Bonjour,

Je suis en train d'apprendre C++ et SDL2 et après avoir lu les tutoriels de démarrage de LittleWhite sur SDL2, je suis tombé sur les tutoriels à propos du tilemapping.
Comme le sujet m’intéresse je me suis dit : pourquoi ne pas en profiter pour reprendre le code du tuto et le transformer pour utiliser C++ et SDL2.

Voici donc le code du premier tutoriel sur le tilemapping, revu pour utiliser C++ et SDL2.
Pourriez-vous me faire des commentaires à la fois sur l'utilisation de SDL2 et sur celle de C++ ?
Je répète que je suis complètement novice à la fois avec C/C++ et SDL/SDL2.

Merci d'avance,
Eldergrim

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
#include <SDL2/SDL.h>
#include <SDL2/SDL_Image.h>
 
#include <iostream>
#include <string>
 
using namespace std;
 
const int LARGEUR_TILE = 24;  // hauteur et largeur des tiles.
const int HAUTEUR_TILE = 16; 
 
const int NOMBRE_BLOCS_LARGEUR = 15;  // nombre a afficher en x et y
const int NOMBRE_BLOCS_HAUTEUR = 13;
 
string table[] = {
"000000000000000",
"000000000000000",
"000000000000000",
"000000000000000",
"100000000111110",
"000000000000000",
"000000000000000",
"000000000000000",
"003400022220022",
"005600000000000",
"005600000000000",
"005600000000000",
"777777777777777"};
 
void logSDLError(ostream &os, const string &msg) {
        os << msg << " error : " << SDL_GetError() << endl;
}
 
SDL_Texture* loadTexture(string filename, SDL_Renderer *ren) {
    SDL_Texture *texture = nullptr;
    SDL_Surface *loadedImage = SDL_LoadBMP(filename.c_str());
 
    if (loadedImage != nullptr) {
        texture = SDL_CreateTextureFromSurface(ren, loadedImage);
        SDL_FreeSurface(loadedImage);
 
        if (texture == nullptr) {
            logSDLError(cout, "CreateTextureFromSurface");
        }
    }
    else {
       logSDLError(cout, "LoadBMP");
    }
    return texture;
}
 
void afficher(  SDL_Texture *tileset,
                SDL_Renderer *pRenderer,
                string table[],
                int nombre_blocs_largeur,
                int nombre_blocs_hauteur)
{
	SDL_Rect Rect_dest;
	Rect_dest.w = LARGEUR_TILE;
	Rect_dest.h = HAUTEUR_TILE;	
 
	SDL_Rect Rect_source;    
	Rect_source.y = 0;
	Rect_source.w = LARGEUR_TILE;
	Rect_source.h = HAUTEUR_TILE;
 
	for(int i=0; i<nombre_blocs_largeur; i++)
	{
		for(int j=0; j<nombre_blocs_hauteur; j++)
		{
			Rect_dest.x = i*LARGEUR_TILE;
			Rect_dest.y = j*HAUTEUR_TILE;            
			Rect_source.x = (table[j][i] - '0') * LARGEUR_TILE;			
			SDL_RenderCopy(pRenderer, tileset, &Rect_source, &Rect_dest);	
		}
	}
 
	SDL_RenderPresent(pRenderer);
}
 
int main(int argc, char** argv)
{
	SDL_Window *screen;
    SDL_Renderer *pRenderer;
    SDL_Texture *tileset;
	SDL_Event event;
    bool quit = false;
 
    if (SDL_Init(SDL_INIT_EVERYTHING) != 0) {
        logSDLError(cout, "SDL_Init");
        return 1;
    }      // prepare SDL
 
	screen = SDL_CreateWindow(  "Tile Mapping - 001",
                                SDL_WINDOWPOS_CENTERED,
                                SDL_WINDOWPOS_CENTERED,
                                LARGEUR_TILE*NOMBRE_BLOCS_LARGEUR,
                                HAUTEUR_TILE*NOMBRE_BLOCS_HAUTEUR,
                                SDL_WINDOW_SHOWN);
    if (screen == nullptr){
        logSDLError(cout, "CreateWindow");
        return 2;
    }
 
    pRenderer = SDL_CreateRenderer(screen, -1, SDL_RENDERER_ACCELERATED | SDL_RENDERER_PRESENTVSYNC);
    if (pRenderer == nullptr){
        logSDLError(cout, "CreateRenderer");
        return 3;
    }
 
	tileset = loadTexture("./tileset1.bmp", pRenderer);
 
    if (tileset == nullptr) {
        logSDLError(cout, "loadTexture");
        return 4;
    }
 
    SDL_SetRenderDrawColor(pRenderer, 0, 0, 0, 255); 
    SDL_RenderClear(pRenderer);
    SDL_RenderPresent(pRenderer);
 
	//Render the scene
    afficher(tileset, pRenderer, table, NOMBRE_BLOCS_LARGEUR, NOMBRE_BLOCS_HAUTEUR);
 
    while (!quit){
        while (SDL_PollEvent(&event)){
            if (event.type == SDL_KEYDOWN)
                quit = true;
        }        
    }    
 
    SDL_DestroyTexture(tileset);    
    SDL_DestroyRenderer(pRenderer);
    SDL_DestroyWindow(screen);
 
    SDL_Quit();
 
	return 0;
}