Maintien de la fenêtre lors du tracé d'une séquence de segments, avec code::blocks sous windows
Dans un programme un peu long, placé en pièce jointe, qui compile correctement, je trace une srie de segments (correspondants à des dominos). J'ai écrit une fonction tracerLigne grâce à l'algorithme de Bresenham, à ce stade, je teste la validité de mon programme en ne traçant que les dominos à l'état initial. Mais j'ai beau faire, mettre des pause(), ou des SDL_Delay(), la fenêtre SDL se ferme immédiatement après l'ouverture.
N.B.: lorsque je ne définis pas de valeur la constante h, dans le header "Constantes.h", la fonction affiche alors une série de points, laissant la fenêtre ouverte.
Voici la main :
Code:
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
| #include <stdlib.h>
#include <SDL.h>
#include <stdio.h>
#include <math.h>
#define HAUTEUR 480
#define LARGEUR 1280
#define NOMBRE_DE_DOMINOS 100
#include "Equa_diff.h"
#include "Dessiner_ligne.h"
void pause();
int main ( int argc, char** argv )
{
#include "Constantes.h"
double *theta = NULL; // la famille (Theta_i en fonction de t)
double *thetap = NULL; // la famille (Theta_i point en fonction de t)
double *thetapp = NULL; // la famille (Theta_i point point en fonction de t)
double *l = NULL; // la famille (l_i en fonction de t)
double *lp = NULL; // la famille (l_i point en fonction de t)
double *dominos = NULL; // la famille des dominos
// allocation des tableaux en mémoire
theta = malloc(NOMBRE_DE_DOMINOS * sizeof(double));
thetap = malloc(NOMBRE_DE_DOMINOS * sizeof(double));
thetapp = malloc(NOMBRE_DE_DOMINOS * sizeof(double));
l = malloc(NOMBRE_DE_DOMINOS * sizeof(double));
lp = malloc(NOMBRE_DE_DOMINOS * sizeof(double));
dominos = malloc(NOMBRE_DE_DOMINOS * sizeof(int));
// On vérifie que l'allocatoin a fonctionné
if (theta == NULL || thetap == NULL || thetapp == NULL || l == NULL || lp == NULL || dominos == NULL)
{
fprintf(stderr,"Impossible d'allouer la mémoire suffisante : %s\n", SDL_GetError() );
exit(EXIT_FAILURE);
}
// On initialise les suites à zéro
int i;
for(i=0;i<NOMBRE_DE_DOMINOS;i++)
{
theta[i] = 0;
thetap[i] = 0;
thetapp[i] = 0;
l[i] = 0;
lp[i] = 0;
}
thetap[0] = thetap0;
// Initialisation de SDL Video
if ( SDL_Init( SDL_INIT_VIDEO | SDL_INIT_TIMER ) < 0 )
{
fprintf(stderr,"Erreur d'initialisation de la SDL: %s\n", SDL_GetError() );
exit(EXIT_FAILURE);
}
// S'assurer due la mémoire soit libérée à la fin
atexit(SDL_Quit);
// Crée une nouvelle fenêtre
SDL_Surface* screen = SDL_SetVideoMode(LARGEUR, HAUTEUR, 32,
SDL_HWSURFACE);
if ( !screen )
{
fprintf(stderr,"Erreur de chargement du mode video: %s\n", SDL_GetError());
exit(EXIT_FAILURE);
}
// Ouverture de la fenêtre
SDL_WM_SetCaption("Chute de dominos",NULL);
// Ici débute la partie graphique
for(i=0;i<NOMBRE_DE_DOMINOS;i++)
{
tracerLigne(screen, 140 + 10 * i, HAUTEUR - 200, 140 + 10 * i + 10 * h * sin(theta[i]) / DELTA, HAUTEUR - 200 - 10 * h * cos(theta[i]), SDL_MapRGB(screen->format, 255, 255, 255));
SDL_Delay( 5000 );
}
// Ici se termine la partie graphique
// Enfin, on met à jour l'écran
SDL_Flip(screen);
// On met le progamme en pause
// On libère tous les tableaux
free(theta);
free(thetap);
free(thetapp);
free(l);
free(lp);
free(dominos);
// all is well ;)
printf("Exited cleanly\n");
return EXIT_SUCCESS;
}
void pause()
{
int continuer = 1;
SDL_Event event;
while(continuer)
{
SDL_WaitEvent(&event);
switch(event.type)
{
case SDL_QUIT:
continuer = 0;
}
}
}
} |
voici le fichier tracer ligne :
Code:
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
|
#include <SDL.h>
void setPixel(SDL_Surface *screen, int x, int y, Uint32 coul)
{
*((Uint32*)(screen->pixels) + x + y * screen->w) = coul;
}
// D'apres l'algorithme de Bresenham
void tracerLigne(SDL_Surface *screen, int x1, int y1, int x2, int y2, Uint32 couleur)
{
int x;
int y;
int xincr;
int yincr;
int Dx;
int Dy;
int erreur; // Ce n'est pas tout a fait l'erreur decrit dans l'algorithme, mais celle-ci multipliee par Dx, afin de s'epargner deux cas supplementaires
x = x1;
y = y1;
Dx = abs(x2 - x1);
Dy = abs(y2 - y1);
(x1 > x2) ? (xincr = -1) : (xincr = 1);
(y1 < y2) ? (yincr = -1) : (yincr = 1);
setPixel(screen, x, y, couleur);
if (Dx >= Dy)
{
erreur = Dx / 2;
while((x != x2) || (y != y2))
{
x += xincr;
erreur += Dy;
if (erreur > Dx)
{
y += yincr;
erreur -= Dx;
}
setPixel(screen, x, y, couleur);
}
}
else
{
erreur = Dy / 2;
while((x != x2) || (y != y2))
{
y += yincr;
erreur += Dx;
if (erreur > Dy)
{
x += xincr;
erreur -= Dy;
}
setPixel(screen, x, y, couleur);
}
}
} |
Quelque chose dans cette fonction empêcherait la fenêtre de rester ouverte, mais quoi?
