sfml_graphics.c++.txt

                                  ┏━━━━━━━━━━━━━━━━━━━┓
                                  ┃   SFML_GRAPHICS   ┃
                                  ┗━━━━━━━━━━━━━━━━━━━┛

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

RenderTarget            #Base classe abstraite pour les classes devant faire 
                        #des rendus graphiques

RENDERTARGET.Clear      #Remplie RENDERTARGET d'une couleur unie COLOR (par
([COLOR])               #défaut noir opaque).

RENDERTARGET.GetWidth() #Renvoie la largeur de RENDERTARGET
RENDERTARGET.GetHeight()#Renvoie la hauteur de RENDERTARGET

RENDERTARGET.Draw       #Blitte DRAWABLE sur RENDERTARGET. Le DRAWABLE blitté
(DRAWABLE)              #n'est plus lié à son DRAWABLE d'origine, ce qui
                        #signifie que modifier l'un ne modifie pas l'autre. Le
                        #DRAWABLE blitté ne peut donc plus être effacé, sauf
                        #superposition d'un autre DRAWABLE, couleur ou autre,
                        #dessus.

RENDERTARGET.SetView    #VIEW devient la VIEW de RENDERTARGET. Il n'y a pas
(VIEW)                  #besoin de le refaire après une modification de VIEW :
                        #RENDERTARGET est mise à jour automatiquement.

RENDERTARGET.GetView()  #Renvoie la VIEW courante.
RENDERTARGET.           #Renvoie la VIEW par défaut, dont le rectangle a la même
GetDefaultView()        #taille que RENDERTARGET, sans compter son 
                        #redimensionnement éventuel. Renvoie une référence. Il
                        #est préférable de modifier la DefaultView plutôt que de
                        #lui en rajouter une nouvelle. La mettre à jour lors
                        #d'un redimensionnement est nécessaire.

RenderWindow            #Enfant de WINDOW et RENDERTARGET, optimisé pour 
                        #l'affichage de graphisme 2D.

RENDERWINDOW()
RENDERWINDOW(ARGS)      #Même constructors que WINDOW.

RENDERWINDOW.Capture()  #Renvoie le contenu de RENDERWINDOW sous forme d'IMAGE.
RENDERWINDOW.           #Toutes les opérations se font par rapport à la
ConvertCoords           #DefaultView, indépendamment des VIEW additionnelles.
(UINT_VAL1, UINT_VAL2   #Il faut donc convertir les coordonnées globales (par 
[, VIEW])               #rapport à la DefaultView) obtenues vers des coordonnées
                        #locales (par rapport à la VIEW additionnelle) : par
                        #exemple le mouvement de souris est renvoyé globalement,
                        #il le faut l'utiliser localement.
                        #Ainsi, les coordonnées globales UINT8_VAL1 et 
                        #UINT8_VAL2 sont renvoyées sous forme de VECTOR2F, pour
                        #des coordonnées locales selon VIEW (par défaut NULL, ce
                        #qui signifie la VIEW actuelle)

Color                   #Couleur (dont transparence).

COLOR()                 #Constructor vide (noir opaque).
COLOR(UINT8_VAL1,       #Construit une COLOR avec une valeur de RGB de
UINT8_VAL2, UINT8_VAL3  #UINT8_VAL1, UINT8_VAL2 et UINT8_VAL3 (0 à 255), et une
[, UINT8_VAL4])         #transparence d'UINT8_VAL4 (255 = opaque).

COLOR += COLOR2         #Additionne COLOR et COLOR2 (comme le mode Addition de
                        #Photoshop)
COLOR *= COLOR2         #Multiplie COLOR et COLOR2 (comme le mode Produit de
                        #Photoshop)

COLOR.r                 #Valeur du rouge de COLOR (0 à 255), sous la forme
                        #d'un UINT8_VAL.
COLOR.g                 #Même chose pour le vert
COLOR.b                 #Même chose pour le bleu
COLOR.a                 #Même chose pour la transparence

Color::Black            #COLOR noire.
Color::White            #COLOR blanche
Color::Red              #COLOR rouge
Color::Green            #COLOR verte
Color::Blue             #COLOR bleue
Color::Yellow           #COLOR jaune
Color::Magenta          #COLOR magenta
Color::Cyan             #COLOR cyan

COLOR == COLOR2
COLOR != COLOR2         #Tests d'égalités.

Blend::Mode             #Enum désignant un mode de fusion.
                        #Valeurs possibles :
Blend::Alpha            #Mode normal, prenant en compte la transparence.
Blend::None             #Mode normal, ne prenant pas en compte la transparence
                        #(la transparence devient du blanc opaque)
Blend::Add              #Comme le mode Add de Photoshop (ajout des valeurs RGB)
Blend::Multiply         #Comme le mode Multiply de Photoshop (multiplication 
                        #des valeurs RGB (ramenées dans le range [0;1]))

Rect <WVAR>             #Désigne une sélection rectangulaire, par rapport à un
                        #DRAWABLE ou une RENDERWINDOW (coordonnées locales). 
                        #Les coordonnées sont exprimées en WVAR. Une Rect dont 
                        #tous les membres sont à 0 sélectionne tout.

RECT()                  #Constructor vide.
RECT(WVAL1, WVAL2,      #Construit un RECT avec un Left de WVAL1, un Top de
WVAL3, WVAL4)           #WVAL2, un Right de WVAL3 et un Bottom de WVAL4.
                        #Si Top > Bottom ou Left > Right, la Width ou la
                        #Height sera négative, mais cela s'affichera normalement
                        #malgré tout. Si Top == Bottom ou Left == Right, rien ne
                        #sera sélectionné.

RECT.Left               #Renvoie les coordonnées (locales par rapport au 
                        #DRAWABLE) du bord gauche de RECT, sous forme de 
                        #référence modifiable. (inclus)
RECT.Top                #Même chose pour le bord supérieur (inclus)
RECT.Right              #Même chose pour le bord droit (exclus)
RECT.Bottom             #Même chose pour le bord inférieur (exclus)

RECT.GetWidth()         #Renvoie la largeur de RECT.
RECT.GetHeight()        #Renvoie la hauteur de RECT.

RECT.Offset(WVAL1, WVL2)#Ajoute WVAL1 à RECT.Left et RECT.Right, et WVAL2 à
                        #RECT.Top et RECT.Bottom.

RECT.Contains(WVAL1,    #Renvoie true si le point dont les coordonnées locales
WVAL2)                  #(par rapport au DRAWABLE) sont WVAL1 et WVAL2 est
                        #sélectionné par RECT.

RECT.Intersects(RECT2   #Renvoie true si RECT et RECT2 partagent une même zone,
[, RECT3_ADR])          #et renvoie cette zone dans RECT3 (par défaut NULL, et
                        #RECT3.Left, Right, Bottom et Top sont 0 si false est
                        #renvoyé).

IntRect                 #Spécialisation de Rect, avec int pour WVAR.

FloatRect               #Spécialisation de Rect, avec float pour WVAR.

Resource <WVAR>         #Classe indiquant qu'une ressource de type WVAR devra
                        #être désallouée à sa destruction.
                        #Leur copie (dont création), est toujours lourde. Ils
                        #sont souvent en oposition avec une deuxième classe
                        #CLASS2 les utilisant, et étant elle légère à copier :
                        #Image / Sprite ; Font / sf::String ; SoundBuffer /
                        #Sound. Pour l'optimisation, il est impératif de :
                        #  - essayer de les passer par référence
                        #  - utiliser la même RESOURCE pour plusieurs CLASS2
                        #  - une CLASS2 dont toutes les instances utilisent
                        #    la même RESOURCE devrait utiliser un singleton de 
                        #    cette RESOURCE (c'est-à-dire une static CLASSDT 
                        #    initiliasée par une static CLASSFK) pour ne 
                        #    créer qu'une fois la RESOURCE.

Image                   #Enfant de Resource<Image>, désigne une image. 
                        #Pour une texture 3D, utiliser une image carré dont les
                        #dimensions en pixels est une puissance de 2.
                        #Extensions supportées : .bmp, .jpg, .png, .tga, .psd,
                        #.dds
                        #Extensions non supportées : .tga, .gif

IMAGE()                 #Constructor vide.
IMAGE(UINT_VAL1,        #Construit IMAGE, puis fait un IMAGE.Create() avec les
UINT_VAL2[, COLOR])     #arguments.
IMAGE(UINT_VAL1,        #Construit IMAGE, puis fait un IMAGE.LoadFromPixels()
UINT_VAL2, UINT8_ADR)   #avec les arguments.

IMAGE.LoadFromFile      #Associe IMAGE à l'image dont le chemin est STRING.
(STRING)            ----| true si succès, false sinon.
IMAGE.Create(UINT_VAL1, #Associe IMAGE à une image dont la largeur est UINT_VAL1
UINT_VAL2[, COLOR])     #et la hauteur UINT_VAL2, remplie de COLOR (par défaut
                        #noir opaque).
                    ----| true si succès, false sinon.
IMAGE.LoadFromPixels    #Associe IMAGE à une image composée des pixels contenus
(UINT_VAL1, UINT_VAL2,  #dans UINT8_ADR (cf GetPixelsPtr()), mais ne prend que
UINT8_ADR)              #les UINT_VAL1 premiers pixels dans la largeur, et les
                        #UINT_VAL2 premiers pixels dans la hauteur.
                        #Il semble qu'UINT_VAL1 doive être >= la largeur de
                        #l'image désignée par UINT8_ADR pour que cela ne bugue
                        #pas.
IMAGE.CopyScreen        #Associe IMAGE à une copie de RENDERWINDOW, tel que
(RENDERWINDW[, INTRECT])#sélectionné par INTRECT (par défaut toute la 
                        #RENDERWINDOW)
                    ----| true si succès, false sinon.
IMAGE.Copy(IMAGE2,      #Blitte IMAGE2, tel que sélectionné par INTRECT (par
UINT_VAL1, UINT_VAL2    #défaut tout IMAGE2), sur IMAGE, à partir du point
[, INTRECT[, BOOL_VAL]])#d'IMAGE dont les coordonnées locales sont UINT_VAL1 et 
                        #UINT_VAL2. Si BOOL_VAL == true, la transparence
                        #d'IMAGE2 est prise en compte, sinon, elle est remplacée
                        #par du blanc opaque (défaut).
                        #Le blittage ne peut pas augmenter les dimensions 
                        #d'IMAGE
IMAGE.SaveToFile(STRING)#Enregistre IMAGE dans le chemin STRING. En fonction de
                        #l'extension de STRING, le format d'enregistrement sera
                        #différent.
                    ----| true si succès, false sinon.

IMAGE.GetPixelsPtr()    #Renvoie un const UINT8_ADR vers un array composé de 
                        #tous les pixels de l'image, sous la forme d'une liste 
                        #de pixels, un pixel étant une suite de 4 UINT8_VAL 
                        #(RGBA). La taille de l'array est donc 4 * 
                        #IMAGE.GetWidth() * IMAGE.GetHeight()

IMAGE.GetWidth()        #Renvoie la largeur d'IMAGE, sous forme d'UINT_VAL
IMAGE.GetHeight()       #Renvoie la hauteur d'IMAGE, sous forme d'UINT_VAL

IMAGE.SetPixel          #
(UINT_VAL1, UINT_VAL2,  #La couleur du pixel se trouvant aux coordonnées
COLOR)                  #(locales) UINT_VAL1, UINT_VAL2 de IMAGE devient COLOR.

IMAGE.GetPixel          #Renvoie la COLOR du pixel se trouvant aux coordonnées
(UINT_VAL1, UINT_VAL2)  #(locales) UINT_VAL1, UINT_VAL2 de IMAGE.

IMAGE.                  #Tous les pixels d'IMAGE dont la couleur est COLOR
CreateMaskFromColor     #auront, jusqu'au prochain appel de CreateMaskFromColor
(COLOR[, UINT8_VAL])    #une transparence d'UINT8_VAL (par défaut 0)

IMAG.SetSmooth(BOOL_VAL)#Si BOOL_VAL est vrai, utilise une interpolation lors du
                        #redimensionnement d'IMAGE (par défaut activé). Peut
                        #parfois produire des contours désagréables lors d'un
                        #rétrécissement.

IMAGE.IsSmooth()        #Renvoie true si l'interpolation est activée.

Drawable                #Désigne une classe devant être affichée sur une
                        #RENDERWINDOW. Ses coordonnées ne sont pas liées à une
                        #RENDERWINDOW précise, mais seront utilisées par ses
                        #dernières via Draw()

DRAWABLE([VECTOR2F1     #Construit un DRAWABLE avec une Position de VECTOR2F1
[, VECTOR2F2[, FLOAT_VAL#(par défaut Vector2f(0,0)), une Scale de VECTOR2F2 
[, COLOR]]]])           #(par défaut Vector2f(1,1)), une Rotation de FLOAT_VAL 
                        #(par défaut 0) et une filtre coloré COLOR (par défaut
                        #blanc opaque).

DRAWABLE.SetX(FLOAT_VAL)#L'abcisse (x) par rapport à la RENDERWINDOW qui le
                        #blittera devient FLOAT_VAL. Les coordonnées (x et y)
                        #ne font pas référence au coin supérieur gauche mais au
                        #centre de DRAWABLE (qui est par défaut le coin
                        #supérieur gauche)
DRAWABLE.SetY(FLOAT_VAL)#Même chose pour l'ordonnée.
DRAWABLE.SetPosition    #
(FLOAT_VAL1, FLOAT_VAL2)
DRAWABLE.SetPosition    #L'abcisse et l'ordonnée par rapport à la RENDERWINDOW
(VECTOR2F)              #deviennent les deux valeurs données en argument.

DRAWABLE.GetPosition()  #Renvoie l'abscisse et l'ordonnée courante, sous forme
                        #de VECTOR2F.

DRAWABLE.GetScale()     #

DRAWABLE.SetScaleX      #
(FLOAT_VAL)
DRAWABLE.SetScaleY      #Comme SetX(), SetY() et SetPosition(), mais appliqué
(FLOAT_VAL)             #au Scale. Un Scale de 1 est normal, de 2 étire par un
DRAWABLE.SetScale       #facteur 2 l'image, etc. Le Scale est absolu, et non
(FLOAT_VAL1, FLOAT_VAL2)#relatif au Scale courant. Le Scale est par rapport au
DRAWABLE.SetScale       #centre du DRAWABLE (l'endroit où il s'étire), et prend 
(VECTOR2F)              #en compte la rotation.

DRAWABLE.SetRotation    #Fait que la rotation (anti-clockwise) de DRAWABLE
(FLOAT_VAL)             #devient FLOAT_VAL degrés (défaut 0). La rotation est
                        #absolue, et non relative à la Rotation courante.

DRAWABLE.GetRotation()  #Renvoie la Rotation courante, sous forme de FLOAT_VAL.

DRAWABLE.SetCenter      #Le x et le y du centre de DRAWABLE devient ces deux
(FLOAT_VAL1, FLOAT_VAL2)#valeurs. Le centre d'un DRAWABLE est relatif au coin
DRAWABLE.SetCenter      #supérieur gauche. Il est par défaut 0 et 0. Il est
(VECTOR2F)              #utilisé comme référence pour SetPosition(), etc., comme
                        #centre de rotation pour SetRotation(), etc., est 
                        #utilisé par SetScale(), etc. pour savoir où l'étirement
                        #va avoir lieu, est utilisé par TransformToLocal() et
                        #TransformToGlobal(), etc.
                        #La nouvelle désignation est absolue, et non relative à
                        #l'ancien centre. Un centre au milieu du DRAWABLE est
                        #souvent utile.
                        #Le Centre fait référence à DRAWABLE avec un Scale de
                        #(1, 1), et n'est pas modifié par le changement du Scale

DRAWABLE.GetCenter()    #Renvoie le Centre courant, sous forme de VECTOR2F

DRAWABLE.Move           #
(FLOAT_VAL1, FLOAT_VAL2)
DRAWABLE.Move(VECTOR2F)
DRAWABLE.Scale          #
(FLOAT_VAL1, FLOAT_VAL2)#Comme SetPosition(), SetScale() et SetRotation(), sauf
DRAWABLE.Scale(VECTOR2F)#que les valeurs ne sont pas absolues, mais relatives à
DRAWBLE.Rotate(FLOAT_VL)#l'ancienne Position, Scale ou Rotation.

DRAWABLE.SetColor(COLOR)#Applique un filtre COLOR sur DRAWABLE. Cela revient à
                        #mettre une couleur unie avec le mode de fusion Produit,
                        #ou à ne garder que le channel de couleur COLOR. C'est
                        #réversible : un nouvel appel avec une nouvelle COLOR ne
                        #tient pas compte des dégradations de l'ancien appel.
                        #Un filtre blanc ne produit donc rien.

DRAWABLE.GetColor()     #Revient le filtre coloré courant, sous forme de COLOR.

DRAWBLE.TransformToLocal#VECTOR2F étant les coordonnées d'un point par rapport
(VECTOR2F)              #à la RENDERWINDOW (coordonnées globales), renvoie les
                        #coordonnées de ce point par rapport au Centre de
                        #DRAWABLE (coordonnées locales).
DRWBLE.TransformToGlobal#VECTOR2F étant les coordonnées d'un point par rapport
(VECTOR2F)              #au Centre de DRAWABLE (coordonnées locales), renvoie
                        #les coordonnées de ce point par rapport à la
                        #RENDERWINDOW (coordonnées globales).

DRAWABLE.SetBlendMode   #Le blend mode de l'image devient BLEND::MODE (par
(BLEND::MODE)           #défaut un DRAWABLE a Blend::Alpha).
DRAWABLE.GetBlendMode() #Renvoie le BLEND::MODE de DRAWABLE.

Sprite                  #Classe, enfant de Drawable, désignant un sprite. Il
                        #doit être blitté sur une RENDERWINDOW, via par
                        #exemple RENDERWINDOW.Draw(). Avant de le blitter, il
                        #faut préciser tous ses paramètres (coordonnées, 
                        #transparence éventuelle, etc.).

SPRITE()                #Constructor vide.
SPRITE(IMAGE[, VECTOR2F1#Même constructor que DRAWABLE, sauf pour le premier
[, VECTOR2F2[, FLOAT_VL #argument : une SPRITE.SetImage(IMAGE) est donc     
[, COLOR]]]])           #effectué.

SPRITE.SetImage(IMAGE)  #Sprite devient associé à l'image IMAGE.

SPRITE.GetImage()       #Renvoie l'IMAGE associée à SPRITE.

SPRITE.FlipX(BOOL_VAL)  #Si BOOL_VAL est true, SPRITE est retourné selon une
                        #symétrie axiale horizontale. Prend en compte le milieu
                        #de SPRITE et non son Centre. BOOL_VAL est absolu et ne
                        #prend pas en compte le précédent état de symétrie de
                        #SPRITE : faire deux fois de suite FlipX() avec le même
                        #BOOL_VAL est donc redondant.
SPRITE.FlipY(BOOL_VAL)  #Même chose, mais vertical.

SPRITE.GetPixel         #Renvoie la COLOR du pixel se trouvant aux coordonnées
(UINT_VAL1, UINT_VAL2)  #(locales) UINT_VAL1, UINT_VAL2 de SPRITE.

SPRITE.Resize           #La longuer et la largeur (en pixels) de SPRITE sont
(FLOAT_VAL1, FLOAT_VAL2)#ajustées en conséquence, en changeant la ScaleX et la
SPRITE.Resize(VECTOR2F) #ScaleY (cette opération n'est donc pas destructrice)

SPRITE.GetSize()        #Renvoie sous forme de VECTOR2F la longueur et la
                        #hauteur de SPRITE (en pixels).

SPRITE.SetSubRect       #Seuls les pixels de SPRITE sélectionnés par INTRECT
(INTRECT)               #seront affichés. Annule un précédent SetSubRect()
SPRITE.GetSubRect()     #Renvoie la sélection courante, sous forme d'INTRECT
                        #(à l'origine le SPRITE entier)

Shape                   #Enfant de DRAWABLE.
                        #Définit un forme convexe (une forme concave donne des
                        #problèmes de rendu, utiliser plusieurs formes convexes
                        #pour produire une forme concave) à partir d'un ensemble
                        #de points ayant chacun des coordonnées (locales, par
                        #rapport au Center de SHAPE), une couleur et une couleur
                        #de contour. La forme doit contenir au moins trois 
                        #points. Un degradé rempli son milieu, dont la couleur
                        #dépend de la couleur de chaque sommet. L'épaisseur du
                        #contour est par défaut 0. Un degradé de couleur entre
                        #chaque sommet pour le contour est aussi effectué, en
                        #fonction des couleurs de contour des sommets.
                        #Les sommets sont numérotés seront leur ordre d'ajout,
                        #de 0 à infini.
                        #Je ne crois qu'il soit possible d'avoir des SHAPE
                        #anti-aliased.

SHAPE()                 #Constructor vide.

SHAPE.AddPoint          #
(FLOAT_VAL1, FLOAT_VAL2 
[, COLOR1[, COLOR2]])   #Rajoute un sommet avec les coordonnées indiquées, une
SHAPE.AddPoint(VECTOR2F #couleur COLOR1 (par défaut blanc opaque), et une
[, COLOR1[, COLOR2]])   #couleur de contour COLOR2 (par défaut noir opaque)
SHAPE.SetPointPosition  #
(UINT_VAL, FLOAT_VAL1,
FLOAT_VAL2)             

SHAPE.SetPointPosition  
(UINT_VAL, VECTOR2F)    #Modifie les coordonnées du sommet numéro UINT_VAL.

SHAPE.GetPointPosition  #Renvoie les coordonnées du sommet numéro UINT_VAL sous
(UINT_VAL)              #forme de VERTOR2F.

SHAPE.SetPointColor     #
(UINT_VAL, COLOR)       #La couleur du sommet numéro UINT_VAL devient COLOR.

SHAPE.GetPointColor     #
(UINT_VAL)              #Renvoie la COLOR du sommet numéro UINT_VAL.

SHAPE.                  #
SetPointOutlineColor    #La couleur du contour du sommet numéro UINT_VAL 
(UINT_VAL, COLOR)       #devient COLOR.

SHAPE.                  #
GetPointOutlineColor    
(UINT_VAL)              #Renvoie la COLOR de contour du sommet numéro UINT_VAL.

SHAPE.SetOutlineWidth   #
(FLOAT_VAL)             #L'épaisseur de contour devient FLOAT_VAL pixels.

SHAPE.GetOulineWidth()  #Renvoie l'épaisseur de contour sous forme de FLOAT_VAL.

SHAPE.EnableFill        #Si BOOL_VAL == false, la couleur principale (hors
(BOOL_VAL)              #contour) n'est plus dessinée. Sinon, rétablit
                        #l'affichage de cette couleur.
SHAPE.EnableOutline     #Si BOOL_VAL == false, le contour n'est plus affiché.
(BOOL_VAL)              #Sinon, rétablit l'affichage du contour.

SHAPE.GetNbPoints()     #Renvoie le nombre de sommets, sous forme d'UINT_VAL

Shape::Line(FLOAT_VAL1, #
FLOAT_VAL2, FLOAT_VAL3,
FLOAT_VAL4, FLOAT_VAL5,
COLOR1[, FLOAT_VAL6     #Renvoie une SHAPE composé de quatre sommets dessinant
[, COLOR2]])            #une ligne avec les coordonnées indiquées par les
Shape::Line(VECTOR2F1,  #premiers arguments, une épaisseur de FLOAT_VAL5 pixels,
VECTOR2F2, FLOAT_VAL5,  #une épaisseur de contour de FLOAT_VAL6 pixels (par
COLOR1[, FLOAT_VAL6     #défaut 0), une couleur COLOR1 et une couleur de contour
[, COLOR2]])            #COLOR2 (par défaut noir opaque)
Shape::Rectangle        #
(FLOAT_VAL1, FLOAT_VAL2,
FLOAT_VAL3, FLOAT_VAL4,
COLOR1[, FLOAT_VAL6
[, COLOR2]])            
Shape::Rectangle
(VECTOR2F, FLOAT_VAL3,
FLOAT_VAL4, COLOR1
[, FLOAT_VL6[, COLOR2]])#Même chose, mais pour un rectangle
Shape::Circle(FLOAT_VL1,#
FLOAT_VAL2, FLOAT_VAL3,
COLOR1[, FLOAT_VAL6
[, COLOR2]])
Shape::Circle(VECTOR2F, #Même chose, mais pour un cercle. Les premiers arguments
FLOAT_VAL3, COLOR1      #sont les coordonnées du centre, et FLOAT_VAL3 le rayon
[, FLOAT_VL6[, COLOR2]])#(en pixels)

Font                    #Enfant de Resource <Font>, désignant une police. On
                        #peut faire un parallèle entre Font / sf::String et
                        #Image / Sprite.
                        #FONT est en fait une image composé d'un ensemble de 
                        #glyphes concaténés d'une police donnée à une taille 
                        #donnée.
                        #Extensions supportées : .ttf, .cff, .pcf, .fnt, .bdf, 
                        #.pfr, .sfnt, type 1, type 42

FONT()                  #Constructor vide.

FONT.LoadFromFile       #Associe FONT à la police dont le chemin est STRING.
(STRING[, UINT_VAL      #Utilise Freetype : quasiment toutes les polices sont
[, UNICODE::TEXT]])     #supportées.
                        #La character size de FONT est UINT_VAL (par défaut 30).
                        #Il ne s'agit pas de la taille de la SF::STRING, mais de
                        #sa taille maximale sans perte de qualité. Si la taille
                        #de la SF::STRING == character size de FONT, la
                        #qualité est parfaite, si elle est >, il y a une grosse
                        #perte, si elle est <, il y a une légère perte.
                        #Plus la character size est grande, plus la FONT est
                        #lourde à se charger.
                        #UNICODE::TEXT désigne l'ensemble de glyphes à charger,
                        #(par défaut l'ensemble des caractères de Latin1).

FONT.GetCharacterSize() #Renvoie la character size de FONT.
FONT.GetImage()         #Renvoie l'ensemble des glyphes concaténés sous forme 
                        #d'IMAGE.

Font::GetDefaultFont()  #Renvoie une FONT builtin (Arial)

String::Style           #Enum désignant le style des caractères d'une SF::STRING
                        #Valeurs possibles :
String::Regular         #Pas de mise en forme
String::Bold            #Gras
String::Italic          #Italique
String::Underlined      #Souligné

sf::String              #(Je met sf:: pour la distinguer de std::string).
                        #Enfant de Drawable, désigne un message affichable.

SF::STRING()            #Constructor vide.
SF::STRING(UNICODE::TEXT#Construit un SF::STRING dont le message est
[, FONT[, FLOAT_VAL]])  #UNICODE::TEXT, avec la police FONT (par défaut Font::
                        #GetDefaultFont()), avec une taille de caractères de 
                        #FLOAT_VAL pixels (par défaut 30).

SF::STRING.SetText      #
(UNICODE::TEXT)         #Le message de SF::STRING devient UNICODE::TEXT.

SF::STRING.GetText()    #Renvoie le message de SF::STRING, sous forme
                        #d'UNICODE::TEXT

SF::STRING.SetFont(FONT)#La police de SF::STRING devient FONT

SF::STRING.GetFont()    #Renvoie la polive de SF::STRING sous forme de FONT

SF::STRING.SetSize      #La taille des caractères de SF::STRING devient 
(FLOAT_VAL)             #FLOAT_VAL

SF::STRING.GetSize()    #Renvoie la taille des caractères de SF::STRING sous
                        #forme de FLOAT_VAL.

SF::STRING.SetStyle     #Le style de SF::STRING devient ULONG_VAL, où ULONG_VAL
(ULONG_VAL)             #est une suite de STRING::STYLE or'd.

SF::STRING.GetStyle()   #Renvoie le style de SF::STRING sous forme d'ULONG_VAL

SF::STRING.GetRect()    #Renvoie les coordonnées globales de la "bounding box" 
                        #de STRING sous forme de FLOATRECT.
SF::STRING.             #Renvoie les coordonnées locales du coin supérieur
GetCharacterPos         #gauche de la lettre numéro SIZE_T_VAL (en partant de 0)
(SIZE_T_VAL)            #de SF::STRING, par rapport à son Center donc.
                        #(convertir éventuellement avec TransformToGlobal())

View                    #Désigne une sorte de caméra. Il s'agit d'un rectangle
                        #lié à une RENDERWINDOW, et la RENDERWINDOW, plutôt que
                        #d'afficher normalement son contenu, zoome ou dézoome,
                        #et scroll pour contenir le rectangle, en respectant
                        #son ratio (RENDERWINDOW est donc déformé si VIEW n'a
                        #pas un ratio 1:1). Cependant, toutes les opérations
                        #restent relatives à la VIEW par défaut (dont le 
                        #rectangle est le même que la RENDERWINDOW de départ),
                        #même VIEW.move(). La VIEW doit être attachée à la
                        #RENDERWINDOW.

VIEW([FLOATRECT])       #Construit une VIEW dont le rectangle est FLOATRECT.
VIEW(VECTOR2F1,         #Construit une VIEW dont le centre du rectangle a les
VECTOR2F2)              #coordonnées VECTOR2F1, dont la moitié de la largeur est
                        #VECTOR2F2.x et la moitié de la hauteur VECTOR2F2.y

VIEW.SetCenter          #
(FLOAT_VAL1, FLOAT_VAL2)
VIEW.SetCenter          
(VECTOR2F)              #Le centre de VIEW a désormais les coordonnées indiquées

VIEW.GetCenter()        #Renvoie le centre de VIEW sous forme de VECTOR2F

VIEW.SetHalfSize        #
(FLOAT_VAL1, FLOAT_VAL2)
VIEW.SetCenter          #La moitié de la largeur et de la hauteur de VIEW sont
(VECTOR2F)              #modifiées telles qu'indiqué.

VIEW.GetHalfSize()      #Renvoie la moitié de la largeur et de la hauteur de 
                        #VIEW sous forme de VECTOR2F

VIEW.SetFromRect        #
(FLOATRECT)             #Le rectangle de VIEW devient FLOATRECT.

VIEW.GetRect()          #Renvoie le rectangle de VIEW

VIEW.Move(FLOAT_VAL1,   #
FLOAT_VAL2)             #Déplace le rectangle de VIEW du nombre de pixels 
VIEW.Move(VECTOR2F)     #indiqués (indépendamment du zoom)
VIEW.Zoom(FLOAT_VAL)    #Rétrécie le rectangle de VIEW d'un facteur FLOAT_VAL
                        #(si FLOAT_VAL > 1, zoome, sinon dézoome)