OpenGL

Dessiner un cube

Objectif

Suite au paramétrage de notre scène de rendu, il nous reste plus qu'à dessiner et à afficher notre cube. Nous allons écrire la méthode display().
OpenGL regroupe de nombreuses fonctionnalités pour manipuler (ou transformer) les formes géométriques et les images. Dans ce tutoriel, nous resterons au plus simple possible, pour afficher notre cube.


Réinitialiser le rendu

Avant chaque rendu, il est obligatoire de vider les buffers et de réinitialiser la matrice de modèle. Pour vider les buffers, nous avons la méthode glClear(). Nous n'utiliserons que le buffer de couleur (GL_COLOR_BUFFER_BIT) et de profondeur (GL_DEPTH_BUFFER_BIT) pour cet exercice. Par ailleurs, nous réutiliserons la méthode glLoadIdentity() pour réinitialiser la matrice.


Les primitives de dessin

Nous connaissons déjà les primitives de bases pour dessiner : les points, les lignes, et les triangles. En OpenGL, il existe d'autres primitives pour dessiner des formes géométriques plus complexes, et faciliter le travail du développeur.



source: http://www.pling.org.uk/cs/cgv.html

Les primitives alternatives Strip, Loop et Fan sont utilisés pour relier les sommets entre eux. Pour des questions de performances, il est conseillé d'utiliser les primitives de bases (points, lignes, et triangles): Les matériels graphiques sont optimisés pour ces primitives.

Dans notre cas, et pour simplifier les choses, nous utiliserons la primitive GL_QUADS pour dessiner les faces d'un cube.


Le mode instantané

La technique la plus simple pour dessiner une forme géométrique est le mode instantané: Nous dessinons "instantanément" les sommets (ou vertex) dans le contexte, sans passer par la mémoire. C'est aussi la technique la moins performante.
En mode instantané, les sommets de l'objet géométrique sont décrites dans un bloc d'instruction, délimité par les méthodes glBegin() et glEnd(). Chacun des sommets (ou des vertex) est dessiné grâce à la méthode glVertex3f().

La fonction glVertex3f() spécifie un vertex (ou un sommet d'une forme), en lui passant 3 paramètres de type Float. Il existe de nombreuses variantes de cette fonction (exemple : glVertex2d()), adaptés à notre utilisation. Pour notre exercice, nous devons spécifier les positions X, Y, et Z d'un sommet, de type flottant.

Pour dessiner une face d'un cube (= un carré), nous devons spécifier 4 vertex. Attention néanmoins: Quelque-soit la primitive utilisée, le système "relie" les vertex 1 à 1, dans leur ordre d'écriture, jusqu'à créer l'objet géométrique désirée.

L'ordre à respecter, depuis la position (0;0) :
glVertex3f(0.0f, 0.0f, 0.0f);
glVertex3f(1.0f, 0.0f, 0.0f);
glVertex3f(1.0f, 1.0f, 0.0f);
glVertex3f(0.0f, 1.0f, 0.0f);

Etant donné qu'un cube est composé de 6 faces, nous devons dessiner 6 carrés. Alors, il faut spécifier 24 vertex.

Il faut savoir que la position (0;0;0) est situé au centre du point de vue de l'utilisateur (par défaut, si nous ne changeons pas ce dernier). Si nous dessinons un cube sur cette position, alors l'utilisateur n'observera pas l'intégralité du cube (il sera à l'intérieur du cube). La solution est de soit modifier le point de vue de l'utilisateur ou déplacer le cube dans la scène.
Nous voulons rester simple: nous "déplaçons" le cube dans la profondeur du champ, grâce à la méthode glTranslatef() (méthode vu dans la partie "Transformations").


Les couleurs

Actuellement, un cube blanc a été dessiné. Il lui manque des couleurs. La fonction glColor3f() a pour objectif de changer la couleur courante, avec les paramètres standards RGB (Rouge, Vert, et Bleu). En flottant, les valeurs vont de 0.0f à 1.0f.

Avec cette fonction, il est possible de définir une couleur pour chaque vertex. Les couleurs sont mélangés automatiquement si deux vertex ou plus sont configurés sur des couleurs différentes.
Nous pouvons changer l'état de la couleur à n'importe quel moment (comme pour un état) et peut être combiné avec la méthode glVertex3f()


Le code produit

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

// Vider buffer et réinitialiser matrix
gl.glClear(GL.GL_COLOR_BUFFER_BIT);
gl.glClear(GL.GL_DEPTH_BUFFER_BIT);
gl.glLoadIdentity();

gl.glTranslatef(0.0f, 0.0f, -7.0f);
int ud = 1;

gl.glBegin(GL2.GL_QUADS);
// Front
gl.glColor3f(0f, 1f, 1f);
gl.glVertex3f(+ud, +ud, +ud); gl.glVertex3f(-ud, +ud, +ud); gl.glVertex3f(-ud, -ud, +ud); gl.glVertex3f(+ud, -ud, +ud);

// Back
gl.glColor3f(0.5f, 1f, 0.5f);
gl.glVertex3f(+ud, +ud, -ud); gl.glVertex3f(-ud, +ud, -ud); gl.glVertex3f(-ud, -ud, -ud); gl.glVertex3f(+ud, -ud, -ud);

// Left & Right
gl.glColor3f(1f, 1f, 0f);
gl.glVertex3f(+ud, +ud, +ud); gl.glVertex3f(+ud, +ud, -ud); gl.glVertex3f(+ud, -ud, -ud); gl.glVertex3f(+ud, -ud, +ud);

gl.glColor3f(1f, 0f, 0f);
gl.glVertex3f(-ud, +ud, +ud); gl.glVertex3f(-ud, +ud, -ud); gl.glVertex3f(-ud, -ud, -ud); gl.glVertex3f(-ud, -ud, +ud);

// Top & Bottom
gl.glColor3f(1f, 0f, 1f);
gl.glVertex3f(-ud, +ud, -ud); gl.glVertex3f(+ud, +ud, -ud); gl.glVertex3f(+ud, +ud, +ud); gl.glVertex3f(-ud, +ud, +ud);

gl.glColor3f(0f, 0f, 1f);
gl.glVertex3f(+ud, -ud, +ud); gl.glVertex3f(-ud, -ud, +ud); gl.glVertex3f(-ud, -ud, -ud); gl.glVertex3f(+ud, -ud, -ud);
gl.glEnd();
}

Nous avons enfin dessiné un cube !
La dernière étape consiste à animer notre cube, pour le mettre en valeur.