Discussion :

[Eldergrim]

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

[Kannagi]

Quel conseil veut tu avoir exactement ?
Le code me semble bon , sauf SDL_RenderPresent(pRenderer); qu'il faudrait pas mettre partout j'ai jamais coder en SDL2 mais il me semble que c'est la fonction qui permet de afficher a écran , et donc de le virer de ta fonction afficher.
Si c'est pour faire un jeu et pas un simple test ben la faut faire une boucle de jeu donc mettre ta fonction afficher sur la boucle.
Apres je te conseille de créer une fonction fps et événement (pour trier les événements).

Apres je trouve ça assez mauvais de mettre le tilemapping dans un fichier ascii , perso je le met dans un fichier binaire , ou les bits de poids faible me sert pour le tiles et les bits de poids fort pour les collisions.

[LittleWhite]

Le code me semble bien. Quelques problèmes d'indentation et je suis d'accord avec la remarque sur SDL_RenderPresent().

Code :

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

1
2
texture = SDL_CreateTextureFromSurface(ren, loadedImage);
        SDL_FreeSurface(loadedImage);

Moi, je supprimerai la surface une fois que l'on sait que la Texture est opérationnelle. Pas avant. Mais c'est vraiment un détail, vu que dans les deux cas on quitte le programme

[Eldergrim]

Bonjour,

Merci pour vos remarques.

Concernant l'indentation ça doit être du au copier/coller lors de la rédaction du message. Ceci dit, les subtiles nuances sur les habitudes d'indentation entre le Java et le C++ peuvent m'échapper.
Ok pour la libération de la SDL_Surface de la texture, ça serait effectivement plus propre.

Par contre je ne suis pas sur de comprendre votre remarque sur SDL_RenderPresent().
D'après ce que j'ai compris cette méthode sert à rafraîchir l'écran avec ce qui doit y être dessiné, c'est bien ça ?
Dans le cadre de cet exemple, sans évolution dans le contenu affiché au fil du temps, on peut donc se permettre de la laisser dans la méthode afficher, non ?

Comment faudrait-il modifier le code dans le cas d'une animation ? Sortir l'appel à SDL_RenderPresent() et le mettre en fin de boucle ?

Merci,
Eldergrim

[LittleWhite]

Le SDL_RenderPresent ne doit être mis que dans la fonction afficher (à la fin) et pas ailleurs. Dans le code actuel, vous avez deux SDL_RenderPresent.
SDL_RenderPresent, ne doit être utilisé, que lorsque les choses à afficher ont toutes était envoyés à à l'écran. La boucle principale devrait être :

Code :

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

1
2
3
4
5
6
while (jeu)
{
   // Effacement de l'écran
   // Affichage des éléments (niveau, personnages...)
   // SDL_RenderPresent() // Envoie des éléments à l'écran
}

Pour les animations

Code :

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

1
2
3
4
5
6
7
while (jeu)
{
   // Effacement de l'écran
   // Mis à jour des éléments (gestion "logique" des animations)
   // Affichage des éléments (niveau, personnages...)
   // SDL_RenderPresent() // Envoie des éléments à l'écran
}

[Eldergrim]

Ok, je vois. Donc ce qui vous chiffonne ici c'est le SDL_RenderPresent() de la ligne 120.

Je vais m'attaquer au deuxième tutoriel, ce qui m'a l'air d'être une autre histoire !

Merci pour vos retours.