Etape 5 : Exemple d`un dessin en 3D

Etape 5 : Exemple d’un dessin en 3D
Nous connaissons à présent les bases relatives à OpenGL grâce à GLUT.
Tous nos exemples ont été réalisés en 2D jusqu’à présent, il est temps de nous intéresser à un
exemple en 3D : un cube.
Pour cela, il est nécessaire de définir ici certaines bases :
-
-
Le cube a 6 faces.
Il faut donc procéder à un autre dessins que celui utilisé lors des précédents tutoriaux : en
effet, nous n’utiliserons plus le dessin de polygone à 4 côtés (un carré avec GL_POLYGON)
mais nous utiliserons GL_QUADS qui permet de créer un quadrilatère et les relier entre eux,
ce qui est beaucoup plus maniable et utile dans notre cas.
Nos glVertex changeront également car nous travaillons en 3D : il faut donc rajouter la
troisième coordonnée : celle de l’espace appelée « z ».
Ici, aucune interaction n’est prévue avec le clavier ou la souris.
Voici notre main :
int main(int argc,char **argv) {
glutInit(&argc,argv);
glutInitDisplayMode(GLUT_RGBA | GLUT_SINGLE);
glutInitWindowSize(500,500);
glutInitWindowPosition(100, 50);
glutCreateWindow("Fenetre OpenGL");
glEnable(GL_DEPTH_TEST);
glEnable(GL_COLOR_MATERIAL);
glutDisplayFunc(display);
glutMainLoop() ;
return(0);
}
On remarque que deux lignes sont apparues :
1) glEnable(GL_DEPTH_TEST);
2) glEnable(GL_COLOR_MATERIAL);
Ces lignes sont obligatoires lorsque l’on travaille en 3D : en effet, elles permettent l’affichage des
faces cachées : ces lignes sont donc indispensables pour le bon affichage du cube car en effet, si nous
sommes privés des faces cachées, alors le travail n’a aucun intérêt et le résultat n’est pas celui
espéré.
Dans notre exemple, nous allons colorier chaque face de notre cube avec une couleur différente pour
plus de visibilité.
Voici le début de la fonction d’affichage :
void display(void) {
glClearColor(0.5,0.5,0.5,0.0);
glClear(GL_COLOR_BUFFER_BIT);
glMatrixMode(GL_MODELVIEW);
gluLookAt(0.3,0.3,0.3,0,0,0,0.3,-0.3,0.3);
glBegin(GL_QUADS);
// Ici le code pour le dessin des 6 faces mais non copié car trop long
glEnd();
glFlush();
}
On remarque que les deux premières lignes permettent de remplir le tampon en gris (définie par
glClearColor.
Le plus intéressant à remarquer est la ligne suivante :
1) gluLookAt(0.3,0.3,0.3,0.0,0.0,0.0,0.3,-0.3,0.3);
En effet, la fonction gluLookAt permet la gestion de la caméra, et donc a fortiori la bonne
visualisation de la scène.
Elle a 9 paramètres que l’on va détailler :
- les trois premiers servent à placer la caméra sur le point (x,y,z) spécifié ; ici la caméra est
placée sur le point (0.3,0.3,0.3).
- les trois suivants servent à orienter la caméra vers le point (x,y,z) spécifié ; ici la caméra est
orientée sur le point (0.0,0.0,0.0).
- les trois derniers servent à ce que la caméra visualise la direction (x,y,z) spécifiée ; ici la
caméra visualise (0.3,-0.3,0.3).
On remarquera que la ligne d’avant « glMatrixMode(GL_MODELVIEW); » est présente par
convention, en effet, gluLookAt est exécuté en mode MODELVIEW.
Voici un tableau montrant l’impacte de gluLookAt :
Avec gluLookAt :
Sans gluLookAt :
Ainsi le résultat est très surprenant sans l’utilisation de gluLookAt : on croirait que seul un carré a été
déssiné.
On remarque que sur le bon exemple nos six faces sont visibles : on voit la face bleue, la face rouge,
la face rose, la face verte, la face jaune et la face blanche ; cela grâce aux deux glEnable décrites dans
le main (cf. début du tutorial).
A noter que le projet est disponible et commenté.