Transformations de visualisation en OpenGL

Dans OpenGL, les matrices MODEL_VIEW et PROJECTION sont combinées pour constituer la matrice de transformation qui s’applique aux entités géométriques. La matrice MODEL_VIEW place les objets à l’endroit approprié dans l’espace et permet de passer du repère de l’objet (utilisé lors de la modélisation) au cadre de la caméra. Les objets sont définis dans un repère lors de la modélisation qui est indépendant du processus de visualisation. La matrice PROJECTION permet de spécifier la forme et l’orientation du volume de visualisation. Dans sa position par défaut, la caméra placée à l’origine est orientée dans la direction z négative. Ainsi, si la matrice MODEL_VIEW est l’identité, le repère de la caméra et celui des objets sont identiques.

Changement du repère du monde Dans bien des applications, les objets sont placés autour de l’origine; par conséquent, l’emplacement par défaut de la caméra ne nous permettra pas toujours d’observer tous les objets de la scène ou de les observer sous l’angle désiré. Il faudra alors positionner correctement la caméra ou placer les objets de telle façon qu’ils soient observés comme désiré. Imaginons une scène où plusieurs objets ont été définis initialement, avec comme matrice MODEL_VIEW, l’identité. Des changements ultérieurs à MODEL_VIEW déplacent le système de coordonnées du monde par rapport à celui de la caméra. Les objets définis par la suite seront observés différemment car ceux-ci seront définis à partir du nouveau système de référence.

Changement du repère du monde Considérons la situation suivante : Au départ, nous avons la représentation initiale où un sommet p possède la même représentation dans les 2 repères, celui de l’objet et celui de la caméra. Par la suite, la matrice MODEL_VIEW devient C. Nous avons donc changé le repère des objets. Un sommet q défini après avoir modifié la matrice MODEL_VIEW est à q dans le repère de l’objet et à Cq dans le repère de la caméra. Cela est connu par OpenGL. Vu autrement, le repère de la caméra n’a pas changé et la transformation désignée par MODEL_VIEW est appliquée aux entités géométriques définies dans la scène. Peu importe l’interprétation que l’on en donne, il faut toutefois porter une attention particulière au moment où les objets sont définis par rapport aux changements effectués à la matrice MODEL_VIEW. À n’importe quel moment, la matrice MODEL_VIEW fait le lien entre le repère des objets de la scène et le repère de la caméra.

Changement du repère de la caméra Il s’agit de déplacer la caméra p/r au système de coordonnées du monde. 1er approche Il faut déplacer le repère du monde relativement à celui de la caméra c’est-à-dire, l’observateur domine, les objets de la scène sont orientés, puis déplacés à l’endroit désiré pour observation. En génération d’images, les objets sont définis dans un repère fixe et c’est à l’observateur de se déplacer à la bonne position pour observer ce qu’il désire. 2ième approche Fixer l’emplacement de la caméra (VRP): set_view_reference_point(x, y, z); Désignation de la normale n au plan de vue : set_view_plane_normal(nx, ny, nz); iii) Désignation du vecteur view-up: set_view_up(ux, uy, uz);

Changement du repère de la caméra 3ième approche La fonction Look-at Une méthode plus directe que la précédente est tout à fait appropriée. L’emplacement de la caméra est la position de l’observateur (Ox, Oy, Oz). En considérant un centre d’intérêt (Cx, Cy, Cz), cela détermine VPN et VRP. Il reste alors à fixer le vecteur « view-up ». La fonction suivante peut être appelée : gluLookAt(Ox, Oy, Oz, Cx, Cy, Cz, VUPx, VUPy, VUPz); La fonction gluLookAt permet de passer du système de coordonnées du monde au système de coordonnées de l’observateur (caméra). Exemple : GLMatrixMode(GL_MODELVIEW); glLoadIdentity();

Changement du repère de la caméra Exemple : gluLookAt(4.0, 2.0, 1.0, 2.0, 4.0, -3.0, 2.0, 2.0, -1.0); observateur centre d’intérêt view-up

Exemple : #include <windows.h> #include <GL/glut.h> #include <GL/glaux.h> static GLint w = 500, h = 500; static GLfloat observateur[] = {-1.0, 0.0, 0.0}; static GLfloat interet[] = {0.0, 0.0, 0.0}; static GLfloat vup[] = {0.0, 1.0, 0.0}; void affichage( void ) { glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT); glMatrixMode(GL_MODELVIEW); glLoadIdentity(); gluLookAt( observateur[0], observateur[1], observateur[2], interet[0], interet[1], interet[2], vup[0], vup[1], vup[2]); glutSolidTeapot(0.3); glFlush(); }

Exemple (suite et fin) : void cles(unsigned char cle, int x, int y) { // Utiliser les clés x, X, y, Y, z et Z pour déplacer l'observateur. // Utiliser les clés i, I, j, J, k et K pour déplacer le centre d'intérêt. // Utiliser les clés u, U, v, V, w et W pour déplacer le vecteur view-up. if(cle == 'x') observateur[0]-= 1.0; if(cle == 'X') observateur[0]+= 1.0; if(cle == 'y') observateur[1]-= 1.0; if(cle == 'Y') observateur[1]+= 1.0; if(cle == 'z') observateur[2]-= 1.0; if(cle == 'Z') observateur[2]+= 1.0; if(cle == 'i') interet[0]-= 1.0; if(cle == 'I') interet[0]+= 1.0; if(cle == 'j') interet[1]-= 1.0; if(cle == 'J') interet[1]+= 1.0; if(cle == 'k') interet[2]-= 1.0; if(cle == 'K') interet[2]+= 1.0; if(cle == 'u') vup[0]-= 1.0; if(cle == 'U') vup[0]+= 1.0; if(cle == 'v') vup[1]-= 1.0; if(cle == 'V') vup[1]+= 1.0; if(cle == 'w') vup[2]-= 1.0; if(cle == 'W') vup[2]+= 1.0; affichage(); }

Définition du volume de visualisation Le volume de visualisation détermine la manière dont un objet est projeté à l’écran et définit les objets ou les parties d’objets qui seront découpés. Il s’agit de calculer la matrice de projection GL_PROJECTION. Nous avons 2 fonctions en OpenGL pour définir une vision en perspective : (i)           glMatrixMode(GL_PROJECTION); glLoadIdentity(); glFrustum(gauche, droite, bas, haut, proche, eloigne); Les 2 plans de découpage sont parallèles. Les distances proche et eloigne doivent être positives; elles représentent la distance du centre de projection à ces plans.

Projections en perspective dans OpenGL (ii)  Dans plusieurs applications, il est plus naturel d’exiger l’angle de vue. La fonction OpenGL gluPerspective(angle_de_vuey, largeur_sur_hauteur, zmin, zmax) où angle_de_vuey : désigne l’angle du champ de vision dans le plan yz entre 0.0 et 180.0, largeur_sur_hauteur désigne le rapport largeur / hauteur de la région considérée du plan de vue, zmin et zmax : représentent la distance entre le centre de projection et les 2 plans de découpage, le long de l’axe des z négatif. Ces distances doivent toujours être positives. y largeur angle de vuey hauteur x z

Projections en parallèle dans OpenGL La seule fonction disponible dans OpenGL est celle qui permet la projection parallèle orthographique : glOrtho(xmin, xmax, ymin, ymax, zmin, zmax); ces paramètres sont les mêmes que ceux de glFrustum et sont de type GLdouble. Volume de vue (xmax, ymax, zmax) (xmin, ymin, zmin) Si elle n’est pas associée à d’autres transformations, la direction de projection est | | à l’axe des z et le point de vue pointe vers l’axe des z négatif.