sfml_window.c++.txt

                                  ┏━━━━━━━━━━━━━━━━━┓
                                  ┃   SFML_WINDOW   ┃
                                  ┗━━━━━━━━━━━━━━━━━┛

HEADER ==>              #<SFML/Window.hpp>

OPENGL ==>              #<SFML/Windows.hpp> inclue les headers d'OpenGL et GLU
                        #automatiquement.
                        #Pour inclure de l'OpenGL : ne pas oublier de faire un
                        #WINDOW.SetActive() à chaque itération de la boucle.
DOUBLE BUFFERING ==>    #SFML utilise par défaut le double buffering. Ainsi,
                        #les images sont d'abord dessinées dans un frame buffer,
                        #puis affichées. Ainsi, l'affichage de chaque image est
                        #instantané. Sinon, l'affichage de chaque image serait
                        #progressif, ce qui produirait un mauvais effet visuel.
FRAME RATE ==>          #Le frame rate est égal à 1 / temps pour dessiner une
                        #frame.
                        #Cela signifie que les frames ne sont pas affichées avec
                        #un interval fixe : c'est pourquoi il est intéressant
                        #de limiter le frame rate au taux de rafraîchissement
                        #de l'écran (vsync, ou synchronisation verticale).
                        #Ainsi, par exemple pour un taux de rafraîchissement de 
                        #60 images / secondes :
                        #  - si une frame se dessine en moins de 1/60 secondes,
                        #    il y aura un léger temps d'attente avant la
                        #    prochaîne frame, et l'animation sera fluide et
                        #    régulière
                        #  - sinon, le FPS sera inférieur au taux de 
                        #    rafraîchissement de l'écran et l'animation sera
                        #    saccadée. Il faut donc alléger l'animation pour
                        #    qu'elle se dessine plus vite, ou forcer un FPS
                        #    maximum plus faible (SetFramerateLimit())

Uint8                   #Typedef vers uint8_t
Uint16                  #Typedef vers uint16_t
Uint32                  #Typedef vers uint32_t
Int8                    #Typedef vers int8_t
Int16                   #Typedef vers int16_t
Int32                   #Typedef vers int32_t

NonCopyable             #Base classe désignant une classe ne pouvant pas 
                        #utiliser de copy constructor ou copy operator.

WindowListener          #Base classe désignant une classe pouvant accueillir des
                        #événements.

Window                  #Enfant de NonCopyable et de WindowListener.
                        #Désigne une fenêtre.

WINDOW()                #Constructor par défaut
WINDOW(ARGS)            #Equivaut à WINDOW() suivi de WINDOW.Create(ARGS)

WINDOW.Create(VIDEOMODE,#Associe WINDOW à VIDEOMODE, avec le titre STRING,
STRING[, STYLE          #le style STYLE (par défaut sf::Resize | sf::Close) et
[, WINDOWSETTINGS]]     #WINDOWSETTINGS (par défaut WINDOWSETTINGS()).
                        #Modifie les anciens paramètres si Create() a déjà été
                        #appelé.
WINDOW.Display()        #Met à jour WINDOW.
WINDOW.Close()          #Ferme (et détruit) WINDOW.

WINDOW.IsOpened()       #Renvoie true si WINDOW est ouvert. Utile dans une
                        #boucle while, qui sera fermée par un WINDOW.Close()
                        #La boucle est typiquement terminée par des Clear(),
                        #suivis de Draw(), suivi de Display().

WINDOW.Show(BOOL_VAL)   #Cache WINDOW si BOOL_VAL est false, la remontre sinon
                        #(si elle a été précédemment cachée)
WINDOW.ShowMouseCursor  #Cache le curseur s'il survole WINDOW, si BOOL_VAL est 
(BOOL_VAL)              #false. Le remontre sinon (s'il a été précédemment 
                        #caché)

WINDOW.GetWidth()       #Renvoie la longueur de WINDOW, sous forme d'UINT_VAL
WINDOW.GetHeight()      #Renvoie la hauteur de WINDOW, sous forme d'UINT_VAL
WINDOW.GetSettings()    #Renvoie le WINDOWSETTINGS de WINDOW.

WINDOW.GetEvent(EVENT)  #S'il y a un événement dans la file d'attente, le place
                        #dans EVENT, le retire de la file d'attente et renvoie
                        #true. Sinon, ne fait rien (n'attend pas) et renvoie
                        #false.
                        #Comme il peut y avoir plusieurs EVENT dans la file
                        #d'attente, il faut mettre cette fonction dans une
                        #boucle while et non dans un if.
WINDOW.GetInput()       #Renvoie l'INPUT associé à WINDOW. Doit être affectée
                        #à un const et référence INPUT, lors de son 
                        #initialisation

WINDOW.SetPosition      #La position de WINDOW devient x = UINT_VAL1 et y =
(UINT_VAL1, UINT_VAL2)  #UINT_VAL2 pixels (par rapport à l'écran)
WINDOW.SetCursorPosition#La position du curseur devient x = UINT_VAL1 et y =
(UINT_VAL1, UINT_VAL2)  #UINT_VAL2 pixels (par rapport à WINDOW) (même si le
                        #curseur ne survole pas WINDOW)
WINDOW.SetSize          #La longueur et la hauteur de WINDOW deviennent
(UINT_VAL1, UINT_VAL2)  #UINT_VAL1 et UINT_VAL2.
WINDOW.SetFramerateLimit#Fixe une limite supérieure au FPS (Frame per Second) de
(UINT_VAL)              #UINT_VAL FPS (j'ai pour ma part toujours 60 FPS).
WINDOW.GetFrameTime()---#Renvoie le nombre de secondes (en général inférieur à
                        #1), sous forme de FLOAT_VAL, écoulé depuis la dernière
                        #frame. Permet de calculer le FPS, mais surtout doit
                        #être utilisé comme facteur multipliant pour que
                        #l'application se déroule de la même manière quel que
                        #soit le FPS. Par exemple, si un personnage doit bouger
                        #de INT_VAL à chaque fois qu'une touche est appuyée,
                        #faire : POSITION += INT_VAL * WINDOW.GetFrameTime()
WINDOW.EnableKeyRepeat  #Si BOOL_VAL == false, désactive la répétition des 
(BOOL_VAL)              #touches, qui fait qu'un événement KeyPressed est lancé
                        #à interval régulier si une touche est maintenue
                        #(activé par défaut). Sinon, le réactive (s'il a été
                        #précédemment désactivé)
WINDOW.UseVerticalSync  #Si BOOL_VAL == true, active la synchronisation
(BOOL_VAL)              #verticale (désactivée par défaut (cependant, pour moi,
                        #cela semble activé)). Cela signifie que les FPS sont 
                        #limitées au taux de rafraîchissement de l'écran. C'est 
                        #une bonne chose, car plus de FPS ne change donc pas
                        #la fluidité de l'image, mais peut produire des 
                        #problèmes si les FPS sont trop grandes.
                        #Sinon, la désactive.

VideoMode               #Désigne la résolution et définition d'un écran.

VIDEOMODE()             #Constructor vide.
VIDEOMODE(UINT_VAL1,    #Construit un VIDEOMODE avec une Width de UINT_VAL1
UINT_VAL2[, UINT_VAL3]) #pixels, une Height de UINT_VAL2 pixels et une
                        #définition de UINT_VAL3 bits/pixels (par défaut 32)

VideoMode::             #Renvoie le VIDEOMODE utilisé par la configuration
SetDesktopMode()        #actuelle.
VideoMode::             #Renvoie le nombre de VIDEOMODE disponibles pour la
GetModesCount()         #configuration actuelle
VideoMode::             #Renvoie le VIDEOMODE numéro SIZE_T_VAL de la
GetMode(SIZE_T_VAL)     #configuration actuelle. SIZE_T_VAL doit être inférieur
                        #à VideoMode::GetModesCount(). Plus SIZE_T_VAL est
                        #petit, plus la résolution et définition sont bonnes.
VIDEOMODE.IsValid()     #Renvoie true si VIDEOMODE est supporté par la
                        #configuration actuelle.
VIDEOMODE == VIDEOMODE2
VIDEOMODE != VIDEOMODE2 #Tests d'égalité

VIDEOMODE.Height        #Hauteur de l'écran (pixels), sous forme d'UINT_VAL
VIDEOMODE.Width         #Largeur de l'écran (pixels), sous forme d'UINT_VAL
VIDEOMODE.BitsPerPixel  #Définition de l'écran (bits/pixels), sous forme 
                        #d'UINT_VAL

Style                   #Enum désignant un style de fenêtre, relatif notamment 
                        #à sa titlebar et ses borders. Il est constitué de l'un
                        #de ces flags (seul Close peut être or'd) :
Style::None             #Pas de bordure ni de titlebar
Style::Titlebar         #Titlebar, bords non resizables et minimize button
Style::Resize           #Titlebar, bords resizables et maximize/minimize button.
Style::Close            #Titlebar et close button.
Style::Fullscreen       #Plein écran

WindowSettings          #Classe désignant des paramètres d'une Window.

WINDOWSETTINGS([UINT_VL1#Construit WINDOWSETTINGS avec un DepthBits d'UINT_VAL1
[, UINT_VAL2            #(par défaut 24) un StencilBits d'UINT_VAL2 (par défaut
[, UINT_VAL3]]])        #8) et un AntialiasingLevel d'UINT_VAL3 (par défaut 0).
                        #Utile pour OpenGL.

WINDOWSETTINGS.DepthBits#Nombre de bits du depth buffer.
WINDOWSETTINGS.
StencilBits             #Nombre de bits du stencil buffer.
WINDOWSETTINGS.
AntialiasingLevel       #Niveau d'anti-aliasing (multisampling)

EventType               #Enum désignant un événement relatif à une WINDOW. 
                        #Valeurs possibles :
Event::Closed           #Fermeture de la fenêtre
Event::Resized          #Redimensionnement de la fenêtre. Lors d'un 
                        #redimensionnement, faire toujours un :
                        #  - WINDOW.GetDefaultView().SetFromRect
                        #    (sf::FloatRect(0, 0, EVENT.Size.Width,
                        #    EVENT.Size.Height));
                        #Sinon la View courante n'est pas mise à jour, et les
                        #Sprites par exemple sont déformés.
                        #Avec OpenGL, il peut être utile aussi de faire un :
                        #  - glViewport(0, 0, EVENT.Size.Width,
                        #    EVENT.Size.Height);
Event::KeyPressed       #Touche appuyée
Event::KeyReleased      #Touche relâchée
Event::TextEntered      #Touche pressée, et cette touche désigne un caractère
                        #imprimable (dont whitespaces)
Event::
MouseButtonPressed      #L'un des boutons de la souris (dont molette) pressé
Event::
MouseButtonReleased     #L'un des boutons de la souris (dont molette) relâché
Event::MouseWheelMoved  #Molette bougée (seules les molettes verticales sont
                        #supportées)
Event::MouseMoved       #Souris déplacée.
Event::MouseEntered     #Souris au-dessus (pas forcément focus)
Event::MouseLeft        #Souris plus (et non "pas") au-dessus (pas forcément
                        #plus de focus)
Event::LostFocus        #Perte de focus
Event::GainedFocus      #Focus
Event::JoyButtonPressed #Bouton de manette ou joystick pressé
Event::JoyButtonReleased#Bouton de manette ou joystick relâchée
Event::JoyMoved         #
Event::Count            #Nombre total de valeurs possibles pour un EVENTTYPE

Key::Code               #Enum désignant la valeur d'une touche.
                        #Valeurs possibles :
Key::A                  #Lettre A. La casse n'importe pas (elle doit être
                        #checkée avec KEYEVENT.Shift)
Key::Num0               #Chiffre 0, sans le numpad. Même chose pour les autres
                        #chiffres.
Key::Numpad0            #Chiffre 0, avec le numpad. Même chose pour les autres
                        #chiffres.
Key::F1                 #F1. Même chose pour F2, etc.
Key::Escape             #
Key::Menu               #
Key::LBracket           #
Key::RBracket           #
Key::SemiColon          #
Key::Comma              #
Key::Period             #
Key::Quote              #
Key::Slash              #
Key::BackSlash          #
Key::Tilde              #
Key::Equal              #
Key::Dash               #
Key::Space              #
Key::Return             #
Key::Back               #
Key::Tab                #
Key::PageUp             #
Key::PageDown           #
Key::End                #
Key::Home               #
Key::Insert             #
Key::Pause              #
Key::Count              #
Key::Delete             #Self-explicit
Key::Left               #
Key::Right              #
Key::Up                 #
Key::Down               #Arrows
Key::LControl           #
Key::LShift             #
Key::LAlt               #
Key::LSystem            #L'une de ces touches, à gauche de la barre espace.
Key::RControl           #
Key::RShift             #
Key::RAlt               #
Key::RSystem            #L'une de ces touches, à droite de la barre espace.
Key::Add                #
Key::Subtract           #
Key::Multiply           #
Key::Divide             #L'une de ces opérations, avec le numpad

KeyEvent                #Struct si EVENT.Type == Event::KeyPressed ou 
                        #KeyReleased

KEYEVENT.Code           #KEY::CODE de KEYEVENT
KEYEVENT.Alt            #True si Alt a été pressé
KEYEVENT.Control        #True si Ctrl a été pressé
KEYEVENT.Shift          #True si Shift a été pressé

TextEvent               #Struct si EVENT.Type == Event::TextEntered

TEXTEVENT.Unicode       #Renvoie le caractère tapé, encodé en UTF-16, sous
                        #forme d'UINT32_VAL (en théorie, car dans la pratique,
                        #cela me renvoie du Latin-1)

MouseMoveEvent          #Struct si EVENT.Type == Event::MouseMoved

MOUSEMOVEEVENT.X        #Renvoie les coordonnées (abscisse) de la souris, par
                        #rapport à la WINDOW
MOUSEMOVEEVENT.Y        #Renvoie les coordonnées (ordonnée) de la souris, par
                        #rapport à la WINDOW

Mouse::Button           #Enum désignant quel bouton de souris a été cliqué.
                        #Valeurs possibles :
Mouse::Left             #Clic gauche
Mouse::Right            #Clic droit
Mouse::Middle           #Clic du milieu
Mouse::XButton1         #Clic avec XButton1 (extra bouton sur certaines souris,
                        #souvent utilisé pour Précédent)
Mouse::XButton2         #Clic avec XButton2 (extra bouton sur certaines souris,
                        #souvent utilisé pour Suivant)
Mouse::ButtonCount      #Renvoie le nombre de boutons de souris disponibles (5).

MouseButtonEvent        #Struct si EVENT.Type == Event::MouseButtonPressed ou
                        #MouseButtonReleased

MOUSEBUTTONEVENT.Button #Renvoie le MOUSE::BUTTON associé à MOUSEBUTTONEVENT
MOUSEBUTTONEVENT.X      #Renvoie les coordonnées (abscisse) de la souris, par
                        #rapport à la WINDOW
MOUSEBUTTONEVENT.Y      #Renvoie les coordonnées (ordonnée) de la souris, par
                        #rapport à la WINDOW

MouseWheelEvent         #Struct si EVENT.Type == Event::MouseWheelEvent

MOUSEWHEELEVENT.Delta   #Déplacement de la molette, sous forme d'INT_VAL

JoyMoveEvent            #Struct si EVENT.Type == Event::JoyMoved. A remplir

JoyButtonEvent          #Struct si EVENT.Type == Event::JoyButtonPressed ou
                        #JoyButtonReleased. A remplir

SizeEvent               #Struct si EVENT.Type == Event::Resized

SIZEEVENT.Width         #Nouvelle Width, sous forme d'UINT_VAL
SIZEEVENT.Height        #Nouvelle Height, sous forme d'UINT_VAL

Event                   #Union désignant un événement. S'utilise de deux 
                        #manières :
                        #  - via EVENT.Type
                        #  - via l'un des EVENT.Key, EVENT.Text, etc. en 
                        #    fonction de l'EVENT.Type

EVENT.Type              #Renvoie l'EVENTTYPE associé à EVENT (possibilités, avec
                        #Event:: avant : Closed, Resized, KeyPressed, 
                        #KeyReleased, TextEntered, MouseButtonPressed, 
                        #MouseButtonReleased, MouseWheelMoved, MouseMoved, 
                        #MouseEntered, MouseLeft, LostFocus, GainedFocus, 
                        #JoyButtonPressed, JoyButtonReleased, JoyMoved.
EVENT.Key               #Renvoie le KEYEVENT associé à EVENT (Key::Code :
                        #namespace Key::)
EVENT.Text              #Renvoie le TEXTEVENT associé à EVENT.
EVENT.MouseMove         #Renvoie le MOUSEMOVEEVENT associé à EVENT.
EVENT.MouseButton       #Renvoie le MOUSEBUTTONEVENT associé à EVENT 
                        #(Mouse::Button : namespace Mouse::)
EVENT.MouseWheel        #Renvoie le MOUSEWHEELEVENT associé à EVENT.
EVENT.JoyMove           #Renvoie le JOYMOVEEVENT associé à EVENT.
EVENT.JoyButton         #Renvoie le JOYBUTTONEVENT associé à EVENT.
EVENT.Size              #Renvoie le SIZEEVENT associé à EVENT.

Input                   #Enfant de NonCopyable et de WindowListener.
                        #Classe permettant de regarder l'état de la souris ou
                        #joystick axis, d'une touche ou d'une clic de souris 
                        #pressé pour une WINDOW donnée, sans forcément attendre 
                        #qu'un événement survienne. Utiliser WINDOW.GetInput()
                        #Préférer utiliser des INPUT pour réagir à un événement
                        #plutôt que des EVENT.

INPUT()                 #Contructor vide.
INPUT.IsKeyDown         #Renvoie true si KEY::CODE est actuellement pressé
(KEY::CODE)
INPUT.IsMouseButtonDown #Renvoie true si MOUSE::BUTTON est actuellement pressé
(MOUSE::BUTTON)
INPUT.GetMouseX()       #Renvoie la position (abscisse, par rapport à WINDOW) de
                        #la souris.
INPUT.GetMouseY()       #Renvoie la position (ordonnée, par rapport à WINDOW) de
                        #la souris.
INPUT.
IsJoystickButtonDown    #
(UINT_VAL1, UINT_VAL2)  #?????
INPUT.GetJoystickAxis   #
(UINT_VAL1, JOY::AXIS)  #?????

Clock                   #Timer (chronomètre). Se lance lors de sa construction.

CLOCK()                 #Constructor vide

CLOCK.GetElapsedTime()  #Renvoie le temps écoulé, en secondes, sous forme de
                        #FLOAT_VAL

CLOCK.Reset()           #Relance le chrono à zero.