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 : 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
#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 : 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
 
#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?