Le module ModOpenGL_1_1 contient les déclarations de la version 1.1 d'OpenGL.
Il existe des versions plus récentes d'OpenGL (jusqu'à la version 3.1 à ce jour) et également des extensions.
Nous nous contenterons, pour ce tutoriel de découverte, de la version 1.1 qui permet déjà de réaliser de nombreuses opérations 3D.

Les fonctions des versions supérieures à la version 1.1 sont considérées comme des extensions, nous ne les utiliserons pas au cours de ce tutoriel.

De nombreuses fonctions utilisées dans cet article sont dépréciées dans la version 3 d'OpenGL.
Il est cependant toujours possible de les utiliser, toutes les cartes graphiques n'offrent pas encore à ce jour de driver compatible OpengGL 3.
Vous pouvez consultez les spécifications OpenGL 3 pour une liste des fonctions dépréciées.

Pour l'utilisation des extensions, consultez le tutoriel suivant : Les extensions OpenGL en VBA et VB6

La programmation en OpenGL est basée sur des états.
C'est-à-dire que l'on définit un état (une couleur, une épaisseur de trait, ...), et il est alors utilisé par toutes les opérations de dessin qui suivent.
Par exemple si on définit la couleur rouge, tous les points dessinés ensuite seront de couleur rouge tant qu'on ne fait pas appel à une autre couleur.

Les fonctions et constantes OpengGL commencent par le préfixe gl.
Elles sont déclarées dans le module ModOpenGL_1_1.

Celles de Glu commencent par le préfixe glu.
Les fonctions préfixées par wgl sont spécifiques à Windows.
Ces fonctions sont déclarées dans le module ModOpenGLTools.

Les fonctions et constantes freeglut commencent par le préfixe glut.
Elles sont toutes déclarées dans le module ModOpenGLFreeGlut.

Quelques fonctions gdi32 sont également utiles pour créer une fenêtre et un contexte openGL sans freeglut.
Ces fonctions sont déclarées dans le module ModOpenGLTools.

Le suffixe des procédures est fonction du type de données attendu.

   On peut également trouver un suffixe v qui désigne un paramètre attendu sous forme de tableau.

Par exemple :
- glNormal3d attend 3 paramètres de type Double
- glNormal3i attend 3 paramètres de type Long
- glNormal3iv attend 1 paramètre de type tableau de Long

OpenGL utilise plusieurs Tampons (ou Buffers).
Ces buffers contiennent des informations relatives à la scène que nous dessinons.

VII-E-1. Le tampon de couleurs▲

VII-E-2. Le tampon de profondeur▲

VII-E-3. Le tampon d'accumulation▲

VII-E-4. Le tampon pochoir▲

VII-E-5. Le double tampon▲

L'unité n'est pas le cm, le mètre ou autre...
Tout est relatif, à vous de définir l'unité de votre scène.
Si par exemple vos créez une scène sur laquelle vous souhaitez déplacer un personnage, vous pouvez arbitrairement décider qu'une valeur de 1 correspondra à 1 mètre.
Ainsi se déplacer de 0,5 correspondra à un déplacement de 50 cm.
Pour créer un cube de 2 mètres de côté, vous créerez un cube de 2 de côté.
Toute la scène sera alors à l'échelle.

Il suffit de choisir une unité en fonction de la scène dessinée pour se simplifier les calculs.
Si vous créez un monde à l'échelle d'un insecte, vous prendrez peut-être plutôt 1cm pour une unité openGL.

Un vertice est un point. Vous lirez également souvent le mot anglais vertex.

Les vertices sont la base du dessin en 3D avec OpenGL

Ces vertices sont regroupés en primitives géométriques (point, triangle, rectangle, ...)

Pour dessiner une primitive géométrique, il faut d'abord appeler la fonction glBegin en précisant la primitive souhaitée.

Nom de la primitive	Description	Exemple
GL_POINTS	Points : chaque vertice est traité comme un point indépendant.
GL_LINES	Lignes : chaque paire de vertices forme un segment.
GL_LINE_STRIP	Lignes connectées : chaque vertice (hormis le premier et le dernier) est utilisé deux fois. Les vertices N et N+1 forment un segment.
GL_LINE_LOOP	Lignes connectées en boucle: même chose que GL_LINE_STRIP. De plus le dernier et le premier vertice forment un segment qui referme le polygone.
GL_TRIANGLES	Triangles : chaque triplet de vertices forme un triangle.
GL_TRIANGLE_STRIP	Triangles connectés : - Pour un nombre de vertices pair : un triangle est formé des vertices N, N+1 et N+2. - Pour un nombre de vertices impair : un triangle est formé des vertices N+1, N et N+2.
GL_TRIANGLE_FAN	Triangles connectés : Chaque triangle est formé du vertice 1 et des vertices N+1 et N+2.
GL_QUADS	Rectangles : Chaque groupe de 4 vertices forme un rectangle.
GL_QUAD_STRIP	Rectangles : Chaque paire de vertices (hormis la première paire) forme un rectangle avec la paire de vertice précédente.
GL_POLYGON	Polygone : Chaque vertice définit un point du polygone. Le polygone doit être convexe.

Chaque vertice est défini par ses coordonnées à l'aide d'une fonction glVertex*.

La primitive doit se terminer par un appel à glEnd.

On peut, entre glBegin et glEnd, cumuler plusieurs primitives géométriques de même type.

   Testons l'affichage d'un triangle :

Après le vidage des buffers (glClear) et avant l'échange de buffer (glutSwapBuffers), ajoutons le code de dessin d'un triangle.
Pour bien structurer le programme, nous allons ajouter une procédure Render dans laquelle nous déplaçons le code de vidage des tampons.

Public Sub CallBackDraw()
' Appel de la fonction de rendu
Call Render
' Echange les buffers
glutSwapBuffers
End Sub

Tout le code de dessin est regroupé dans la fonction Render, qui pourra ainsi être appelée de divers endroits du code si besoin.

Public Sub Render()
' Vide les buffers couleur et profondeur
glClear GL_COLOR_BUFFER_BIT Or GL_DEPTH_BUFFER_BIT
' Début de la primitive
glBegin GL_TRIANGLES
    ' Ajoute les trois sommets
    glVertex2d 0, 0
    glVertex2d 1, 0
    glVertex2d 1, 1
' Fin de la primitive
glEnd
End Sub

Exécutez la fonction FonctionOpenGL pour visualiser le triangle.


Vous l'avez sans doute remarqué, nous avons utilisé des coordonnées à deux dimensions pour dessiner notre triangle.
Malgré tout, on a bien un affichage en trois dimensions, le triangle a été placé avec une profondeur de 0 sur l'axe Z.
glVertex2d 1, 1 est équivalent à glVertex3d 1, 1,0.

Le triangle ainsi dessiné est blanc. C'est la couleur par défaut.
On peut affecter une couleur différente à chaque point du triangle.

Il suffit d'appeler une fonction glColor*.

On ne gère pas de transparence, on peut donc utiliser une fonction à 3 paramètres.

Ajoutez juste après l'appel à glBegin la fonction de changement de couleur :

' Début de la primitive
glBegin GL_TRIANGLES
    ' Couleur jaune 
    glColor3d 1, 1, 0
[...]

Un seul appel à la fonction glColor* suffit à colorer tous les vertices.
En fait la couleur jaune reste la couleur de tous les vertices qui seront ensuite dessinés par le programme.
Si on souhaite réinitialiser la couleur, il faut redéfinir la valeur par défaut (couleur blanche) :

    ' Couleur blanche par défaut
    glColor4d 1, 1, 1,1

En VB on utilise souvent un entier long pour définir la couleur, notamment les constantes vbWhite, vbRed, vbGreen, ...

Pour simplifier le choix des couleurs, j'ai ajouté au module ModOpengGLTools les fonctions glColor3VB et glColor4VB.
On peut leur donner en argument une couleur de type entier long.

Utilisons ces fonctions pour affecter à chaque point une couleur différente :

Public Sub Render()
' Vide les buffers couleur et profondeur
glClear GL_COLOR_BUFFER_BIT Or GL_DEPTH_BUFFER_BIT
' Début de la primitive
glBegin GL_TRIANGLES
    ' Ajoute les trois sommets
    glColor3VB vbYellow ' Jaune
    glVertex2d 0, 0
    glColor3VB vbBlue ' Bleu
    glVertex2d 1, 0
    glColor3VB vbRed ' Rouge
    glVertex2d 1, 1
' Fin de la primitive
glEnd
End Sub

Nous remarquons que les couleurs s'appliquent en dégradé :

Chaque polygone a deux faces : une face avant et une face arrière.
Ces faces sont définies par l'ordre des vertices du polygone.
La face avant est, par défaut, celle qui est face à l'observateur lorsque les points sont définis dans le sens inverse des aiguilles d'une montre.

Appelez glFrontFace GL_CW pour inverser l'ordre des faces.
glFrontFace GL_CCW revient au comportement par défaut.

Notre triangle a donc été dessiné avec une face avant vers nous :


Il est possible de masquer certaines faces, c'est ce qu'on appelle le culling.
Masquer les faces arrières des polygones peut accélérer le rendu.
Il faut cependant bien s'assurer que les faces soit créées avec la bonne orientation pour ne pas voir disparaître des polygones qui devraient être visibles.

' D'abord activer le culling
glEnable GL_CULL_FACE
' Puis préciser les faces masquées
glCullFace GL_BACK

Ce code masque la face arrière (qui n'est pas visible sur notre dessin).
Si on utilise glCullFace GL_FRONT, le triangle disparaît.

On peut pour chaque point définir une normale avec une fonction glNormal*.
La normale est généralement définie perpendiculairement à la surface dessinée.
Pour un triangle, la normale est définie perpendiculairement à la face avant, dans la direction allant de la face arrière à la face avant.
Lorsqu'on utilise de la lumière, les normales deviennent importantes car elles déterminent l'éclairage du polygone.

On verra l'importance des normales dans le chapitre sur la lumière.

Nous n'avons défini que des points, OpenGL a dessiné des polygones pleins.
C'est le mode d'affichage par défaut.
Ce mode d'affichage peut être modifié en utilisant la fonction glPolygonMode.
Inutile de redéfinir ce mode d'affichage à chaque fois que l'on dessine la scène, c'est un état qui peut être défini une seule fois à l'initialisation.

Ajoutons une procédure InitScene que nous appelons juste avant le lancement de la boucle glutMainLoop.

[...]
' Appel de la fonction d'initialisation
InitScene
' Boucle principale
glutMainLoop
End Sub

VII-L-1. Affichage des points▲

Public Sub InitScene()
' Mode d'affichage = Points 
glPolygonMode GL_FRONT_AND_BACK, GL_POINT
' Taille des points
glPointSize 10
End Sub

Public Sub InitScene()
' Mode d'affichage = Points 
glPolygonMode GL_FRONT_AND_BACK, GL_POINT
' Taille des points
glPointSize 10
' Lissage des points
glEnable GL_POINT_SMOOTH
End Sub

VII-L-2. Affichage des lignes▲

' Mode d'affichage = Lignes
glPolygonMode GL_FRONT_AND_BACK, GL_LINE
' Taille des lignes
glLineWidth 5

' Mode d'affichage = Lignes
glPolygonMode GL_FRONT_AND_BACK, GL_LINE
' Taille des lignes
glLineWidth 5
' Active les motifs de lignes
glEnable GL_LINE_STIPPLE
' Définit le motif pointillé
glLineStipple 5, 43690

Function BinToDec(pBin As String) As Long
Dim lDec As Long
Dim lCpt As Long
    lDec = 0
    For lCpt = 0 To Len(pBin) - 1
        lDec = lDec + Mid(pBin, Len(pBin) - lCpt, 1) * 2 ^ lCpt
    Next
    BinToDec = lDec
End Function

' Définit le motif pointillé
glLineStipple 5, BinToDec("1010101010101010")

VII-L-3. Remplissage des polygones▲

' Mode d'affichage = remplissage
glPolygonMode GL_FRONT_AND_BACK, GL_FILL