OpenGL

Paramétrer le rendu de l'application

Objectif

Dans cette partie, nous allons paramétrer le rendu de l'application. Pour cela, nous allons coder les méthodes init() et reshape() de l'objet Cube, qui implémente l'interface GLEventListener. A partir de ces méthodes, nous allons paramétrer les états d'OpenGL et la perspective de la scène de rendu.

Pour pouvoir invoquer les fonctions OpenGL, il nous faut son objet. Sous JOGL, pour récupérer ce dernier depuis le contexte (qui est passé en paramètre), nous faisons appel à l'instruction suivante: GL2 gl = gLDrawable.getGL().getGL2();


init(): Les états

Il existe plusieurs méthodes pour activer, désactiver, et paramétrer un état sous OpenGL :

Bien sûr, il existe d'autres fonctions pour paramétrer notre scène de rendu. Mais cela dépend de nos besoins (plus d'informations dans la partie "Etats").

Pour notre cube, nous aurons besoin d'activer le Z-buffer: Sans ce buffer de profondeur, les formes géométriques (comme les faces de notre cube) sont affichées dans l'ordre de leurs apparitions. Les formes géométriques "s'écrasent" entre elles sur une position X et Y, et ne prend pas en compte la position en profondeur Z (il ne représente qu'une valeur de calcul, pour les opérations matriciels et de vertex).
L'objectif du Z-buffer est d'enregistrer la position en profondeur Z des vertex et de les comparer entre eux, afin de déterminer quel sommet sera affiché en premier plan.



Sans et avec le buffer de profondeur (ou Z-buffer)

Pour activer le Z-buffer : glEnable(GL_DEPTH_TEST)


reshape(): La perspective

Configurer la perspective de la scène est très simple, et se réalise en 3 étapes :

Pour sélectionner une matrice, nous faisons appel à la méthode glMatrixMode(). La matrice de projection est définit par la constante GL_PROJECTION. Il ne faut pas oublier de re-sélectionner la matrice de modèle GL_MODELVIEW (qui sera utilisé pour la rendu des vertex dans la scène) à la fin de la méthode.

Après avoir sélectionné la matrice de projection, il faut la "réinitialiser". La méthode glLoadIdentity() a pour but de remplacer la matrice courante par la matrice d'identité (= la matrice par défaut). Cette méthode sera aussi invoquée au début de chaque rendu, pour la matrice de modèle.

Enfin, il nous reste à définir la perspective de la scène. Pour une perspective en 3D, nous allons utiliser la méthode GLU.gluPerspective() (vu dans la partie "Transformations"). En ajout, il est possible de paramétrer le "point de vue" de la scène, grâce à la méthode gluLookAt(). Cette méthode est surtout utilisé lors de la rendu d'une image et non pour la configuration de la projection, puisqu'elle n'est pas conçu pour modifier la perspective d'une scène.



Le code produit

public void init(GLAutoDrawable gLDrawable) {
GL2 gl = gLDrawable.getGL().getGL2();

// Fonctions pour nettoyer les buffers
gl.glClearColor(0.0f, 0.0f, 0.0f, 0.0f);
gl.glClearDepth(1.0f);

// Activer le Z-buffer
gl.glEnable(GL.GL_DEPTH_TEST);
}


public void reshape(GLAutoDrawable gLDrawable, int x, int y, int width, int height) {
GL2 gl = gLDrawable.getGL().getGL2();
GLU glu = GLU.createGLU(gl);

// Les paramètres
float fovY = 50.0f;
float aspect = (float) width / (float) height;
float zNear = 1f;
float zFar = 1000f;

// La perspective
gl.glMatrixMode(GLMatrixFunc.GL_PROJECTION);
gl.glLoadIdentity();
glu.gluPerspective(fovY, aspect, zNear, zFar);
gl.glMatrixMode(GLMatrixFunc.GL_MODELVIEW);
}

Maintenant, nous allons dessiner un cube de couleurs.