sfml_system.c++.txt

                                  ┏━━━━━━━━━━━━━━━━━┓
                                  ┃   SFML_SYSTEM   ┃
                                  ┗━━━━━━━━━━━━━━━━━┛

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

Vector2 <WVAR>          #Vecteur contenant deux valeurs (souvent un abcisse et
                        #une ordonnée)

VECTOR2()               #Constructor vide
VECTOR2(WVAL1, WVAL2)   #VECTOR2.x devient WVAL1, et VECTOR2.y WVAL2 (toutes 
                        #deux de type WVAR)

VECTOR2.x               #Premier élément de VECTOR2.
VECTOR2.y               #Deuxième élément de VECTOR2.

Vector2f                #Spécialisation de Vector2, avec des floats pour WVAR.

Vector3 <WVAR>          #Vecteur contenant trois valeurs (souvent des 
                        #coordonnées tridimensionnelles).

VECTOR3()               #Constructor vide
VECTOR3(WVAL1, WVAL2,   #VECTOR3.x devient WVAL1, VECTOR3.y WVAL2 et VECTOR3.z
WVAL3)                  #WVAL3 (toutes trois de type WVAR)

VECTOR3.x               #Premier élément de VECTOR3.
VECTOR3.y               #Deuxième élément de VECTOR3.
VECTOR3.z               #Troisième élément de VECTOR3.

Vector3f                #Spécialisation de Vector3, avec des floats pour WVAR.

Sleep(FLOAT_VAL)        #Attend FLOAT_VAL secondes.

Randomizer::SetSeed     #La Seed interne devient UINT_VAL. La Seed interne est
(UINT_VAL)              #automatiquement générée de manière pseudo-aléatoire à
                        #chaque lancement du programme. Utiliser cette fonction
                        #ne sert donc qu'à réutiliser une précédente seed.

Randomizer::GetSeed()   #Renvoie la Seed interne, sous forme d'UINT_VAL.
Randomizer::Random      #Renvoie un INT_VAL aléatoire compris entre INT_VAL1 et
(INT_VAL1, INT_VAL2)    #INT_VAL2
Randomizer::Random      #Renvoie un FLOAT_VAL aléatoire compris entre FLOAT_VAL1
(FLOAT_VAL1, FLOAT_VAL2)#et FLOAT_VAL2

THREADS ==>             #Permettent de faire deux actions en parallèle dans le
                        #même programme. Mais il faut prendre garde à ce que
                        #les différents threads ne partagent pas les mêmes
                        #ressources, et utiliser des Mutex sinon. S'ils font des
                        #opérations atomiques sur ces ressources, pas besoin de
                        #Mutex, car ils ne pourront pas partager la ressource en
                        #même temps.

Thread::FuncType        #Typedef vers une VOID_FONC_ADR prenant un seul
                        #argument VOID_ADR (utilisé par THREAD).

Thread                  #Enfant de NonCopyable, désigne un thread. Deux 
                        #utilisations : comme tel, ou utilisé comme une base
                        #classe, en redéfinissant alors Run(). Le deuxième
                        #choix permet une plus grande flexibilité (par exemple
                        #partager plus facilement des variables entre les
                        #threads)

THREAD                  #Construit un THREAD lié à la fonction THREAD::
(THREAD::FUNCTYPE_VAL   #FUNCTYPE_VAL, prenant comme argument VOID_ADR (par 
[, VOID_ADR])           #défaut NULL).

THREAD.Launch()         #Lance la fonction liée à THREAD, avec son argument,
                        #dans un nouveau thread. Le thread lançeant cette
                        #fonction attendra la fin de celle-ci avant de se
                        #terminer lui-même.
THREAD.Wait()           #Attend la fin de la fonction lancée par THREAD.Launch()
THREAD.Terminate()      #Interrompt THREAD. A éviter, car ne laisse pas le
                        #temps à THREAD de nettoyer. Préférer faire une boucle
                        #dans le thread inspectant une BOOL_VAL indiquant si le
                        #thread doit être terminé, et modifier cette BOOL_VAL.
THREAD.Run(void)        #Protected virtual VOID_CLASSFK, à redéfinir si THREAD 
                        #est utilisé comme une base classe : cette fonction se
                        #lancera alors lorsque THREAD.Launch() sera exécuté.

Mutex                   #Enfant de NonCopyable, désignant un Mutex.

MUTEX()                 #Constructor vide.

MUTEX.Lock()            #Locke le MUTEX. Si MUTEX est déjà locked, attends qu'il
                        #soit unlocked avant de le lock à nouveau.
                        #Attention aux deadlocks.
MUTEX.Unlock()          #Unlock MUTEX.

Lock                    #Enfant de NonCopyable, permet de Lock et Unlock un
                        #Mutex. Contrairement à l'utilisation simple d'un Mutex,
                        #si une exception est lancée alors que le MUTEX est
                        #locked, elle attend qu'il soit unlocked.

LOCK(MUTEX)             #Construit LOCK, et locke MUTEX. MUTEX est unlocke par
                        #le destructor de LOCK.

Unicode::Text           #Désigne une chaîne de caractères. Permet d'avoir une
                        #interface unique pour les STR, STRING, WSTRING, etc.

TEXT()                  #Constructor vide.
TEXT(STR)
TEXT(WSTR)
TEXT(STRING)
TEXT(WSTRING)
TEXT(UINT8_ADR)
TEXT(UINT16_ADR)
TEXT(UINT32_ADR)
TEXT(UNICODE::UTF8STRNG)
TEXT(UNICDE::UTF16STRNG)
TEXT(UNICDE::UTF32STRNG)#Le contenu de TEXT devient celui de son argument.
operator STRING()
operator WSTRING()
operator UNICODE::
UTF8STRING()
operator UNICODE::
UTF16STRING()
operator UNICODE::      #TEXT peut être implicitement converti dans n'importe
UTF32STRING()           #lequel de ces types.

Unicode::UTF8String     #Typedef vers std::basic_string<Uint8>
Unicode::UTF16String    #Typedef vers std::basic_string<Uint16>
Unicode::UTF32String    #Typedef vers std::basic_string<Uint32>