Bonjour,

Lorsque j'exécute ce code, j'ai une boule arc-en-ciel qui tourne en continu. Est-ce que vous sauriez me dire s'il y a une erreur dans le code ? Je précise que si je supprime la ligne "glutIdleFunc(anime);" dans le main, le code s'exécute correctement. J'utilise Xcode sur Mac OS Sierra.

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
// CubeFacettes.c
// affichage d'un cube unitaire modélisé par des facettes
// vu depuis 1,2,3
 
#include <GLUT/glut.h> // OpenGL + GLUT
#include <stdio.h>
#include <math.h>
#include <unistd.h>
 
 
const float frequence = 10.0;// frequence de rafraîchissement
const float increment = 1.0; // incément de l'angle en degrés
float angle = 0; // angle de rotation (variable globale)
 
const int fenetreX = 200; //abscisse du coin supérieur gauche
const int fenetreY = 200; // ordonnée du coin supérieur gauche
#define fenetreHauteur 300 // hauteur de la fenêtre
#define fenetreLargeur 400 // largeur de la fenêtre
const GLfloat observateurX = 3.0; // position de l'observateur
const GLfloat observateurY = 2.0;
const GLfloat observateurZ = 1.0;
const GLfloat ouverture = 45.0; // angle d'ouverture
const GLfloat avant = 1.0; // plan avant pour le découpage
const GLfloat arriere = 1000.0; // plan arrière
// rapport des axes de la fenêtre
const GLfloat rapport = (float)fenetreLargeur / (float)fenetreHauteur;
 
void anime(void)
{
    angle = angle + increment; // rotation
    if (angle > 360.0)
         angle = angle - 360.0;
    glutPostRedisplay();
 
}
 
const GLfloat P[8][3] = // tableau des sommets du cube
{
    { -0.5, -0.5, +0.5 }, // P0
    { +0.5, -0.5, +0.5 }, // P1
    { +0.5, +0.5, +0.5 }, // P2
    { -0.5, +0.5, +0.5 }, // P3
    { -0.5, -0.5, -0.5 }, // P4
    { +0.5, -0.5, -0.5 }, // P5
    { +0.5, +0.5, -0.5 }, // P6
    { -0.5, +0.5, -0.5 } // P7
};
 
const GLubyte arete[12][2] = // tableau des arêtes du cube
{
    { 0, 1 }, { 1, 2 }, { 2, 3 }, { 3, 0 },
    { 4, 5 }, { 5, 6 }, { 6, 7 }, { 7, 4 },
    { 0, 4 }, { 1, 5 }, { 2, 6 }, { 3, 7 }
};
 
const GLubyte facette[6][4] =
{
    { 0, 1, 2, 3 }, { 4, 7, 6, 5 }, { 5, 6, 2, 1 },
    { 7, 3, 2, 6 }, { 4, 0, 3, 7 }, { 4, 5, 1, 0 }
};
 
void cube()
{
    int i; // variable de boucle
    for (i = 0; i<6; i++) // 6 facettes
    {
        glBegin(GL_POLYGON);
        glVertex3fv(P[facette[i][0]]);
        glVertex3fv(P[facette[i][1]]);
        glVertex3fv(P[facette[i][2]]);
        glVertex3fv(P[facette[i][3]]);
        glEnd();
    }
}
 
 
 
void reshape(int w, int h)
{
    glViewport(0, 0, (GLsizei)w, (GLsizei)h);
    glMatrixMode(GL_PROJECTION);
    glLoadIdentity();
    gluPerspective(ouverture, // angle d'ouverture
                   rapport, // rapport des axes largeur/hauteur
                   avant, // distance plan avant
                   arriere); // distance plan arrière
    glMatrixMode(GL_MODELVIEW);
}
 
void init(void) // initialisations
{
    glClearColor(1.0, 1.0, 1.0, 0.0);//blanc
    glMatrixMode(GL_MODELVIEW);// matrice de modélisation
    glLoadIdentity(); // matrice identité
    gluLookAt(observateurX, observateurY, observateurZ, // depuis
              0.0, 0.0, 0.0, // vers
              0.0, 0.0, 1.0); // Oz vers haut pour l’Europe
    //0.0, 1.0, 0.0); // Oy vers haut pour les USA
}
 
void display(void) // affichage d’un cube unitaire
{
    glClear(GL_COLOR_BUFFER_BIT);
 
    glColor3f(0.0, 0.0, 0.0); // noir
    glPushMatrix();
    glRotatef(angle,1.0,0.0,0.0);
    glutWireCube(1.0);
    glPopMatrix();
    glutSwapBuffers( );
    sleep((float)1.0/frequence*(float)1000.0);// attente en ms
}
 
 
int main(int argc, char** argv)
{
    glutInit(&argc, argv); // initialisation de la GLUT
    glutInitDisplayMode // mode d'affichage
    (GLUT_DOUBLE | // tampon double
     GLUT_RGB); // couleur RGB)
    glutInitWindowSize(fenetreLargeur, fenetreHauteur);
    glutInitWindowPosition(fenetreX, fenetreY);
    glutCreateWindow(argv[0]);// création de la fenêtre
    init(); // initialisations de l'application
    glutDisplayFunc(display); // affichage de l'application
    glutReshapeFunc(reshape); // redimensionnement
    glutIdleFunc(anime);
    glutMainLoop(); // boucle de gestion des événements
    return 0;
}
Merci pour votre aide.