OpenGL avec Delphi

Une primitive est une forme géométrique simple, par exemple un carré, un triangle, un rectangle… C'est à l'aide de ceux-ci que nous serons en mesure de construire plusieurs formes géométriques épatantes. Ne perdons pas de temps et allons étudier quelques commandes de base.

Comme à l'habitude voici du code, celui-ci sera écrit dans la procédure OnPaint() de votre contrôle fenêtré.

glClear(GL_COLOR_BUFFER_BIT);
glClearColor(0.0, 0.0, 0.0, 0.0);

glMatrixMode(GL_MODELVIEW);
glLoadIdentity;

gluLookAt( 0.0, 0.0, 7.0,
           0.0, 0.0, 0.0,
           0.0, 1.0, 0.0 );

glBegin( GL_TRIANGLES );
       glColor3f( 1.0, 1.0, 1.0 ); 
            glVertex2d( 2.0, -2.0 );
       glColor3f( 0.5, 0.5, 0.0 ); 
            glVertex2d( -2.0, -2.0 );
       glColor3f( 0.0, 0.5, 0.5 );
            glVertex2d( 0.0, 2.0 );
glEnd();

glFlush();

Voilà des nouvelles commandes OpenGL que je ne vous ai pas expliquées, mais qui étaient présentes dans le premier tutoriel :

• glClear(GL_COLOR_BUFFER_BIT); : ici on vide le tampon de pixels où les valeurs chromatiques (couleurs) sont logées. La couleur de vidage sera spécifiée à l'aide de la commande suivante glClearColor(..) ;
• glClearColor(0.0, 0.0, 0.0, 0.0); : voilà la couleur de vidage. Elle se présente sous format RGBA donc (Rouge, Vert, Bleu, Alpha). Alpha est un taux de luminosité, mais nous en reparlerons plus tard ;
• glMatrixMode( GL_MODELVIEW ); / glLoadIdentity(); : aa commande glMatrixMode spécifie la matrice active, trois paramètres sont possibles (GL_MODELVIEW, GL_PROJECTION, GL_TEXTURE. Ici la matrice de modélisation-visualisation a été choisie parce que nous nous préparons à construire nos primitives. Donc les appels de transformations successives affecteront la matrice de modélisation-visualisation. Et c'est aussi le temps maintenant d'effectuer sur nos primitives des rotations, des déplacements et des redimensions. La commande glLoadIndentity(); vide la matrice active afin de prévoir les commandes de transformations suivantes ;

• gluLookAt( 0.0, 0.0, 7.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0 ); : cette commande provient de la bibliothèque GLU, elle permet de placer le spectateur en fonction de la scène à visualiser. Les trois premiers paramètres spécifient où est placée la caméra dans un univers 3D donc X, Y et Z. Les trois autres paramètres spécifient où la caméra regarde ou plutôt quel point elle fixe. Et les trois derniers paramètres spécifient la direction du vecteur. Comme nous n'avons pas nécessairement de déplacement complexe dans ce petit programme, alors il aurait suffi d'utiliser la commande suivante glTranslated( 0.0, 0.0, -10 ). Cette commande aurait placé la caméra à -10 unités derrière la scène alors juste parfait pour visualiser le triangle de face. Pour ce qui est des transformations, il existe trois belles commandes que voici :

  • glTranslate( X, Y, Z ) : spécifie un déplacement dans la scène ;
  • glScale( X, Y, Z ) : spécifie un changement d'échelle dans la scène ;
  • glRotate( X, Y, Z ) : spécifie une rotation dans la scène.

  N'oubliez jamais de spécifier la position de votre vue avant de dessiner la scène, car sinon vous serez à l'origine de la scène et vous ne verrez rien.

• glBegin( GL_TRIANGLES ); / glEnd() : la commande glBegin( type ) débute une liste de sommets décrivant une primitive géométrique. Comme vous le constaterez, nous allons construire un triangle. le paramètre type peut prendre les différentes valeurs que voici :

  Différents types pour la commande glBegin()
  Valeur	Signification
  GL_POINTS	Points isolés.
  GL_LINES	Paires de sommets interprétées en tant que segments de ligne isolés.
  GL_LINES_STRIP	Séries de segments de ligne joints.
  GL_LINE_LOOP	Même chose, mais ajout d'un segment entre le dernier et le premier sommet.
  GL_TRIANGLES	Regroupe par trois les sommets interprétés comme des triangles.
  GL_TRIANGLE_STRIP	Bande liée de triangles.
  GL_TRIANGLE_FAN	Éventail lié de triangles.
  GL_QUADS	Regroupe par quatre les sommets interprétés comme des polygones à quatre côtés.
  GL_QUAD_STRIP	Bande liée de quadrilatères.
  GL_POLYGON	Contour externe d'un polygone convexe simple.

• glColor3f( 1.0, 1.0, 1.0 ); : spécifie la couleur des sommets. Remarquez ici la dernière lettre de cette commande, f et le nombre 3 si vous vous référez au tableau (début du premier tutoriel) vous remarquerez que la couleur est donnée sous format (Rouge, Vert, Bleu) et le type de données pour les couleurs sera float (entre 0.0 et 1.0). Tant et aussi longtemps qu'il n'y aura pas une nouvelle commande de sélection de couleur, les sommets seront tous blancs (1.0, 1.0, 1.0). Il est préférable de toujours spécifier la couleur des sommets avant leur création.

• glVertex2d( 2.0, -2.0 ); : encore une fois regarder le nombre 2 et la dernière lettre de la fonction d. Celle-ci dessine positionne un sommet à l'endroit voulu. Ici l'endroit est spécifié par glVertex2d( X, Y ). Ce sommet aura la couleur spécifiée par la commande glColor*.

• glFlush(); : exécution des commandes d'OpenGL. Donc toutes les commandes qui ont été envoyées à OpenGL seront exécutées après cette commande.

Un exemple de code définissant le champ de vision en fonction de la dimension du contrôle fenêtré (la fenêtre).

glViewport(0, 0, ClientWidth, ClientHeight );
glMatrixMode( GL_PROJECTION );
glLoadIdentity;

gluPerspective( 45, Width / Height, 0.1, 10.0 );
glMatrixMode( GL_MODELVIEW );
Invalidate;

• glViewport(0, 0, TGLsizei(ClientWidth), TGLsizei(ClientHeight)); : spécifie l'espace disponible sur le composant où OpenGL dessine. Les deux paramètres suivants spécifient les coordonnées de la fenêtre située en haut à gauche donc (0, 0). Les deux derniers paramètres spécifient la grandeur de la fenêtre donc en bas à droite (largeur, hauteur). Cette commande est appelée ici parce que si la dimension de la fenêtre change alors OpenGL se résignera à dessiner sa future scène dans cet enclos défini.
• glMatrixMode( GL_PROJECTION ); / glLoadIdentity(); : active la matrice de projection, car nous allons définir un champ de vision à la ligne suivante. La commande glLoadIdentity() sert à initialiser la matrice de projection, car c'est elle qui est active maintenant.

• gluPerspective( 45, Width / Height, 0.0, 10.0 ); : crée une nouvelle matrice de projection permettant de créer un champ de vision pour notre scène. Quatre paramètres sont nécessaires :

  • Angles de vue : spécifie l'angle du champ de vue, ici nous lui attribuons un angle de 45º. Sa valeur doit être comprise entre 0 et 180º ;
  • Ratio : représente l'aspect du ratio, donc la largeur divisée par la hauteur. Si par exemple nous lui avions spécifié un ratio de 0.5 qui est égal à ½, donc la largeur serait 2 fois moins dense ;
  • Proche : la distance la plus proche du champ de vision, en profondeur, est (0.0) alors on ne peut être plus dans l'action que cela !;
  • Loin : la distance la plus éloignée donc 10.0. Si nous dessinons une primitive à 11.0 de profondeur et plus, il nous serait impossible de l'apercevoir, car elle ne ferait pas partie de notre champ de vision défini.

  Il existe d'autres types de perspective comme glFrustum, glOrtho. À vous de les découvrir…

• Invalidate; : si l'on jette un petit coup d'œil dans l'aide en ligne de Delphi, on comprendra vite que cette commande sert à obliger le rafraîchissement d'un contrôle fenêtré. Par conséquent s'il est rafraîchi il est aussi repeint OnPaint().

Ah! le fameux triangle d'OpenGL. Je ne peux vous dire mieux que : « Essayez de dessiner d'autres formes géométriques… » Source

Pour ceux que cela intéresse, voici l'autre manière. Source (à la C++)