Transformations de visualisation et autres Par Xavier Michelon

Au cours du dernier didacticiel, lorsque nous avons abordé les transformations géométriques, nous avons déplacé et fait tourner des objets. Mais nous n'avons jamais parlé de l'observateur (la position et l'orientation de la caméra virtuelle). Pourtant c'est une question primordiale qui conditionne notre affichage.

Il existe différentes manières d'aborder la question des transformations de visualisation. Je vais vous proposer celle que je trouve la plus pratique, et qui se base sur une observation simple : un déplacement de l'observateur de x unités dans une direction donnée équivaut à un déplacement de tous les objets de la scène de -x unités dans cette direction. De la même manière, faire tourner la caméra de d degrés produit le même résultat qu'une rotation d'angle -d appliquée à tous les objets de la scène. Finalement, on se rend compte que les transformations de visualisation ne sont rien d'autre que des transformations de modélisation.

Par défaut, nous avons vu que la caméra est positionnée en l'origine, qu'elle regarde en direction de l'axe des Z négatifs, et que l'axe Y correspond à la verticale. En combinant rotations et translations, il est possible de faire prendre n'importe quelle position à notre caméra virtuelle. La procédure pour construire une scène 3D est donc la suivante : tout d'abord, construire la scène en faisant abstraction de la position de l'observateur. Une fois la scène construite, positionner l'observateur en appliquant à tous les objets une translation et des rotations. Compte tenu du fait qu'en OpenGL, les opérations se décrivent dans l'ordre inverse de leur application, les transformations de visualisation sont les premières que vous devez spécifier dans votre code.

void display()
{
  glLoadIdentity();
  glTranslated(0,0,-5);
  glTranslated(1,0,0);
  glBegin(GL_POLYGON);
  ..
  glEnd();
}  

Observons la fonction ci-dessus. Avec ce que je viens de vous expliquer, on peut l'interpréter de différentes manières. Si on considère que les deux translations sont des transformations de modélisation, le code ci dessus crée un polygone, lui applique une translation de 1 en X et -5 en Y, et l’observateur se situe en l'origine. Si on considère la première transformation comme une transformation de visualisation, on crée un polygone, on lui applique une translation de 1 suivant X, et on positionne la caméra en (0,0,5). Si on considère que les deux translations sont des transformations de visualisation, on crée un polygone et on positionne la caméra en (-1,0,5).

Nous avons déjà parlé de la bibliothèque GLU d'OpenGL, qui propose un ensemble de fonctions annexes. On parle de fonctions utilitaires car elles ne sont pas fondamentales, mais rendent souvent service en simplifiant la résolution d'un problème donné. Nous allons nous intéresser à gluLookAt(), dont le prototype est le suivant :

void gluLookAt(GLdouble camx,GLdouble camy,GLdouble camz, GLdouble centrex,GLdouble  centrey,
 GLdouble centrez,GLdouble hautx,GLdouble hauty,GLdouble hautz);  

gluLookAt() simplifie la spécification de transformations de visualisation. La caméra en positionnée en (camx,camy,camz), elle est dirigée vers le point (centrex,centrey,centrez), et l'axe (hautx,hauty,hautz) correspond à la verticale de la caméra. gluLookAt() calcule les rotations et translations nécessaires pour positionner la caméra correctement, et multiplie le résultat à droite de la matrice active. Si on réécrit la fonction display() précédente en utilisant gluLookAt() et en supposant que les deux translations sont des transformations de visualisation, on obtient le résultat suivant :

void display()
 {
 glLoadIdentity();
  gluLookAt(-1,0,5,0,0,0,0,1,0);
  glBegin(GL_POLYGON);
  ..
  glEnd();
 }