Discussion :

[wallace27]

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.

[wallace27]

J'ai peut-être une piste, je crois que c'est mon sleep qui pose problème car en le supprimant je peux exécuter mon application et le cube tourne bel et bien.

[dragonjoker59]

Faut arrêter ce code OpenGL 1.X, il ne te servira à rien, nulle part.
Quand tu vas passer à une version "moderne", ou en tout cas utilisable, d'OpenGL (la 3.2 est sortie en 2009), tu vas devoir tout réapprendre.

[Kannagi]

Je plussoie Dragonjoker , de plus glut est une librairie un peu vielle et buggais (sauf si tu as pris freeglut).
OpenGL1/2 il n'y a pas de raison pour que tu l'apprenne (sauf si tu vise une machine qui ne possède que cela ).

[wallace27]

D'accord, alors je vais vous écouter et à mon examen je vais écrire comme réponse comme quoi je n'ai pas à utiliser OpenGL 1 et 2 et que par conséquent je ne répondrai à aucune question et ne ferai aucun exercice. Je vous tiens au courant de la note qu'on me donnera et vous remercie pour votre aide.

[dragonjoker59]

Quel cours noté d'OpenGL peut encore se baser sur cette version antédiluvienne ?
Ce cours ne te servira tout simplement jamais...
Après, si c'est pour valider une année d'une formation payante, je comprends...
Mais retiens bien qu'on t'apprend un truc inutile de nos jours.

Pour en revenir à ton soucis, tu ne l'exprimes tout simplement pas...
Que se passe-t-il, et que devrait-il se passer ?