Publicité
+ Répondre à la discussion
Affichage des résultats 1 à 17 sur 17
  1. #1
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut [DEBUTANT] Diverses Questions

    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.

  2. #2
    Responsable 2D/3D/Jeux

    Avatar de LittleWhite
    Homme Profil pro Alexandre Laurent
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    15 656
    Détails du profil
    Informations personnelles :
    Nom : Homme Alexandre Laurent
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 15 656
    Points : 72 658
    Points
    72 658

    Par défaut

    Bonjour,

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

    Citation Envoyé par NoIdea Voir le message
    -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
    Vous souhaitez participer à la rubrique 2D / 3D / Jeux ? Contactez-moi
    La rubrique a aussi un blog !

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  3. #3
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut

    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.

  4. #4
    Responsable 2D/3D/Jeux

    Avatar de LittleWhite
    Homme Profil pro Alexandre Laurent
    Ingénieur développement logiciels
    Inscrit en
    mai 2008
    Messages
    15 656
    Détails du profil
    Informations personnelles :
    Nom : Homme Alexandre Laurent
    Localisation : France

    Informations professionnelles :
    Activité : Ingénieur développement logiciels

    Informations forums :
    Inscription : mai 2008
    Messages : 15 656
    Points : 72 658
    Points
    72 658

    Par défaut

    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 )
    Vous souhaitez participer à la rubrique 2D / 3D / Jeux ? Contactez-moi
    La rubrique a aussi un blog !

    Ma page sur DVP
    Mon Portfolio

    Qui connaît l'erreur, connaît la solution.

  5. #5
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 16 141
    Points
    16 141

    Par défaut

    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.
    Mieux que SDL : découvrez SFML

  6. #6
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut

    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");
    }

  7. #7
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 16 141
    Points
    16 141

    Par défaut

    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.
    Mieux que SDL : découvrez SFML

  8. #8
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut

    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.

  9. #9
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut

    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.

  10. #10
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 16 141
    Points
    16 141

    Par défaut

    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.
    Mieux que SDL : découvrez SFML

  11. #11
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut

    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...

  12. #12
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 16 141
    Points
    16 141

    Par défaut

    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é.
    Mieux que SDL : découvrez SFML

  13. #13
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut

    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 ?

  14. #14
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 16 141
    Points
    16 141

    Par défaut

    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.
    Mieux que SDL : découvrez SFML

  15. #15
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut

    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 ?)

  16. #16
    Rédacteur
    Avatar de Laurent Gomila
    Profil pro
    Développeur informatique
    Inscrit en
    avril 2003
    Messages
    10 651
    Détails du profil
    Informations personnelles :
    Âge : 30
    Localisation : France, Moselle (Lorraine)

    Informations professionnelles :
    Activité : Développeur informatique

    Informations forums :
    Inscription : avril 2003
    Messages : 10 651
    Points : 16 141
    Points
    16 141

    Par défaut

    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.
    Mieux que SDL : découvrez SFML

  17. #17
    Membre actif

    Inscrit en
    avril 2010
    Messages
    341
    Détails du profil
    Informations forums :
    Inscription : avril 2010
    Messages : 341
    Points : 155
    Points
    155

    Par défaut

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

+ Répondre à la discussion
Cette discussion est résolue.

Liens sociaux

Règles de messages

  • Vous ne pouvez pas créer de nouvelles discussions
  • Vous ne pouvez pas envoyer des réponses
  • Vous ne pouvez pas envoyer des pièces jointes
  • Vous ne pouvez pas modifier vos messages
  •