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
|
#include <stdlib.h>
#include <math.h>
#include "SDL/SDL.h"
/* Ligne de compilation (je suis sous linux).
* gcc -O3 -march=athlon64 roto.cpp -pthread `sdl-config --cflags --libs` -lGL -lGLU
*
* `sdl-config --cflags --libs` donne -I/usr/include/SDL -D_GNU_SOURCE=1 -D_REENTRANT -L/usr/lib -lSDL
*
* Spécifier l'architecture fait perdre en portabilité mais le gain de vitesse est énorme.
* Toutes les optimisations du code devraient être faites avec le max d'optimisation du compilateur (-O3)
* pour que les tests soient représentatifs.
*/
#define PATH_IMAGE "Fond24.bmp" /* chemin de l'image (bitmap) à faire tourner */
#define FPS_DISP_RATE 2000 /* Temps en ms entre deux affichages des fps */
#define VITESSE_ANGULAIRE M_PI / 10.0f /* Vitesse angulaire en radians par seconde*/
/* Etat des touches du clavier. true pour enfoncée. */
bool etatClavier[512];
/* Fonction de copie de pixels pour ne pas trop dépendre du format de l'image */
void inline SDL_CopyPixel(SDL_Surface* src, int x, int y, SDL_Surface* dest, int i, int j) {
int bpp = src->format->BytesPerPixel;
Uint8 *srcPixel = (Uint8 *)src->pixels + y * src->pitch + x * bpp;
Uint8 *destPixel = (Uint8 *)dest->pixels + j * dest->pitch + i * bpp;
switch(bpp) {
case 1:
*destPixel = *srcPixel;
break;
case 2:
*(Uint16 *)destPixel = *(Uint16 *)srcPixel;
break;
case 3:
/* L'opération sur 24 bits est lente */
destPixel[0] = srcPixel[0];
destPixel[1] = srcPixel[1];
destPixel[2] = srcPixel[2];
break;
case 4:
*(Uint32 *)destPixel = *(Uint32 *)srcPixel;
break;
}
}
/* Effectue une rotation centrale plus un changement d'échelle, alloue automatiquement la mémoire.
* Le zoom est "gratuit". Prendre un rapport de 1 pour retrouver la rotation.
* Les formules mathématiques sont ici appliqués "naïvement". Ce n'est pas l'idéal pour les performances
* mais c'est simple et lisible. C'est un passage conseillé pour vérifier que la logique est bonne.
* Si après en optimisant ça ne marche plus on saura pourquoi.
*/
SDL_Surface* SDL_RotoZoom(SDL_Surface* origine, float angle_radian, float rapport) {
SDL_Surface* destination; /* Surface de destination, allouée ici et retournée */
int mx, my, mxdest, mydest; /* Coordonnées des centres des surfaces */
int i, j; /* Coordonnées de travail lors du parcourt de la surface de destination */
int bx, by; /* Coordonnées de travail, correspondent à i et j dans l'image d'origine */
float tcos, tsin; /* cos et sin de angle_radian */
int largeurdest, hauteurdest; /* Dimentions de la surface de destination */
/*pour éviter pleins d'appels, on stocke les valeurs*/
tcos = cos(angle_radian);
tsin = sin(angle_radian);
/*calcul de la taille de l'image de destination*/
largeurdest= (int) ceil( (origine->w * fabs(tcos) + origine->h * fabs(tsin)) * rapport );
hauteurdest= (int) ceil( (origine->w * fabs(tsin) + origine->h * fabs(tcos)) * rapport );
/*
* alloue la mémoire à l'espace de destination
*/
destination = SDL_CreateRGBSurface(SDL_HWSURFACE, largeurdest, hauteurdest, origine->format->BitsPerPixel,
origine->format->Rmask, origine->format->Gmask, origine->format->Bmask, origine->format->Amask);
/*on vérifie que la mémoire a été allouée*/
if(destination==NULL)
return NULL;
/*calcul des centres des images*/
mxdest = (int) destination->w/2;
mydest = (int) destination->h/2;
mx = (int) origine->w/2;
my = (int) origine->h/2;
/* Coeur de l'algo
* On parcourt la surface de destination pour la remplir
*/
for(j=0; j<destination->h; j++)
for(i=0; i<destination->w; i++) {
/*
* on détermine la valeur de pixel qui correspond le mieux pour la position
* i,j de la surface de destination
*
* on détermine la meilleure position sur la surface d'origine en appliquant
* une matrice de rotation inverse
*/
bx = mx + (int)( ( tcos*(i-mxdest) + tsin*(j-mydest)) / rapport );
by = my + (int)( (-tsin*(i-mxdest) + tcos*(j-mydest)) / rapport );
/* on vérifie que l'on ne sort pas des bords */
if (bx>=0 && bx< origine->w && by>=0 && by< origine->h)
SDL_CopyPixel(origine, bx, by, destination, i, j);
}
return destination;
}
/* Le même en optimisé.
* Les calculs peuvent être grandement simplifiés car d'une boucle à l'autre bx et by augmentent d'une valeur fixe.
* C'est l'optimisation la plus simple. Très intéressante car on ne perd rien en fonctionalité.
*/
SDL_Surface* SDL_RotoZoom_Opt(SDL_Surface* origine, float angle_radian, float rapport) {
SDL_Surface* destination; /* Surface de destination, allouée ici et retournée */
int mx, my, mxdest, mydest; /* Coordonnées des centres des surfaces */
int i, j; /* Coordonnées de travail lors du parcourt de la surface de destination */
int bx, by; /* Coordonnées de travail, correspondent à i et j dans l'image d'origine */
float x, y; /* valeurs de travail (bx et by avant arrondit) */
float ligne_x, ligne_y; /* valeurs au debut des lignes (retour de i à 0) */
float dxi, dyi, dxj, dyj; /* increments des x et y suivant i et j (compteurs des x et y) */
float tcos, tsin; /* cos et sin de angle_radian */
int largeurdest, hauteurdest; /* Dimentions de la surface de destination */
/*pour éviter pleins d'appel, on stocke les valeurs*/
tcos = cos(angle_radian);
tsin = sin(angle_radian);
/*calcul de la taille de l'image de destination*/
largeurdest= (int) ceil( (origine->w * fabs(tcos) + origine->h * fabs(tsin)) * rapport );
hauteurdest= (int) ceil( (origine->w * fabs(tsin) + origine->h * fabs(tcos)) * rapport );
/*
* alloue la mémoire à l'espace de destination, attention,
* la surface est de même taille
*/
destination = SDL_CreateRGBSurface(SDL_HWSURFACE, largeurdest, hauteurdest, origine->format->BitsPerPixel,
origine->format->Rmask, origine->format->Gmask, origine->format->Bmask, origine->format->Amask);
/*on vérifie que la mémoire a été allouée*/
if(destination==NULL)
return NULL;
/* calcul des centres des images */
mxdest = (int) destination->w/2;
mydest = (int) destination->h/2;
mx = (int) origine->w/2;
my = (int) origine->h/2;
/* Initialisation et calculs des incréments */
ligne_x = mx + (-tcos * mxdest - tsin * mydest) / rapport;
ligne_y = my + ( tsin * mxdest - tcos * mydest) / rapport;
dxi = tcos / rapport;
dxj = tsin / rapport;
dyi = -tsin / rapport;
dyj = tcos / rapport;
/* Coeur de l'algo
* On parcourt la surface de destination pour la remplir
*/
for(j=0;j<destination->h;j++){
x = ligne_x;
y = ligne_y;
for(i=0;i<destination->w;i++) {
bx = (int) x;
by = (int) y;
/* on vérifie que l'on ne sort pas des bords*/
if (bx>=0 && bx< origine->w && by>=0 && by< origine->h)
SDL_CopyPixel(origine, bx, by, destination, i, j);
/* On incrémente les coordonnées dans l'image d'origine */
x += dxi;
y += dyi;
}
/* incrément pour le changement de ligne */
ligne_x += dxj;
ligne_y += dyj;
}
return destination;
}
/* Gestion des évènements SDL.
* On se contente de tenir à jour le tableau des touches appuyées même si c'est peu utile ici.
* On ferme sur un SDL_QUIT (arrive en cas de fermeture de la fenêtre par ex).
*/
void GestionEvenements(void) {
SDL_Event e;
while (SDL_PollEvent(&e)) {
switch (e.type) {
case SDL_KEYUP:
etatClavier[e.key.keysym.sym]=false;
break;
case SDL_KEYDOWN:
etatClavier[e.key.keysym.sym]=true;
break;
case SDL_QUIT:
/* Dans l'absolu il faudrait libérer nos surfaces */
SDL_Quit();
exit(EXIT_SUCCESS);
default:
break;
}
}
}
int main(int argc, char* argv[])
{
unsigned int currentFrm;
unsigned int lastFrm;
unsigned int lastFpsDisplay; /* instant du dernier affichage des fps */
float tempsEcoule = 0.0f; /* temps écoulé depuis la dernière image, en secondes */
float fpsCounter = 0; /* compteur des images affichées depuis le dernier calcul de fps */
float angle = 0.0f; /* angle courrant pour la rotation (en radians) */
if (SDL_Init(SDL_INIT_VIDEO | SDL_INIT_TIMER)<0) {
exit(EXIT_FAILURE);
}
SDL_Surface* fenetre = SDL_SetVideoMode(800, 600, 32, SDL_HWSURFACE | /*SDL_FULLSCREEN |*/ SDL_DOUBLEBUF);
if (fenetre==NULL) {
SDL_Quit();
exit(EXIT_FAILURE);
}
/* Initialisation du clavier */
for(int i=0; i<512; i++)
etatClavier[i]=false;
/* Lecture de l'image que l'on va torturer */
SDL_Surface* imageOriginale = SDL_LoadBMP(PATH_IMAGE);
if (imageOriginale==NULL) {
SDL_Quit();
exit(EXIT_FAILURE);
}
/* Boucle principale */
currentFrm = SDL_GetTicks();
lastFrm = currentFrm;
lastFpsDisplay = currentFrm;
while (1) {
/* gestion du temps */
lastFrm = currentFrm;
currentFrm = SDL_GetTicks();
tempsEcoule = (currentFrm-lastFrm)/1000.0f;
/* Affichage du frame rate sur la console */
if(currentFrm-lastFpsDisplay>FPS_DISP_RATE) {
printf("%f\n", fpsCounter*1000.0f/(currentFrm-lastFpsDisplay));
lastFpsDisplay = currentFrm;
fpsCounter = 0;
}
GestionEvenements();
if(etatClavier[SDLK_ESCAPE]) {
/* On quitte sur "échap", avec un évènement SDL_QUIT lancé à la main
* pour arriver au même point d'arrêt qu'avec la fermeture de la fenêtre par exemple.
*/
SDL_Event ev;
ev.type = SDL_QUIT;
SDL_PushEvent(&ev);
}
angle += VITESSE_ANGULAIRE * tempsEcoule;
if(angle>2*M_PI)
angle-=2*M_PI;
/* Effacer l'écran. Utiliser une couleur particulière permet de voir ce qui a été affiché et ce qui est vide */
SDL_FillRect(fenetre, NULL, 0x000f0fff);
SDL_Surface* surfRot = SDL_RotoZoom_Opt(imageOriginale, angle, 1.8);
SDL_BlitSurface(surfRot, NULL, fenetre, NULL);
SDL_FreeSurface(surfRot); /* Très très très important si on ne veut pas manger toute sa ram et plus en 2 minutes */
fpsCounter++;
SDL_Flip(fenetre);
}
/* Jamais atteint */
return EXIT_SUCCESS;
} |
[SOURCE] [SDL] Comment programmer une rotation
Répondre avec citation
Envoyé par fearyourself
)
Ce qui me fait penser qu'il faudrait que je retente avec les fonctions d'accès aux pixels qui n'étaient peut-être pas en inline à l'origine, et elles n'étaient peut-être donc pas si coûteuses que ça.
(mais j'avais la flemme de faire autrement sur le coup)
). Je crois que je vais bientôt apprendre à utiliser gdb 
).
Partager