[DEBUTANT] Diverses Questions [Résolu]

[NoIdea]

Bonjour a tous, je de passer de SDL a SFML aujourd'hui et j'ai plusieurs questions :

-Lorsqu'on passe de mode fenêtré a plein écran, est on obligé de détruire la fenêtre ? (Il me semble que la méthode create détruit ma fenêtre puis la reconstruit). Ceci à le défaut de faire un flash pas très agréable.

-Y a t-il l'équivalent d'un Blit en SDL ? J'ai cherché, et il me semble que l'on est obligé de Draw sur la RenderWindow. (Cette question est juste pour mes projets futurs)

-En dernier, peut-on désactiver le "auto zoom" lors d'un évènement resize ? (sans se fatiguer avec les vues OpenGL) cad : Lors d'un resize, les objets ne sont pas automatiquement étirés.

Merci de répondre à mes questions. Cette Bibliothèque surpasse toutes celles que j'ai essayées mis a part sur la gestion des event ou je la trouve on peu légère.

[LittleWhite]

Bonjour,

Moi je ne suis pas encore passer à la SFML, mais il me semblait possible de répondre à quelques points.

Envoyé par NoIdea

-Lorsqu'on passe de mode fenêtré a plein écran, est on obligé de détruire la fenêtre ? (Il me semble que la méthode create détruit ma fenêtre puis la reconstruit). Ceci à le défaut de faire un flash pas très agréable.

J'ai encore vu aucune programme passer entre les deux modes sans flash, donc je pense que oui, on est oublier de faire cette étape de destruction / recréation.

-Y a t-il l'équivalent d'un Blit en SDL ? J'ai cherché, et il me semble que l'on est obligé de Draw sur la RenderWindow. (Cette question est juste pour mes projets futurs)

Je pense que c'est le draw ( car le blit de la SDL était souvent utilisé pour juste copier une surface sur l'écran )

Note: L'auteur de la SFML surveille quelque fois ce forum

[NoIdea]

Quand je disais blit je voulais dire blit Image/Image ou Sprite/Sprite et non Sprite/Ecran. Merci pour cette précision au niveau du "flash".

[EDIT]

J'ai encore vu aucune programme passer entre les deux modes sans flash, donc je pense que oui, on est oublier de faire cette étape de destruction / recréation.

Je ne sais pas si il y a réellement un passage en plein écran d'un point de vue hardware, mais quand je fais (sur mozilla firefox) Affichage->plein écran ou F11, je n'ai pas de flash et j'ai bel et bien La barre de titre (avec la croix) qui disparait ainsi que la barre des taches.

[LittleWhite]

Ce que vous dites pour firefox, c'est juste qu'il enlève certaine spécificité de la fenêtre ( la barre des titres, et des menus ... ) après, y a pas de changement de résolution ( je veux dire, que d'un point de vue technique il est toujours en windowed, sauf qu'il occupe tout l'écran ( ou presque )

[Laurent Gomila]

En effet, le vrai mode plein écran n'a rien à voir avec certaines applications qui ne font que retirer les bordures et maximiser leur fenêtre. Ce qui flashe, c'est le changement de résolution : si tu utilises la même résolution que ton bureau normalement ça devrait être plus "smooth".

-Y a t-il l'équivalent d'un Blit en SDL ? J'ai cherché, et il me semble que l'on est obligé de Draw sur la RenderWindow. (Cette question est juste pour mes projets futurs)

Dans SFML 1 tu peux copier des pixels d'une image sur une autre, avec la fonction Image::Copy.
Dans SFML 2, tu peux faire du vrai rendu sur image avec la classe RenderImage.

-En dernier, peut-on désactiver le "auto zoom" lors d'un évènement resize ? (sans se fatiguer avec les vues OpenGL) cad : Lors d'un resize, les objets ne sont pas automatiquement étirés.

Il suffit de redimensionner la vue courante à chaque évènement Resized, pour qu'elle soit toujours de la même taille que la fenêtre. Tu devrais trouver un exemple dans la doc ou sur le forum officiel.

[NoIdea]

Merci pour ces réponses, mais peut-on avec la SFML supprimer les bordures et imiter Firefox pour le mode pleine écran (cad ne pas faire un plein écran).
Toutefois, quand je regarde la méthode de redimensionnement de mon IDE, je remarque qu'elle est progressive :
Aujourd'hui, avec la SFML, lorsqu'on Resize la fenêtre, l'évènement n'est émit que lorsque l'utilisateur relâche la souri.
Avec mon IDE (CodeBlocks), le redimensionnement est progressif : l'évènement resize doit être émit alors qu'on n'a pas encore relâcher la souri car on voit le redimensionnement de la fenetre avant même d'avoir relacher la souri.
Est-ce possible avec la SFML ?

[EDIT] J'ai remarquer que l'évènement resize apparaissais de nombreuses fois une fois avoir redimensionner la fenetre :
Par exemple, si je prend 5 secondes pour redimensionner ma fenêtre, une fois l'avoir redimensionner (donc pas durant le redimensionnement), j'obtiens X >5 évènement resize. Si je prend 10 secondes, j'aurais env 2X evenement resize.

Pourquoi ces évènements ne sont-ils pas émis durant le redimensionnement ?
Quelle est l'utilité d'avoir une pile d'évènement identiques en même temps?

Je vous montre le code qui créer ce phénomène :

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
void app::wait()
{
    //Les emit sont des fonctions qui me sont propre.
    //Les optimisations, propreté du code et fonctionnement du code n'est pas la partie qui m'intéresse.
    sf::Event event;
    exit=false;
    while(!exit)
    {
        while(screen.GetEvent(event))
        {
            switch(event.Type)
            {
                case sf::Event::Resized :
                    std::cout<<"resize";
                    emit("resize");
                    break;
                case sf::Event::GainedFocus :
                    std::cout<<"gained";
                    emit("gained_focus");
                    break;
                case sf::Event::LostFocus :
                    std::cout<<"lost";
                    emit("lost_focus");
                    break;
                case sf::Event::TextEntered :
                    emit("character",Evenement<Uint32>(event.Text.Unicode));
                    break;
                case sf::Event::KeyPressed :
                    emit("keyboard", Evenement<bool, Key::Code, bool,bool,bool>(true,event.Key.Code,event.Key.Alt,event.Key.Control,event.Key.Shift));
                    break;
                case sf::Event::KeyReleased :
                    emit("keyboard", Evenement<bool, Key::Code, bool,bool,bool>(false,event.Key.Code,event.Key.Alt,event.Key.Control,event.Key.Shift));
                    break;
                case sf::Event::MouseButtonPressed :
                    emit("mouse_button", Evenement<bool, sf::Mouse::Button, int,int>(true,event.MouseButton.Button,event.MouseButton.X,event.MouseButton.Y));
                    break;
                case sf::Event::MouseButtonReleased :
                    emit("mouse_button", Evenement<bool, sf::Mouse::Button, int,int>(false,event.MouseButton.Button,event.MouseButton.X,event.MouseButton.Y));
                    break;
                case sf::Event::MouseMoved :
                    emit("mouse_motion", Evenement<unsigned int,unsigned int>(event.MouseMove.X,event.MouseMove.Y));
                    break;
                case sf::Event::Closed :
                    emit("window_quit");
                    break;
                default :
                    break;
            }
        }
    }
    emit("application_closed");
}

[Laurent Gomila]

peut-on avec la SFML supprimer les bordures et imiter Firefox pour le mode pleine écran (cad ne pas faire un plein écran).

Oui

Aujourd'hui, avec la SFML, lorsqu'on Resize la fenêtre, l'évènement n'est émit que lorsque l'utilisateur relâche la souri.
Avec mon IDE (CodeBlocks), le redimensionnement est progressif : l'évènement resize doit être émit alors qu'on n'a pas encore relâcher la souri car on voit le redimensionnement de la fenetre avant même d'avoir relacher la souri.
Est-ce possible avec la SFML ?

Non malheureusement. La manière dont SFML fonctionne et la manière avec laquelle les OS gèrent ça sont incompatibles.

Pourquoi ces évènements ne sont-ils pas émis durant le redimensionnement ?

Parce que pendant le redimensionnement, l'OS lance sa propre boucle de gestion de l'évènement et ne rend la main au programme principal que lorsque tout est fini. Le seul moyen de réagir pendant le redimensionnement, c'est de chopper un évènement particulier de la fenêtre, mais ensuite ce ne serait pas exploitable par SFML (il faudrait un système où l'API graphique a le contrôle total sur la logique d'exécution du programme).

Quelle est l'utilité d'avoir une pile d'évènement identiques en même temps?

Ce n'est pas SFML qui les génère, peut-être est-ce l'OS.

[NoIdea]

Merci pour ces éclaircissements, je pense que le sujet est résolut. Me reste à voir comment faire du "fake" plein écran... (je m'y attaque tout de suite).
Ce problème au niveau de l'évènement resize est gênant. Toutefois, je continuerais sur la SFML... (Cette bibliothèque est vraiment bien faite).
Quelqu'un saurait-il comment wxwidgets, QT et autres framework réussisent a interagir avec le systeme d'exploitation pour obtenir un resize progressif ?
En tout cas, la SFML, c'est du bon boulot !
Manque juste quelques amélioration au niveau des évènements, et quelques docs (les docs du site officiel sont très bien mais plutôt superficielle ce qui m'oblige à aller fouiller dans les headers).
Bon courage.

[NoIdea]

J'ai tout de même cherché une solution (du moins pour windows) pour l'agrandissement de la fenêtre. J'ai trouvé ceci.
Toutefois, je n'ai pas compris si cette evenement était émit tous les T secondes ou s'il était émit au début du resize et grace a WM_SIZE on récupère la fin du redimensionnement.

Suite a cette découverte, ayant vu que l'on pouvait modifier les sources SFML (tant que ne proclame pas que se sont les originaux), j'ai modifié 2 fichiers :

WindowImplWin32.cpp

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
void WindowImplWin32::ProcessEvent(UINT Message, WPARAM WParam, LPARAM LParam)
{
    // Don't process any message until window is created
    if (myHandle == NULL)
        return;
 
    switch (Message)
    {
        // Destroy event
        case WM_DESTROY :
        {
            // Here we must cleanup resources !
            Cleanup();
            break;
        }
        //ATTENTION : AJOUT PERSONEL
        case WM_SIZING :
        {
            Evt.Type        = Event::Resizing;
            SendEvent(Evt);
            break;
        }
        // Set cursor event
        case WM_SETCURSOR :
        {
            // The mouse has moved, if the cursor is in our window we must refresh the cursor
            if (LOWORD(LParam) == HTCLIENT)
                SetCursor(myCursor);
 
            break;
        }
 
        // Close event
        case WM_CLOSE :
        {
            Event Evt;
            Evt.Type = Event::Closed;
            SendEvent(Evt);
            break;
        }
 
        // Resize event
        case WM_SIZE :
        {
            // Update window size
            RECT Rect;
            GetClientRect(myHandle, &Rect);
            myWidth  = Rect.right - Rect.left;
            myHeight = Rect.bottom - Rect.top;
 
            Event Evt;
            Evt.Type        = Event::Resized;
            Evt.Size.Width  = myWidth;
            Evt.Size.Height = myHeight;
            SendEvent(Evt);
            break;
        }
 
        // Gain focus event
        case WM_SETFOCUS :
        {
            Event Evt;
            Evt.Type = Event::GainedFocus;
            SendEvent(Evt);
            break;
        }
 
        // Lost focus event
        case WM_KILLFOCUS :
        {
            Event Evt;
            Evt.Type = Event::LostFocus;
            SendEvent(Evt);
            break;
        }
 
        // Text event
        case WM_CHAR :
        {
            if (myKeyRepeatEnabled || ((LParam & (1 << 30)) == 0))
            {
                Event Evt;
                Evt.Type = Event::TextEntered;
                Evt.Text.Unicode = static_cast<Uint32>(WParam);
                SendEvent(Evt);
            }
            break;
        }
 
        // Keydown event
        case WM_KEYDOWN :
        case WM_SYSKEYDOWN :
        {
            if (myKeyRepeatEnabled || ((HIWORD(LParam) & KF_REPEAT) == 0))
            {
                Event Evt;
                Evt.Type        = Event::KeyPressed;
                Evt.Key.Alt     = HIWORD(GetAsyncKeyState(VK_MENU))    != 0;
                Evt.Key.Control = HIWORD(GetAsyncKeyState(VK_CONTROL)) != 0;
                Evt.Key.Shift   = HIWORD(GetAsyncKeyState(VK_SHIFT))   != 0;
                Evt.Key.Code    = VirtualKeyCodeToSF(WParam, LParam);
                SendEvent(Evt);
            }
            break;
        }
 
        // Keyup event
        case WM_KEYUP :
        case WM_SYSKEYUP :
        {
            Event Evt;
            Evt.Type        = Event::KeyReleased;
            Evt.Key.Alt     = HIWORD(GetAsyncKeyState(VK_MENU))    != 0;
            Evt.Key.Control = HIWORD(GetAsyncKeyState(VK_CONTROL)) != 0;
            Evt.Key.Shift   = HIWORD(GetAsyncKeyState(VK_SHIFT))   != 0;
            Evt.Key.Code    = VirtualKeyCodeToSF(WParam, LParam);
            SendEvent(Evt);
 
            break;
        }
 
        // Mouse wheel event
        case WM_MOUSEWHEEL :
        {
            Event Evt;
            Evt.Type = Event::MouseWheelMoved;
            Evt.MouseWheel.Delta = static_cast<Int16>(HIWORD(WParam)) / 120;
            SendEvent(Evt);
            break;
        }
 
        // Mouse left button down event
        case WM_LBUTTONDOWN :
        {
            Event Evt;
            Evt.Type               = Event::MouseButtonPressed;
            Evt.MouseButton.Button = Mouse::Left;
            Evt.MouseButton.X      = LOWORD(LParam);
            Evt.MouseButton.Y      = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse left button up event
        case WM_LBUTTONUP :
        {
            Event Evt;
            Evt.Type               = Event::MouseButtonReleased;
            Evt.MouseButton.Button = Mouse::Left;
            Evt.MouseButton.X      = LOWORD(LParam);
            Evt.MouseButton.Y      = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse right button down event
        case WM_RBUTTONDOWN :
        {
            Event Evt;
            Evt.Type               = Event::MouseButtonPressed;
            Evt.MouseButton.Button = Mouse::Right;
            Evt.MouseButton.X      = LOWORD(LParam);
            Evt.MouseButton.Y      = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse right button up event
        case WM_RBUTTONUP :
        {
            Event Evt;
            Evt.Type               = Event::MouseButtonReleased;
            Evt.MouseButton.Button = Mouse::Right;
            Evt.MouseButton.X      = LOWORD(LParam);
            Evt.MouseButton.Y      = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse wheel button down event
        case WM_MBUTTONDOWN :
        {
            Event Evt;
            Evt.Type               = Event::MouseButtonPressed;
            Evt.MouseButton.Button = Mouse::Middle;
            Evt.MouseButton.X      = LOWORD(LParam);
            Evt.MouseButton.Y      = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse wheel button up event
        case WM_MBUTTONUP :
        {
            Event Evt;
            Evt.Type               = Event::MouseButtonReleased;
            Evt.MouseButton.Button = Mouse::Middle;
            Evt.MouseButton.X      = LOWORD(LParam);
            Evt.MouseButton.Y      = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse X button down event
        case WM_XBUTTONDOWN :
        {
            Event Evt;
            Evt.Type               = Event::MouseButtonPressed;
            Evt.MouseButton.Button = HIWORD(WParam) == XBUTTON1 ? Mouse::XButton1 : Mouse::XButton2;
            Evt.MouseButton.X      = LOWORD(LParam);
            Evt.MouseButton.Y      = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse X button up event
        case WM_XBUTTONUP :
        {
            Event Evt;
            Evt.Type               = Event::MouseButtonReleased;
            Evt.MouseButton.Button = HIWORD(WParam) == XBUTTON1 ? Mouse::XButton1 : Mouse::XButton2;
            Evt.MouseButton.X      = LOWORD(LParam);
            Evt.MouseButton.Y      = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse move event
        case WM_MOUSEMOVE :
        {
            // Check if we need to generate a MouseEntered event
            if (!myIsCursorIn)
            {
                TRACKMOUSEEVENT MouseEvent;
                MouseEvent.cbSize    = sizeof(TRACKMOUSEEVENT);
                MouseEvent.hwndTrack = myHandle;
                MouseEvent.dwFlags   = TME_LEAVE;
                TrackMouseEvent(&MouseEvent);
 
                myIsCursorIn = true;
 
                Event Evt;
                Evt.Type = Event::MouseEntered;
                SendEvent(Evt);
            }
 
            Event Evt;
            Evt.Type        = Event::MouseMoved;
            Evt.MouseMove.X = LOWORD(LParam);
            Evt.MouseMove.Y = HIWORD(LParam);
            SendEvent(Evt);
            break;
        }
 
        // Mouse leave event
        case WM_MOUSELEAVE :
        {
            myIsCursorIn = false;
 
            Event Evt;
            Evt.Type = Event::MouseLeft;
            SendEvent(Evt);
            break;
        }
    }
}

et :

Event.hpp

Code :

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
enum EventType
    {
        Closed,
        Resized,
        LostFocus,
        GainedFocus,
        TextEntered,
        KeyPressed,
        KeyReleased,
        MouseWheelMoved,
        MouseButtonPressed,
        MouseButtonReleased,
        MouseMoved,
        MouseEntered,
        MouseLeft,
        JoyButtonPressed,
        JoyButtonReleased,
        JoyMoved,
        //Ajout Personel
        Resizing,
        Count // Keep last -- total number of event types
    };

Ceci sont mes seules modifications. Avant de recompiler le tout, pensez vous que cela ai une chance de marcher ?

Merci a tous.

[Laurent Gomila]

Merci pour ces éclaircissements, je pense que le sujet est résolut. Me reste à voir comment faire du "fake" plein écran...

Il suffit d'utiliser le style None, et une taille de fenêtre égale à la résolution de l'écran (sf::VideoMode::GetDesktopMode()).

Quelqu'un saurait-il comment wxwidgets, QT et autres framework réussisent a interagir avec le systeme d'exploitation pour obtenir un resize progressif ?
En tout cas, la SFML, c'est du bon boulot !

Ils captent l'évènement WM_SIZING et le renvoient à l'utilisateur, tout simplement. Le problème c'est que SFML n'a pas de callbacks d'évènements, c'est l'utilisateur qui va consulter les évènements quand il le veut, et pas la lib qui le notifie quand il se produit quelque chose. Et comme Windows bloque l'exécution pendant le redimensionnement... l'utilisateur ne peut pas demander à SFML les évènements, il faudrait obligatoirement un système de callback.

Manque juste quelques amélioration au niveau des évènements

Tu parles du redimensionnement, ou d'autre chose ?

les docs du site officiel sont très bien mais plutôt superficielle ce qui m'oblige à aller fouiller dans les headers

Hmm, il n'y a rien de plus dans les en-têtes que dans la doc, puisque celle-ci est justement générée à partir des en-têtes.

Avant de recompiler le tout, pensez vous que cela ai une chance de marcher ?

Aucune (ce serait déjà fait si c'était aussi simple...).
A cause de ce que j'ai expliqué plus haut, ça ne va faire qu'empiler plein de Resize dans la pile d'évènements, et l'utilisateur ne pourra les consulter que lorsque le redimensionnement aura pris fin.
Il n'y a pas à chercher, c'est techniquement impossible sans système de callback.

[NoIdea]

Tu parles du redimensionnement, ou d'autre chose ?

Je parle au niveau des redimensionnements, l'absence de userevent, et l'absence de fonction style SDL_WaitEvent().
Il est vrai que la plupart de ces choses sont possibles facilement, cependant, il est toujours agréable de voir que les choses sont déjà faites.

Et comme Windows bloque l'exécution pendant le redimensionnement... l'utilisateur ne peut pas demander à SFML les évènements, il faudrait obligatoirement un système de callback.

Ne peut-on pas contourner ce problème avec les threads ? (bon peu importe, j'abandonne l'idée : j'attendrais la version de la SFML où se sera implémenté).

Hmm, il n'y a rien de plus dans les en-têtes que dans la doc, puisque celle-ci est justement générée à partir des en-têtes.

Oui j'ai remarquer la documentation pour les class Window, Renderwindow, Sprite et etc, mais aucune pour les Event : en tapant "SFML sf::Event" sous google, aucune doc de sf::Event (type des différents éléments des structures et etc...) mais peut être ai-je mal chercher (j'ai pas beaucoup persévérer ayant les headers dispo).

Il n'y a pas à chercher, c'est techniquement impossible sans système de callback.

Je ne sais pas comment SFML gère le tout en intrinsèque, mais n'est-il pas possible d'avoir une fonction de callback qui rajoute les évènement à la file ?

En tout cas, merci d'avoir pris le temps de me répondre ; c'est toujours agréable de pouvoir avoir des réponses claires rapidement. La SFML à un brillant avenir...

[Laurent Gomila]

Je parle au niveau des redimensionnements

On est d'accord, mais là c'est une impossibilité technique.

l'absence de userevent

Pour quoi faire ?

l'absence de fonction style SDL_WaitEvent()

Implémenté dans SFML 2.

Oui j'ai remarquer la documentation pour les class Window, Renderwindow, Sprite et etc, mais aucune pour les Event : en tapant "SFML sf::Event" sous google, aucune doc de sf::Event (type des différents éléments des structures et etc...) mais peut être ai-je mal chercher

Il y a de la doc, mais pour quelque chose de vraiment utile il y a le tutoriel correspondant

Je ne sais pas comment SFML gère le tout en intrinsèque, mais n'est-il pas possible d'avoir une fonction de callback qui rajoute les évènement à la file ?

Le problème n'est pas d'ajouter les évènements à la file, ça c'est facile. Le souci c'est que l'utilisateur ne pourra les consulter qu'à la fin du redimensionnement, puisque l'OS bloque l'exécution tant qu'il n'est pas terminé.

[NoIdea]

l'absence de userevent
Pour quoi faire ?

En SDL, j'utilisais pas mal les UserEvent : par exemple on peut générer l'évènement has_moved peut indiquer si un joueur s'est déplacé et ainsi le gérer l'affichage indépendamment de la fonction has_moved (qui change la structure du personnage par exemple).
De plus, peut-on utiliser la fonction sendevt (qui permettrais de simuler des évènements) en SFML ou est-ce réservé à l'implémentation.
Lorsque la fenetre est redimensionnée, windows bloque le processus ? Si oui comment les autres bibliothèques le font-elle ? lance-t-elle un autre processus ?

[Laurent Gomila]

En SDL, j'utilisais pas mal les UserEvent : par exemple on peut générer l'évènement has_moved peut indiquer si un joueur s'est déplacé et ainsi le gérer l'affichage indépendamment de la fonction has_moved (qui change la structure du personnage par exemple).

A mon avis ici tu abuses beaucoup des évènements persos, je ne pense pas que ce soit fait pour ça. Je pense que pas mal de monde les utilise comme raccourci pratique pour faire passer tout et n'importe quoi d'un endroit à un autre de l'application, au lieu de chercher des solutions propres au niveau de la conception des classes.
Ce qui me conforte dans l'idée qu'il ne faut pas les implémenter
De toute façon, quelqu'un qui aurait réellement besoin d'une gestion d'évènements persos implémenterait son propre système par dessus les évènements SFML liés à la fenêtre ; dans tous les cas ce n'est pas une bonne solution d'utiliser le même mécanisme.

De plus, peut-on utiliser la fonction sendevt (qui permettrais de simuler des évènements) en SFML ou est-ce réservé à l'implémentation.

Ce n'est pas fait pour être utilisé publiquement, non.

Lorsque la fenetre est redimensionnée, windows bloque le processus ? Si oui comment les autres bibliothèques le font-elle ? lance-t-elle un autre processus ?

Elles notifient l'utilisateur immédiatement. Si celui-ci réagit directement (en provoquant un rafraîchissement de la fenêtre par exemple), c'est ok. S'il ne fait que stocker l'évènement pour plus tard (ce que fait SFML), il ne pourra déstocker cet évènement qu'à la fin du redimensionnement.

Note qu'utiliser un thread peut être une solution tout à fait envisageable dans certaines situations, pour contourner ce problème.

[NoIdea]

Il suffit d'utiliser le style None, et une taille de fenêtre égale à la résolution de l'écran (sf::VideoMode::GetDesktopMode()).

Je viens de testé, et je rencontre un problème d'élégance :
Il me semble que je suis obligé de rappeler la méthode Create pour changer les window settings. Je vois donc sur mon écran une fenêtre en train de disparaitre et remplacée tout de suite.
Est-il possible d'éviter la visualisation de la disparition de la fenêtre ? (par exemple faire pour que l'écran ne soit pas rafraichit avant que la nouvelle fenêtre soit créée ?)

[Laurent Gomila]

Non ce n'est pas possible avec SFML. Tu peux redimensionner la fenêtre sans la recréer, mais pas changer son style. Ceci-dit ça pourrait être ajouté dans SFML 2, je ne vois pas d'inconvénient à ce genre de fonction.

[NoIdea]

Je crois que j'ai fini sur les questions de bases, merci pour tes réponses. Sujet Résolut.