Discussion :

[panthere noire]

Bonjours, la compilation ce passe bien mai a l'execution j'obtien SDL_RenderCopy : -1 : Invalid renderer .
lJe vai faire aux plus court s'il faut je peux mettre le code complet

iclasse button
constructeur

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
 
Button::Button(SDL_Renderer* _pRenderer,
				std::string &_path_picture,
				std::string &_pathimage_down,
				std::string &_pathimage_select ,
				int _posup,	int _posleft, int _lenup, int _lenwid)
 
{
	pRenderer			= _pRenderer		;
 
	pathpicture			= _path_picture		;
	pathimage_down		= _pathimage_down	;
	pathimage_select	= _pathimage_select	;
 
	posup				= _posup 			;
	posleft				= _posleft			;
	lenup				= _lenup			;
	lenwid				= _lenwid			;
 
 	if (Button::loadpicture(pathpicture,0)== false){std::cout << "Erreur image 0"<<  std::endl;};
 	Button::loadpicture(pathimage_down,1);
 	Button::loadpicture(pathimage_select,2);
}

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
 
bool Button::loadpicture(std::string pathpicture,int id)
{
	pSurface[id] = SDL_LoadBMP(pathpicture.c_str());
	if (pSurface[id])
	{
		std::cout << "DEBUG POINTEUR: " << pRenderer << std::endl;
		pTexture[id] = SDL_CreateTextureFromSurface(pRenderer,pSurface[id]);
		if ( pTexture )
		{
			return true;
		}
		else
		{
			std::cout <<"Erreur dans la fonction SetPicture" <<
						"pointeur pTexture : " << pTexture[id] << " : " << pathpicture << std::endl;
			return false;
		}
	}
	else
	{
		std::cout <<"Erreur dans la fonction SetPicture" <<
				"pointeur pSurface : " << pSurface[id]  << " : " << pathpicture << std::endl;
		return false;
	}
}

la console me donne ceci .

Code :

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

1
2
3
4
 
DEBUG POINTEUR: 0x1d2288
ID: 0
SDL_RenderCopy : -1 : Invalid renderer

le pointeur est bien celui de la fenêtre fourni par SDL_CreateRenderer(pWindow, -1, SDL_RENDERER_ACCELERATED);

curieusement sa marche pour l'image de fond, mai c est dans la classe windows et pas le meme code,

je me demande si le passage aux niveau du constructeur ne pose pas problème. le pointeur n'est pas null et correspond a celui qui ce trouve dans la classe windows ?

donc je pige pas ou est l'erreur.
au besoins je peux mettre les sources quelque part , mai ou ? car tout colle ici c'est pas pratique mai pas de souci si c est demander

Merci d'avance

[Bousk]

- on ne sait pas ce que sont pTextures, une fois utilisé comme pointeur, une autre comme map(?)
- on ne sait pas ce qu'est pSurface
- il n'y a pas besoin de garder la surface une fois la texture créée
- il n'y a pas plus besoin de garder le path des fichiers chargés
- toutes les strings sont passées par copie
- le code ne montre rien du problème qui est certainement l'initialisation foirée de SDL

[panthere noire]

Oui sa mérite quelque ajustement :s
j'ai joins le projet , dans le main il va lui manquer les images que j'ai pas pu mettre en raison de la limite pour un fichier sur le serveur.

si l'initialisation est foiré je pense que sa ne devrai pas compiler...

Merci pour ta réponse
SdlWindows.zip

[Bousk]

La compilation n'a rien à voir avec l'initialisation de SDL.
Poste les codes directement ou héberge-les sur une plateforme. Je ne téléchargerai pas une archive sur ma machine ou celle du boulot.

[panthere noire]

Pas de problème


main.cpp

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
 
#include <iostream>
#include <SDL2/SDL.h>
 
#include "c_sdl2_windows.hpp"
#include "c_sdl2_button.hpp"
 
int main(int argc, char** argv)
{
	planning_windows W;
 
    if (W.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="C:\\votrechemin\\Naxos\\image.bmp";
	std::string img1="./button.bmp";
	std::string img2="./bt2.bmp";
	std::string img3="./bt3.bmp";
 
    if ( W.create_windows("Mon titre",800,600,true,false) == -1 ) { return -1;}
    SDL_Window* pWin		= W.get_window();
	SDL_Renderer* pRend 	= W.get_renderer();
	int wposup		= 0;
	int wposleft	        = 0;
	int wup			= 0;
	int wlen		        = 0;
	//W.set_windows_hide();
	//W.GetResolution(V_VecHauteur,V_VecLargeur,V_VecFrequance);
	// W.SetFullScreen();
	W.set_window_opacity(0.1,1);
	//W.CouleurDefond(60,60,60,0);
    W.set_permit_change_size();
	W.get_win_size(pWin,wposup,wposleft,wup,wlen);
    W.set_windows_show();
	W.set_picture(pRend,pathimage,0,0,wup,wlen);
    W.set_update_screen();
 
	W.set_window_opacity(1,2);
	//	W.GetEvent();
	//SDL_SetRenderDrawColor(pRend, 0, 220, 0, 255); // Choisir la couleur
 
	SDL_Rect rectangle{100, 200, 100, 500};
	SDL_SetRenderDrawColor(pRend, 255, 255, 255, 255);
	//SDL_RenderFillRect(pRend, &rectangle);
	SDL_RenderDrawRect(pRend, &rectangle);
 
	//W.CouleurDefond(60,60,60,100);
	W.set_update_screen();
	//SDL_Surface* pSurface = nullptr;
	//C:\Users\Xerox\Documents\Devcpp\SDLClass\SdlWindows
 
	pRend=W.get_renderer();
	Button bt(pRend,img1,img2,img3,300,300,300,300);
	bt.show(0);
 
	W.set_update_screen();
 
	//pSurface = SDL_LoadBMP(pathimg.c_str());
	//W.SetWindowsShow();
	while (1) {
	//    std::cout << "debugloop" << loopinit << std::endl;
 
		if (W.get_event() == "exit"){ break; }
 
		//Sleep(idle);
		W.pause(10);
	}
	//W.set_destroy_surface		();
	//W.SetDestroyTexture		();
    W.destruction_windows		        ();
    W.set_exit_sdl				();
    return 0;
}

fichier: c_sdl2_windows.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
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
 
#include <iostream>
#include <SDL2/SDL.h>
 
#include "c_sdl2_windows.hpp"
#include "c_sdl2_button.hpp"
 
int main(int argc, char** argv)
{
	planning_windows W;
 
    if (W.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="C:\\votrechemin\\Naxos\\image.bmp";
	std::string img1="./button.bmp";
	std::string img2="./bt2.bmp";
	std::string img3="./bt3.bmp";
 
    if ( W.create_windows("Mon titre",800,600,true,false) == -1 ) { return -1;}
    SDL_Window* pWin		= W.get_window();
	SDL_Renderer* pRend 	= W.get_renderer();
	int wposup		= 0;
	int wposleft	= 0;
	int wup			= 0;
	int wlen		= 0;
	//W.set_windows_hide();
	//W.GetResolution(V_VecHauteur,V_VecLargeur,V_VecFrequance);
	// W.SetFullScreen();
	W.set_window_opacity(0.1,1);
	//W.CouleurDefond(60,60,60,0);
    W.set_permit_change_size();
	W.get_win_size(pWin,wposup,wposleft,wup,wlen);
    W.set_windows_show();
	W.set_picture(pRend,pathimage,0,0,wup,wlen);
    W.set_update_screen();
 
	W.set_window_opacity(1,2);
	//	W.GetEvent();
	//SDL_SetRenderDrawColor(pRend, 0, 220, 0, 255); // Choisir la couleur
 
	SDL_Rect rectangle{100, 200, 100, 500};
	SDL_SetRenderDrawColor(pRend, 255, 255, 255, 255);
	//SDL_RenderFillRect(pRend, &rectangle);
	SDL_RenderDrawRect(pRend, &rectangle);
 
	//W.CouleurDefond(60,60,60,100);
	W.set_update_screen();
	//SDL_Surface* pSurface = nullptr;
	//C:\Users\Xerox\Documents\Devcpp\SDLClass\SdlWindows
 
	pRend=W.get_renderer();
	Button bt(pRend,img1,img2,img3,300,300,300,300);
	bt.show(0);
 
	W.set_update_screen();
 
	//pSurface = SDL_LoadBMP(pathimg.c_str());
	//W.SetWindowsShow();
	while (1) {
	//    std::cout << "debugloop" << loopinit << std::endl;
 
		if (W.get_event() == "exit"){ break; }
 
		//Sleep(idle);
		W.pause(10);
	}
	//W.set_destroy_surface		();
	//W.SetDestroyTexture		();
    W.destruction_windows		        ();
    W.set_exit_sdl				();
    return 0;
}

fichier: c_sdl2_windows.cpp

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
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
267
268
269
270
271
272
273
274
275
276
277
278
279
280
281
282
283
284
285
286
287
288
289
290
291
292
293
294
295
296
297
298
299
300
301
302
303
304
305
306
307
308
309
310
311
312
313
314
315
316
317
318
319
320
321
322
323
324
325
326
327
328
329
330
331
332
333
334
335
336
337
338
339
340
341
342
343
344
345
346
347
348
349
350
351
352
353
354
355
356
357
358
359
360
361
362
363
364
365
366
367
368
369
370
371
372
373
374
375
376
377
378
379
380
381
382
383
 
#include "c_sdl2_windows.hpp"
planning_windows::planning_windows(){}
void planning_windows::get_win_size (SDL_Window* pwin,
										int &posup,
										int &posleft,
										int &up,
										int &len)
{
	SDL_GetWindowPosition(pwin,&posleft,&posup);
	SDL_GetWindowSize(pwin,&len,&up);
}
 
void planning_windows::set_picture(SDL_Renderer* pRenderer,
								const std::string &pathpicture,
								const int &posup,
								const int &posleft,
								const int &lenup,
								const int &lenwid){
	SDL_Surface* pSurface = nullptr;
	SDL_Texture* pTexture = nullptr;
 
	pSurface = SDL_LoadBMP(pathpicture.c_str());
	if (pSurface)
	{
		pTexture = SDL_CreateTextureFromSurface(pRenderer,pSurface);
 
 
		if ( pTexture )
		{
//en test
 
	std::cout <<PosistionGauche << ":" <<OldPosistionSuperieur << ":"
	<< WinLargeur << ":"<< Winhauteur << std::endl;
			SDL_Rect dest; //= {PosistionGauche,OldPosistionSuperieur, WinLargeur,Winhauteur};
			dest.x = posup;
			dest.y = posleft;
			dest.w = lenwid;
			dest.h = lenup;
 
			SDL_RenderCopy(pRenderer,pTexture,NULL,&dest); // Copie du sprite grâce au SDL_Renderer
 
			SDL_RenderPresent(pRenderer);
			SDL_DestroyTexture(pTexture); // Libération de la mémoire associée à la texture
		}
		else
		{
			std::cout <<"Erreur dans la fonction SetPicture" <<
						"pointeur pTexture : " << pTexture << " : " << pathpicture << std::endl;
		}
	}
	else
	{
				std::cout <<"Erreur dans la fonction SetPicture" <<
						"pointeur pSurface : " << pSurface  << " : " << pathpicture << std::endl;
	}
}
 
SDL_Renderer* planning_windows::get_renderer()	{ return pRenderer;}
SDL_Window* planning_windows::get_window()		{ return pWindow;}
 
void planning_windows::set_window_opacity(float opacity,int coldownshow)
{
 
	for (float i=0; i < opacity; i= i + 0.01)
	{
    	//C_MeSDL2Windows::M_SetUpdateScreen();
		//Sleep(coldownShow);
		pause(coldownshow);
		//std::cout << i << std::endl;
		SDL_SetWindowOpacity(pWindow,i);
	}
 
}
bool planning_windows::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 planning_windows::set_exit_sdl(){
    if ( pWindow != nullptr ) 	{ pWindow=nullptr; }
	if ( pRenderer != nullptr ) { pRenderer=nullptr ;}
    SDL_Quit();
}
 
int planning_windows::create_windows(const std::string & wtitre,
                                      const int & taillevertical,
                                      const int & taillehorizontal,
                                      const bool & aucentre,
                                      const bool & visible,
                                      const bool & decoration){
 
    int vHideOrShows=-1;
 
    if (visible == true){
        vHideOrShows=SDL_WINDOW_SHOWN;
        WindowsVisible=true;
    }
    else
    {
        vHideOrShows=SDL_WINDOW_HIDDEN;
        WindowsVisible=false;
    }
 
    if (aucentre)
    {
 
		if (decoration==false)
		{
			pWindow = SDL_CreateWindow(wtitre.c_str(),
								SDL_WINDOWPOS_CENTERED,
								SDL_WINDOWPOS_CENTERED,
								taillehorizontal,
								taillevertical,
								vHideOrShows | SDL_WINDOW_BORDERLESS | SDL_WINDOW_OPENGL);
		}
		else
		{
			pWindow = SDL_CreateWindow(wtitre.c_str(),
								SDL_WINDOWPOS_CENTERED,
								SDL_WINDOWPOS_CENTERED,
								taillehorizontal,
								taillevertical,
								vHideOrShows | SDL_WINDOW_OPENGL);
		}
    }
    else
    {
		if (decoration==false)
		{
			pWindow = SDL_CreateWindow(wtitre.c_str(),
								SDL_WINDOWPOS_UNDEFINED,
								SDL_WINDOWPOS_UNDEFINED,
								taillehorizontal,
								taillevertical,
								vHideOrShows | SDL_WINDOW_BORDERLESS | SDL_WINDOW_OPENGL);
		}
		else
		{
			pWindow = SDL_CreateWindow(wtitre.c_str(),
										SDL_WINDOWPOS_UNDEFINED,
										SDL_WINDOWPOS_UNDEFINED,
										taillehorizontal,
										taillevertical,
										vHideOrShows | SDL_WINDOW_OPENGL);
		}
    }
 
 
    if( pWindow == NULL) {
        std::cout << "Erreur: pointeur null suite a la creation de la fenêtre";
        WindowsVisible = false;
        return -1;
    }
    else
	{
        planning_windows::SetGpuRenderer();
        return 0;
    }
}
 
int planning_windows::pause(const Uint32 & Time){
    if( pWindow )
    {
        SDL_Delay(Time);
    }
    else
    {
        fprintf(stderr,"Erreur de pause ?: %s\n",SDL_GetError());
    }
 }
 
void planning_windows::destruction_windows(){
 
    if( pWindow )
    {
        SDL_DestroyWindow(pWindow);
    }
 
    pWindow=nullptr;
}
 
bool planning_windows::set_full_screen(){
    if( pWindow )
    {
            if (SDL_SetWindowFullscreen(
                pWindow,
                SDL_WINDOW_FULLSCREEN_DESKTOP ) == 0 )
            {
                return true;
            }
            else
            {
                return false;
            }
    }
    return false;
}
 
int planning_windows::get_resolution(std::vector<int> & vechauteur,
									std::vector<int> & veclargeur,
                                    std::vector<int> & 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;
*/
            vechauteur.push_back(displayMode.h);
            veclargeur.push_back(displayMode.w);
            vecfrequance.push_back(displayMode.refresh_rate);
        //fprintf(stdout, "Mode %d : %dx%dx%d\n", i, displayMode.w, displayMode.h, displayMode.refresh_rate);
    }
    return -4;
}
 
void planning_windows::SetGpuRenderer(){
    pRenderer = SDL_CreateRenderer(pWindow, -1, SDL_RENDERER_ACCELERATED);
}
void planning_windows::set_luminositer(const float & lum){
    if( pWindow )
    {
        SDL_SetWindowBrightness(pWindow,lum);
    }
    else
    {
       std::cout << "Erreur pointeur invalide M_SetLuminositer " << std::endl;
    }
}
void planning_windows::set_update_screen(){
    if( pWindow )
    {
        SDL_RenderPresent(pRenderer);
    }
    else
    {
        std::cout << "Erreur pointeur invalide M_SetUpdateScreen " << std::endl;
    }
}
void planning_windows::set_windows_show(){
    SDL_ShowWindow(pWindow);
    WindowsVisible = true;
}
void planning_windows::set_windows_hide(){
	SDL_HideWindow(pWindow);
    WindowsVisible = false;
}
void planning_windows::couleur_de_fond( const int  	& rouge,
                                      	const int & vert ,
                                      	const int & bleu,
                                      	const int & transparence)
{
    SDL_SetRenderDrawColor(pRenderer, rouge, vert, bleu, transparence);
    SDL_RenderClear(pRenderer);
}
 
void planning_windows::set_permit_change_size(){
    if( pWindow )
    {
        SDL_SetWindowResizable(pWindow,SDL_TRUE);
    }
}
 
std::string planning_windows::get_event()
{
    SDL_Event event;
 
    while ( SDL_PollEvent(&event) != 0 )
    {
        switch (event.type)
        {
        case SDL_KEYDOWN:
			if ( event.key.keysym.scancode == SDL_SCANCODE_ESCAPE )
			{
				return "exit";
			}
 
			//return event.key.keysym.scancode;
		break;
        case SDL_KEYUP:
//                   fprintf(stdout, "Un relachement d une touche :\n");
//                   fprintf(stdout, "\trépétition ? : %d\n",event.key.repeat);
//                   fprintf(stdout, "\tscancode : %d\n",event.key.keysym.scancode);
//                   fprintf(stdout, "\tkey : %d\n",event.key.keysym.sym);
			if ( event.key.keysym.scancode == SDL_SCANCODE_ESCAPE )
			{
				return "exit";
			}
        case SDL_MOUSEMOTION:
        break;
        case SDL_MOUSEBUTTONUP:
        break;
        case SDL_MOUSEBUTTONDOWN:
        		std::cout << "Windows SDL_MOUSEBUTTONDOWN" << std::endl;
        break;
        case SDL_MOUSEWHEEL:
        case SDL_WINDOWEVENT:
				SDL_GetWindowPosition(pWindow,&PosistionGauche,&PosistionSuperieur);
        		if (PosistionGauche != OldPosistionGauche)
				{
					std::cout << "La Position a gauche a changer" << PosistionGauche << std::endl;
					OldPosistionGauche = PosistionGauche;
					planning_windows::set_update_screen();
				}
        		if (PosistionSuperieur != OldPosistionSuperieur)
				{
					std::cout << "La Posistion sur la hauteur a changer" << PosistionSuperieur << std::endl;
					OldPosistionSuperieur = PosistionSuperieur;
					planning_windows::set_update_screen();
				}
 
				SDL_GetWindowSize(pWindow,&WinLargeur,&Winhauteur);
        		if (WinLargeur != OldWinLargeur)
				{
					std::cout << "La largeur a changer" << WinLargeur << std::endl;
					OldWinLargeur = WinLargeur;
					planning_windows::set_update_screen();
				}
 
        		if (Winhauteur != OldWinhauteur)
				{
					std::cout << "La hauteur a changer" << Winhauteur << std::endl;
					OldWinhauteur = Winhauteur;
					planning_windows::set_update_screen();
				}
 
				if (event.window.event == SDL_WINDOWEVENT_CLOSE){ return "exit"; }
				break;
			default:
                std::cout << event.type << std::endl;
        }
    }
    return "continue";//sans ce type de retour sa provoque: process returned -1073741819 (0xC0000005)
}
 
void planning_windows::set_windows_priority_show()
{
	SDL_RaiseWindow(pWindow);
}

fichier c_sdl2_button.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
 
#ifndef DEF_ME_SDL2_BUTTON
#define DEF_ME_SDL2_BUTTON
 
#include <SDL2/SDL.h>
 
#include <string>
#include <iostream>
 
class Button
{
public:
	//constructeur
    Button(SDL_Renderer* _pRenderer,
			std::string & pathimage_up ,
			std::string & pathimage_down,
			std::string & pathimage_select ,
			int x, int y, int w, int h)						;
	void SetPicture(int id)									;// bug sur le rendrerr le pointeur a la bonne valeur ??
	void show(int id)									;//chargement  et affichage
	bool get_in_the_area(int posup,int posleft,
							int lenup,int lenwid)			;// a faire !
protected:
	void set_pos_destination()								;//correct defini la position,
private:
 
	bool loadpicture(std::string pathpicture,int id)		                ;//charge les images, les gardes dans un tableaux
	SDL_Surface* pSurface [2]			;
	SDL_Texture* pTexture [2]			;
	SDL_Renderer* pRenderer = nullptr	;// bug la librarie revoiye un -1 : Invalid renderer
 
	std::string pathimage_down 			;// a faire
	std::string pathimage_select		        ;// a faire
 
	std::string pathpicture				;// a faire
	int posup							;// position depuis le haut
	int posleft							;// position depuis la gauche
	int lenup							;
	int lenwid							;
	SDL_Rect dest						; //{PosistionGauche,OldPosistionSuperieur, WinLargeur,Winhauteur};
};
#endif

fichier c_sdl2_button.cpp

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
 
#include "c_sdl2_button.hpp"
//constructeur
Button::Button(SDL_Renderer* _pRenderer,
				std::string &_path_picture,
				std::string &_pathimage_down,
				std::string &_pathimage_select ,
				int _posup,	int _posleft, int _lenup, int _lenwid)
 
{
	pRenderer			        = _pRenderer		;
 
	pathpicture			= _path_picture		;
	pathimage_down		= _pathimage_down	;
	pathimage_select	        = _pathimage_select	;
 
	posup				= _posup 			;
	posleft				= _posleft			;
	lenup				= _lenup			;
	lenwid				= _lenwid			;
 
 	if (Button::loadpicture(pathpicture,0)== false){std::cout << "Erreur image 0"<<  std::endl;};
 	Button::loadpicture(pathimage_down,1);
 	Button::loadpicture(pathimage_select,2);
}
 
void Button::show(int id){
	Button::set_pos_destination();
	Button::SetPicture(id);
}
 
bool Button::loadpicture(std::string pathpicture,int id)
{
	pSurface[id] = SDL_LoadBMP(pathpicture.c_str());
	if (pSurface[id])
	{
		std::cout << "DEBUG POINTEUR: " << pRenderer << std::endl;
		pTexture[id] = SDL_CreateTextureFromSurface(pRenderer,pSurface[id]);
		if ( pTexture )
		{
			return true;
		}
		else
		{
			std::cout <<"Erreur dans la fonction SetPicture" <<
						"pointeur pTexture : " << pTexture[id] << " : " << pathpicture << std::endl;
			return false;
		}
	}
	else
	{
		std::cout <<"Erreur dans la fonction SetPicture" <<
				"pointeur pSurface : " << pSurface[id]  << " : " << pathpicture << std::endl;
		return false;
	}
}
 
void Button::set_pos_destination()
{
			dest.x = posup;
			dest.y = posleft;
			dest.w = lenwid;
			dest.h = lenup;
}
 
void Button::SetPicture(int id)
{
	std::cout << "ID: " << id   << std::endl;
	int res=SDL_RenderCopy(pRenderer,pTexture[id],NULL,&dest);
	if (res != 0) // Copie du sprite,souce aux complet(NULL) sur dest
	{
		std::cout << "SDL_RenderCopy : "<< res  << " : " << SDL_GetError() <<  std::endl;
	}
	SDL_RenderPresent(pRenderer);		//Ecriture sur la cible , (affichage)
	SDL_DestroyTexture(pTexture[id]);	// Libération de la mémoire associée à la texture
}

j'ai quelque souci a coller le code aux niveau indentation mai sa devrai suffire. il faut évidement placer les images qui vont bien
Merci pour ton aide

[panthere noire]

Bon j'ai tenter de passer par reference a un pointeur .... comme ceci

Code :

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

SDL_Renderer*& _pRenderer

ça n'a rien changer, pas de warning ni d'erreur. je commence a me demander si c est pas la lib qui a un problème ....

[Kannagi]

ça n'a rien changer, pas de warning ni d'erreur. je commence a me demander si c est pas la lib qui a un problème ....

réponse courte : Non

[panthere noire]

j'ai comme l'impression que SDL_RenderCopy a besoins d'un "effaçage" si l'image est la même a nouveau ??
sa manque une bonne doc quand même, sur le wiki officiel c'est documenter, mai par contre c est a la devinette pour trouve l’enchaînement si je puis dire merci tout de même pour votre fabuleux soutien.

[Kannagi]

Il faut tout effacer oui , la 2D ou la 3D sur las API "bas niveau" même principe le matériel dessine sur le frame buffer, et donc non il efface pas le frame buffer si on ne le lui demande pas
Mais en général on efface pas souvent , si tu fais un jeux vidéo le "background" sert souvent d'effacement (vu que tu vas à chaque fois le draw).

[Bousk]

sa manque une bonne doc quand même, sur le wiki officiel c'est documenter,

C'est documenté mais ça manque de doc ?

j'ai comme l'impression que SDL_RenderCopy a besoins d'un "effaçage" si l'image est la même a nouveau ??

Gné ? render copy copie une texture sur le renderer qui sert de tableau d'affichage. Si tu l'effaces pas il s'en cognera pas mal, rien ne t'interdit de dessiner par-dessus la frame d'avant. Le rendu risque juste d'être bof.

[panthere noire]

Il faut tout effacer oui , la 2D ou la 3D sur las API "bas niveau" même principe le matériel dessine sur le frame buffer, et donc non il efface pas le frame buffer si on ne le lui demande pas
Mais en général on efface pas souvent , si tu fais un jeux vidéo le "background" sert souvent d'effacement (vu que tu vas à chaque fois le draw).

hein quoi ???
Donc donc je doit tout redessiner a chaque modification mai la charge est énorme,
c'est la que le manque de documentation ce fait sentir

Merci pour ta réponse

[Kannagi]

hein quoi ???
Donc donc je doit tout redessiner a chaque modification mai la charge est énorme,

t'inquiete pas , ton GPU tiendra le coup
Par contre , tu ne dev pas depuis longtemps si ?
Parce que ça marche comme ça depuis euh 40 ans

Par contre énorme c'est relatif , comme j'aime bien les vielles machines tu prend une NeoGeo (sorti en 1989), elle était capable de dessiner 380 sprite par frame (donc 22800 sprite par seconde).
Si on parle de la PS1 (1994) , elle pouvait draw 300 000 polygone par seconde :p
Ce genre de chiffre n'a fait que augmenté ^^
Bref pour dire que deux bouton , par ci par là , c'est du pipi de chat de nos jours

c'est la que le manque de documentation ce fait sentir

Est ce qu'une doc doit expliquer ce genre de détails , je ne sais pas.
(Une doc va pas forcément réexpliquer comment fonctionne le rendu depuis ces 30 dernière années ).

[panthere noire]

C'est documenté mais ça manque de doc ?


Gné ? render copy copie une texture sur le renderer qui sert de tableau d'affichage. Si tu l'effaces pas il s'en cognera pas mal, rien ne t'interdit de dessiner par-dessus la frame d'avant. Le rendu risque juste d'être bof.

non ça ne l’empêche pas, mai si tu le fait 2 fois avec la même texture la réponse c'est non ! il te sort l'erreur que je me prend depuis le début de ce post. j'ai pas trouver pourquoi la même texture ne peux pas être ré-utiliser sans la charger depuis sa source en l'ocurence un fichier, mai c est lier a mon manque d'expérience en la matière c'est indéniable.

La sdl a un comportement différent de ce qu'on trouve dans un livre de c++ c'est donc documenter par son auteur qui a déjà a mon avis sacrement du bosser pour faire une libraire de ce type que je remercie, le souci c est qu'il n'y a que peux d'exemple, surtout ceux qui sont récent et qui ne date pas d'il y a plus de 10 ans... si la pèche aux info par google est possible il ne faut pas perdre de vue que souvent c'est plus exploitable. Par exploitable, j'entend que moi en temps que débutant je puisse le comprendre et pouvoir le reproduire.

En répondant de cette manière tu ne facilite pas la tache a ceux qui veule progresser, mai aux contraire tu les ralentis.
n'y vois pas une attaque personnel, mai plutôt une manière de rappeler que le titre du post n'est pas ce sujet qui si besoins est peux ce poursuivre en priver.

Merci pour vos réponse

[panthere noire]

Kannagi, merci pour ta réponse. je suis un peut étonner c est tout de savoir qu'il faut tout redessiner

[Bousk]

Encore une fois, tu dis n'importe quoi. Et le répéter ne le rendra pas moins faux.
Tu constates un truc faux et généralises une erreur/te voiles la face en prétendant que ça vient de la lib alors que c'est sans l'ombre d'un doute dans ton code.

D'abord, SDL ne se comporte pas différemment du C++. C'est une lib écrite en C qui permet d'afficher des trucs.
Ça n'a rien à voir avec le C++, et surtout il n'y a rien d'extraordinaire à l'utiliser.
Tu peux pas un jour décider de faire un jeu et espérer que la doc de SDL t'accompagne du début à la fin.
Le but de la doc d'une lib c'est de lister ses fonctions et expliquer comment la lib fonctionne. Pas de reprendre des décennies d'écrits à ce sujet.
Ce n'est pas de détailler le développement d'un jeu de A à Z. Déjà parce que c'est quasi impossible, mais en plus ça n'a rien à voir avec le but d'une doc de lib.

Ensuite Google est une source d'infos viable, et oui il faut adapter ce qu'on y trouve parce que scoop : chaque situation est différente et tu ne peux pas te conter de copier/coller sans réfléchir un code.
Ça va parfois marcher, très souvent non, et utiliser ses neurones c'est bien aussi.
Et si les exemples datent de 10 ans c'est parce que beaucoup sont pour SDL1 ou 1.2 et non SDL2 et que SDL est encore plus vieille que ça, je l'utilisais déjà il y a 15 ans et c'était pas nouveau.
Vu que c'est du C, on s'en moque pas mal et tous les exemples sont encore valides et ne souffre pas des dernières évolutions du langage, pour peu de faire un minimum d'effort pour les adapter à son cas.
Et ils ont même fourni un guide de transition pour facilier le passage de 1.2 à 2. Et on y apprend même que le guide est disponible en français sur... développez ! Merci LittheWhite.
Si tu veux juste un truc récent il y a SFML, qui a largement ma préférence depuis qu'elle existe.

Enfin, concernant la réutilisation d'une texture, encore heureux que c'est possible.
Si chaque frame devait recharger l'image depuis le disque, tu passerais jamais les 10fps dans une vraie app... voire bien moins Avec un jeu un peu complexe il faudrait plus compter en fps mais en spf.
Le test suivant est très simple, avec du code qui vient directement de la doc, et fonctionne parfaitement comme attendu et prouve une bonne fois pour toutes, si tu fais pas preuve de mauvaise foi, que tu as tord.

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
#include <SDL.h>
#include <random>
#undef main
#define WIN_W 640
#define WIN_H 480
 
int main(int argc, const char* argv[])
{
	SDL_Init(SDL_INIT_VIDEO);
 
	SDL_Window* window = SDL_CreateWindow(
        "An SDL2 window",                  // window title
        SDL_WINDOWPOS_UNDEFINED,           // initial x position
        SDL_WINDOWPOS_UNDEFINED,           // initial y position
        WIN_W,                               // width, in pixels
        WIN_H,                               // height, in pixels
        SDL_WINDOW_OPENGL                  // flags - see below
    );
    SDL_Renderer* renderer = SDL_CreateRenderer(window, -1, SDL_RENDERER_ACCELERATED);
 
    SDL_Surface* surface = SDL_LoadBMP("test.bmp");
    const int pic_w = surface->w;
    const int pic_h = surface->h;
    SDL_Texture* texture = SDL_CreateTextureFromSurface(renderer, surface);
    SDL_FreeSurface(surface);
 
    std::default_random_engine generator;
    while (1)
    {
        SDL_Event e;
        if (SDL_PollEvent(&e))
        {
            if (e.type == SDL_QUIT)
            {
                break;
            }
        }
 
        SDL_Rect pos;
        pos.x = std::uniform_int_distribution<int>(0, WIN_W - pic_w)(generator);
        pos.y = std::uniform_int_distribution<int>(0, WIN_H - pic_h)(generator);
        pos.w = pic_w;
        pos.h = pic_h;
        //SDL_RenderClear(renderer);
        SDL_RenderCopy(renderer, texture, NULL, &pos);
        SDL_RenderPresent(renderer);
        SDL_Delay(5000);
    }
 
    SDL_DestroyTexture(texture);
    SDL_DestroyRenderer(renderer);
    SDL_DestroyWindow(window);
    SDL_Quit();
	return 0;
}

Non je n'efface pas, je ne recharge jamais l'image non plus parce que c'est au mieux stupide et un coup à tuer ses perfs, et voilà j'ai une image de plus qui apparaît toutes les 5s.