Discussion :

[panthere noire]

Je suis le tutoriel cituer ici https://alexandre-laurent.developpez...toriels/sdl-2/

je reprend la sdl en c++ je n'irai pas jusqu'à faire un wrapper c'est pas dans mes corde si je puis dire

je voudrai changer la couleur de fond de la windows et j'arrive pas a mettre la main sur la fonction sdl qui va bien ou je m'y prend mal.

je cree la windows de cette manière.

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
pWindow = SDL_CreateWindow(WTitre.c_str(),
                                        SDL_WINDOWPOS_CENTERED,
                                        SDL_WINDOWPOS_CENTERED,
                                        TailleHorizontal,
                                        TailleVertical,
                                        SDL_WINDOW_SHOWN);

ensuite
Est ce que ceci serai juste ?

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

SDL_MapRGB(pWindow->format,255,255,255)

Comme le pointeur est celui qui est de la fenêtre c'est supposer marcher ?
chez moi sa ne compile pas j'en conclu que quelque chose cloche

Merci d'avance

[Bousk]

Rien à voir, heureusement il y a la doc.

Pour remplir une couleur, c'est SDL_FillRect ou le combo SDL_SetRenderDrawColor / SDL_RenderClear.

[panthere noire]

Merci pour ta réponse , le problème est résolut

[panthere noire]

Petit souci.

1.- si la fenêtre est crée et visible puis le changement de couleur ce fait, cela provoque un flash .
2.-La fenêtre est crée et cachée .
La couleur devrai donc s'appliquer ensuite je l'affiche . mai pas de changement .

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
 
 pWindow = SDL_CreateWindow(WTitre.c_str(),
                                        SDL_WINDOWPOS_CENTERED,
                                        SDL_WINDOWPOS_CENTERED,
                                        TailleHorizontal,
                                        TailleVertical,
                                        SDL_WINDOW_HIDDEN);

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
 
  pRenderer = SDL_CreateRenderer(pWindow, -1, SDL_RENDERER_ACCELERATED);
    SDL_SetRenderDrawColor(pRenderer, rouge, vert, bleu, transparence);
    SDL_RenderClear(pRenderer);
    SDL_RenderPresent(pRenderer);
    //SDL_HideWindow(pWindow);
    //SDL_RaiseWindow(pWindow);
    SDL_ShowWindow(pWindow);

3.- je cree donc cachée , mai je place le SDL_ShowWindow(pWindow); Avant
SDL_SetRenderDrawColor(pRenderer, rouge, vert, bleu, transparence);
Resulta:
Il n'y a pas de flash visible, je pense que c'est juste plus rapide et que l'œil n'est pas capable de voir ce délai très court.

il n'y a pas moyen de faire cela quand la fenêtre est pas cachée,
car sur un système lent sa pourrai peut etre ce voir tout de même !?

[LittleWhite]

Bonjour,

Le flash est surement lié au fait que vous "présentez" la fenêtre trop tôt. Montrez nous le code provoquant le flash (la partie de la création de la fenêtre, à l'affichage).

[panthere noire]

je croit que le fait de l'afficher directement ne permet pas de la travailler sans provoque ce flash a car a l'arrivée elle a forcement la couleur par defaut gris/blanc

C' est en pleine modification donc pas très lisible .

le code compile chez moi,
le main suivant flash :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <iostream>
#include <SDL2/SDL.h>
 
#include "c_sdl2_windows.hpp"
 
 
 
int main(int argc, char** argv)
{
 
C_MeSDL2Windows CS2W;
 
    if (CS2W.Initilize(true,false,false,false) == false) {return -1;}
 
    std::vector<int> V_VecHauteur;
    std::vector<int> V_VecLargeur;
    std::vector<int> V_VecFrequance;
    std::string pathimage="./image.bmp";
    //std::string pathimage="./image2.jpg";
 
    CS2W.M_CreateWindows("Mon titre",true,600,1024,true);
    //CS2W.M_GetResolution(V_VecHauteur,V_VecLargeur,V_VecFrequance);
    //CS2W.M_sprit(pathimage);
    //CS2W.M_SetFullScreen();
    //CS2W.M_SetWindowsShow();
    CS2W.M_CouleurDefond(20,20,20,255);
    //CS2W.M_SetWindowsShow();
    CS2W.M_SetUpdateScreen();
    CS2W.M_Pause(2500);
    CS2W.M_DestructionWindows();
    CS2W.M_SetExitSdl();
    return 0;
}

celui-ci pas:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include <iostream>
#include <SDL2/SDL.h>
 
#include "c_sdl2_windows.hpp"
 
 
 
int main(int argc, char** argv)
{
 
C_MeSDL2Windows CS2W;
 
    if (CS2W.Initilize(true,false,false,false) == false) {return -1;}
 
    std::vector<int> V_VecHauteur;
    std::vector<int> V_VecLargeur;
    std::vector<int> V_VecFrequance;
    std::string pathimage="./image.bmp";
    //std::string pathimage="./image2.jpg";
 
    CS2W.M_CreateWindows("Mon titre",true,600,1024,false);
    //CS2W.M_GetResolution(V_VecHauteur,V_VecLargeur,V_VecFrequance);
    //CS2W.M_sprit(pathimage);
    //CS2W.M_SetFullScreen();
    //CS2W.M_SetWindowsShow();
    CS2W.M_CouleurDefond(20,20,20,255);
    CS2W.M_SetWindowsShow();
    CS2W.M_SetUpdateScreen();
    CS2W.M_Pause(2500);
    CS2W.M_DestructionWindows();
    CS2W.M_SetExitSdl();
    return 0;
}

La classe *.hpp

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#ifndef DEF_ME_SDL2_WINDOWS
#define DEF_ME_SDL2_WINDOWS
 
 
#include <SDL2/SDL.h>
#include <string>
#include <iostream>
#include <vector>
class C_MeSDL2Windows
{
	public:
		C_MeSDL2Windows     ();
		bool Initilize      (const bool & InitVideo,
                                const bool & InitAudio,
                                const bool & InitEvent,
                                const bool & InitTimer);
 
		void M_CreateWindows(const std::string & WTitre,
                                const bool & AuCentre,
                                const int & TailleVertical,
                                const int & TailleHorizontal,
                                const bool & Visible);
 
        int M_GetResolution(std::vector<int> & F_VecHauteur,
                            std::vector<int> & F_VecLargeur,
                            std::vector<int> & F_VecFrequance);
 
        void M_CouleurDefond(const int & rouge,
                                const int & vert ,
                                const int & bleu,
                                const int & transparence);
 
        void M_Pause                (const Uint32 & Time)       ;
        void M_sprit                (std::string & pathimage)   ;
        void M_DestructionWindows   ()                          ;
        bool M_SetFullScreen        ()                          ;
        void M_SetExitSdl           ()                          ;
 
 
        void M_SetLuminositer       (const float & lum)         ;
        void M_SetUpdateScreen      ()                          ;
        void M_SetWindowsShow       ()                          ;
 
    private:
        SDL_Renderer *pRenderer = nullptr                       ;
        SDL_Window* pWindow = nullptr                           ;
        void M_SetGpuRenderer       ()                          ;
};
#endif

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

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
 
#include "c_sdl2_windows.hpp"
C_MeSDL2Windows::C_MeSDL2Windows(){}
 
bool C_MeSDL2Windows::Initilize(const bool & InitVideo,
                                const bool & InitAudio,
                                const bool & InitEvent,
                                const bool & InitTimer)
{
    if ((InitVideo == true) && SDL_Init(SDL_INIT_VIDEO) != 0 )
    {
        fprintf(stdout,"Échec de l'initialisation de la SDL (SDL_INIT_VIDEO) (%s)\n",SDL_GetError());
        return false;
    }
    if ((InitAudio == true) && SDL_Init(SDL_INIT_AUDIO) != 0 )
    {
        fprintf(stdout,"Échec de l'initialisation de la SDL (SDL_INIT_AUDIO) (%s)\n",SDL_GetError());
        return false;
    }
    if ((InitEvent == true) && SDL_Init(SDL_INIT_EVENTS) != 0 )
    {
        fprintf(stdout,"Échec de l'initialisation de la SDL (SDL_INIT_EVENTS) (%s)\n",SDL_GetError());
        return false;
    }
    if ((InitTimer == true) && SDL_Init(SDL_INIT_TIMER) != 0 )
    {
        fprintf(stdout,"Échec de l'initialisation de la SDL (SDL_INIT_TIMER) (%s)\n",SDL_GetError());
        return false;
    }
    return true;
}
void C_MeSDL2Windows::M_SetExitSdl(){
 
    if( pWindow != nullptr) { pWindow=nullptr;}
 
    SDL_Quit();
}
void C_MeSDL2Windows::M_CreateWindows(const std::string & WTitre,
                                      const bool & AuCentre,
                                      const int & TailleVertical,
                                      const int & TailleHorizontal,
                                      const bool & Visible){
 
    int vHideOrShows=0;
 
    if (Visible == true){
        vHideOrShows=SDL_WINDOW_SHOWN;
    }
    else
    {
        vHideOrShows=SDL_WINDOW_HIDDEN;
    }
 
    if (AuCentre){
            pWindow = SDL_CreateWindow(WTitre.c_str(),
                                        SDL_WINDOWPOS_CENTERED,
                                        SDL_WINDOWPOS_CENTERED,
                                        TailleHorizontal,
                                        TailleVertical,
                                        vHideOrShows);
    }
    else{
            pWindow = SDL_CreateWindow(WTitre.c_str(),
                                        SDL_WINDOWPOS_UNDEFINED,
                                        SDL_WINDOWPOS_UNDEFINED,
                                        TailleHorizontal,
                                        TailleVertical,
                                        vHideOrShows);
    }
    if( pWindow == NULL) {std::cout << "Erreur: pointeur null suite a la creation de la fenêtre";}
    else                 { C_MeSDL2Windows::M_SetGpuRenderer();}
}
 
 void C_MeSDL2Windows::M_Pause(const Uint32 & Time){
    if( pWindow )
    {
        SDL_Delay(Time);
    }
    else
    {
        fprintf(stderr,"Erreur de création de la fenêtre: %s\n",SDL_GetError());
    }
 }
 
void C_MeSDL2Windows::M_DestructionWindows(){
 
    if( pWindow )
    {
        SDL_DestroyWindow(pWindow);
    }
 
    pWindow=nullptr;
 
}
 
bool C_MeSDL2Windows::M_SetFullScreen(){
    if( pWindow )
    {
            if (SDL_SetWindowFullscreen(pWindow,SDL_WINDOW_FULLSCREEN_DESKTOP ) == 0 )
            {
                return true;
            }
            else
            {
                return false;
            }
    }
    return false;
 
}
int C_MeSDL2Windows::M_GetResolution(std::vector<int> & F_VecHauteur,
                                        std::vector<int> & F_VecLargeur,
                                        std::vector<int> & F_VecFrequance)
{
    int modeNumber = SDL_GetNumDisplayModes(0);
    int error = 0;
    if (modeNumber < 0)
    {
     fprintf(stdout,"Échec lors de la récupération du nombre de modes (%s)\n",SDL_GetError());
    // return -2;
    }
    fprintf(stdout,"Vous avez %d mode(s) d'affichage\n", modeNumber);
 
    // Affichage des différents modes
    SDL_DisplayMode displayMode;
    for (int i = 0 ; i < modeNumber ; i++)
    {
        error = SDL_GetDisplayMode(0, i, &displayMode);
        if (error < 0)
        {
            fprintf(stdout, "Échec lors de la récupération du mode d'affichage (%s)\n", SDL_GetError());
            return -3;
        }
/*
                std::cout << "Ligne: "      << i <<
                            " Largeur: "    << displayMode.w <<
                            "Hauteur"       << displayMode.h <<
                            " Frequance "   << displayMode.refresh_rate <<
                std::endl;
*/
            F_VecHauteur.push_back(displayMode.h);
            F_VecLargeur.push_back(displayMode.w);
            F_VecFrequance.push_back(displayMode.refresh_rate);
        //fprintf(stdout, "Mode %d : %dx%dx%d\n", i, displayMode.w, displayMode.h, displayMode.refresh_rate);
    }
}
 
void C_MeSDL2Windows::M_sprit(std::string & pathimage){
   // SDL_Surface* pSprite = SDL_LoadBMP("./image.bmp");
//    std::string pathimage="./image.bmp";
    SDL_Renderer *pRenderer = SDL_CreateRenderer(pWindow,-1,SDL_RENDERER_ACCELERATED); // Création d'un SDL_Renderer utilisant l'accélération matérielle
    if ( pRenderer )
    {
        SDL_Surface* pSprite = SDL_LoadBMP(pathimage.c_str());
        if ( pSprite )
        {
            SDL_Texture* pTexture = SDL_CreateTextureFromSurface(pRenderer,pSprite); // Préparation du sprite
            if ( pTexture )
            {
                SDL_Rect dest = { 640/2 - pSprite->w/2,480/2 - pSprite->h/2, pSprite->w, pSprite->h};
                SDL_RenderCopy(pRenderer,pTexture,NULL,&dest); // Copie du sprite grâce au SDL_Renderer
 
                SDL_RenderPresent(pRenderer); // Affichage
                SDL_Delay(3000); /* Attendre trois secondes, que l'utilisateur voit la fenêtre */
 
                SDL_DestroyTexture(pTexture); // Libération de la mémoire associée à la texture
            }
            else
            {
                fprintf(stdout,"Échec de création de la texture (%s)\n",SDL_GetError());
            }
 
            SDL_FreeSurface(pSprite); // Libération de la ressource occupée par le sprite
        }
        else
        {
            fprintf(stdout,"Échec de chargement du sprite (%s)\n",SDL_GetError());
        }
 
        SDL_DestroyRenderer(pRenderer); // Libération de la mémoire du SDL_Renderer
    }
    else
    {
        fprintf(stdout,"Échec de création du renderer (%s)\n",SDL_GetError());
    }
}
void C_MeSDL2Windows::M_SetGpuRenderer(){
    pRenderer = SDL_CreateRenderer(pWindow, -1, SDL_RENDERER_ACCELERATED);
}
void C_MeSDL2Windows::M_SetLuminositer(const float & lum){
    if( pWindow )
    {
        SDL_SetWindowBrightness(pWindow,lum);
    }
    else
    {
       std::cout << "Erreur pointeur invalide M_SetLuminositer " << std::endl;
    }
}
void C_MeSDL2Windows::M_SetUpdateScreen(){
    if( pWindow )
    {
        SDL_RenderPresent(pRenderer);
    }
    else
    {
        std::cout << "Erreur pointeur invalide M_SetUpdateScreen " << std::endl;
    }
}
void C_MeSDL2Windows::M_SetWindowsShow(){
    SDL_ShowWindow(pWindow);
}
void C_MeSDL2Windows::M_CouleurDefond(const int & rouge,
                                      const int & vert ,
                                      const int & bleu,
                                      const int & transparence){
 
 
    SDL_SetRenderDrawColor(pRenderer, rouge, vert, bleu, transparence);
}

[LittleWhite]

Étonnamment, vous ne faites pas de SDL_RenderClear (https://wiki.libsdl.org/SDL_RenderClear) pour effacer l'écran avec la couleur de fond que vous avez choisi.

Aussi :

• je ne suis pas fan des préfixes des noms de classes en C_ et des noms de méthodes en M_. Je ne trouve pas ces deux ci utiles. Mais c'est un avis personnel ;
• je ne vois pas pourquoi vous passez les int en références constantes. Vous ne gagnez rien à faire ainsi (mais j'aimerai bien connaître la raison) ;
• par contre, ici void C_MeSDL2Windows::M_sprit(std::string & pathimage){ cela devrait être une référence constante.

[panthere noire]

Merci pour ta réponse

Pour le M et le C c'est juste pour différencier facilement le code du reste des variables, c'est pas indispensable.
Je verrai si sure le long terme c'est justifier ou pas. car j'avais fait sans jusqu'à présent, pour en avoir un aperçus il me faut donc faire avec.

pour les constantes, si on fait sans cela donne:

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
 
error: invalid initialization of non-const reference of type 'int&' from an rvalue of type 'int'
     CS2W.M_CouleurDefond(20,20,20,255);

je ne connais pas de moyen de faire autrement, vu que la librairie le demande ?


Pour SDL_RenderClear je pensais que c'était pas utile car il n'y a rien a effacer vu que la feuille était vide ?

Edit:
pour la méthode c'est corriger merci .

[LittleWhite]

Il faut que la fonction ait la signature :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
void C_MeSDL2Windows::M_CouleurDefond(const int rouge,
                                      const int vert ,
                                      const int bleu,
                                      const int transparence){

Le const ici, n'est pas du tout "important". Il vous empêchera juste de modifier la valeur dans la fonction. Mais même sans, ça ne modifie en rien les valeurs depuis l'appelant, car ce sont des copies.

je ne connais pas de moyen de faire autrement, vu que la librairie le demande ?

Pas la bibliothèque, c'est une histoire de C++.

Je vous conseille de lire/relire ce tutoriel. Car en théorie, vous devez avoir une boucle principale, qui, lorsqu'il n'y a rien à afficher fera :

• RenderClear() ;
• RenderPresent() ;

Et lorsqu'il y a des éléments :

• RenderClear() ;
• Affichage des trucs
• RenderPresent() ;

Si vous faites cela, je doute que vous ayez le flash.

[panthere noire]

Le const ici, n'est pas du tout "important". Il vous empêchera juste de modifier la valeur dans la fonction. Mais même sans, ça ne modifie en rien les valeurs depuis l'appelant, car ce sont des copies.
.

Pardon le code citer n'est pas celui que j'avais mis
la déclaration suivante

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
 
void M_CouleurDefond(const int & rouge,
                                const int & vert ,
                                const int & bleu,
                                const int & transparence);

Et non pas celui que vous avez modifier (ou j'ai mal interpréter)
Sont des références. et nécessite d'être déclarée auparavant d'ou l'usage de const. le but étant d'éviter une copie de la valeur aux moment de l'appelle de la méthode.
Il serai donc, plus judicieux d'utiliser l'appelle par copie ?

Merci pour le lien sur le tutoriel et de ta patience

[LittleWhite]

Pour les types de bases (int, float, double), que vous fassiez une copie ou une référence, la donnée copiée est la même. En effet, une référence, c'est comme un pointeur, donc c'est 4 octets (ou 8 sur un système 64 bits), un int c'est aussi 4 octets (généralement), du coup, copier 4 octets, ou copier 4 octets... la différence est nulle.