Préparez votre application pour afficher un cube, tel qu'il est expliqué ci-dessus dans la section V : Préparation de l'environnement de développement VB.

Les Shaders sont apparus avec la version 2.0, ils sont supportés pas les cartes graphiques récentes mais pas par certaines cartes graphiques des PC bureautiques.

Commençons par vérifier que la carte graphique les supporte, en plaçant ce code avant l'appel à InitScene :

' Teste si les Shaders sont supportés
If val(LongToString(glGetString(GL_VERSION))) < 2 Then
    MsgBox "Shaders non supportés", vbOKOnly
    Exit Function 
End If

Bien entendu, Exit Function est à remplacer par Exit Sub si le test est codé dans la procédure Main d'une application VB6.
Si les Shaders ne sont pas supportés, on affiche un message et on quitte la fonction.

Importez maintenant le module ModOpenGL_2_0 qui contient les fonctions de la version 2.0.
N'oubliez pas de "mapper" ensuite les fonctions en exécutant la procédure RemapVBToGL de ce module.

' Initialise les fonctions
ModOpenGL_2_0.RemapVBToGL

Nous voici prêts à programmer les Shaders!

Il y a deux notions à connaître :
- les Shaders.
- et les Programs.

Le principe est assez simple :
1 - on crée un Shader.
2 - on définit son code source en GLSL.
3 - on compile le Shader
4 - on crée un Program.
5 - on attache le Shader au Program.
6 - on génère le Program exécutable (étape de linkage).
7 - on peut utiliser le Program.

On pourra activer ou désactiver un Program au cours du rendu.

La complication en VB est la gestion des chaînes de caractères.
OpenGL utilise des chaînes de caractères multi-octets alors que VB utilise des chaînes Unicode.
Nous utiliserons donc la fonction StrConv pour convertir les chaînes de caractères.
De plus les paramètres sont des pointeurs, que nous obtenons avec la fonction StrPtr ou VarPtr selon les cas.

Il y a trois types de Shaders :
- les Shaders de sommets (Vertex Shaders) qui agissent sur la position des Vertex.
- les Shaders de pixels (Fragement Shaders) qui agissent sur la couleur des pixels de l'image.
- les Shaders de géométrie (Geometry Shaders) apparus avec le Shader Model 4.0 d'OpenGL 3.

Pour débuter, nous allons créer et utiliser un Shader très simple.
Celui-ci modifie la couleur de chaque pixel afin qu'il soit rouge.
Ce programme n'est pas très utile mais a le mérite d'être simple pour un premier exemple.

Voici le code GLSL de ce Shader :

void main(void)
{
gl_FragColor = vec4 ( 1.0 , 0.0 , 0.0 , 1.0 ) ;
}

Il est en effet très simple :
- pour chaque pixel dessiné, la procédure main est appelée.
- gl_FragColor renvoit une couleur fixe (couleur rouge).

Voyons maintenant comment intégrer ce programme dans notre code VB.

Dans la procédure InitScene, générons un Shader.

'Génération du Shader
Dim lShader As Long
lShader = glCreateShader(GL_FRAGMENT_SHADER)

GL_FRAGMENT_SHADER désigne un Shader de pixel, car nous souhaitons agir sur la couleur des pixels.

Ensuite il faut définir le code source du Shader grâce à la fonction glShaderSource.
Nous écrivons ce code dans une variable lShaderString de type String.
Il est également possible d'écrire le code source dans un fichier texte et de le charger en VB.
On peut ainsi écrire des Shaders facilement réutilisables.

' Code source du Shader
Dim lShaderString As String	
lShaderString = "void main(void)" & _
                "{" & _
                "gl_FragColor = vec4 ( 1.0 , 0.0 , 0.0 , 1.0 ) ;" & _
                "}"		

Ce code source doit être converti en multi-octets :

' Conversion
lShaderString = StrConv(lShaderString, vbFromUnicode)

Puis on injecte le code source dans le Shader :

' Injecte le code source dans le Shader
glShaderSource lShader, 1, VarPtr(lShaderString), LenB(lShaderString)

On passe en paramètre le pointeur vers la chaîne de caractères : on obtient ce pointeur grâce à la fonction VarPtr.
Et en dernier paramètre, on précise la taille de la chaîne de caractères : il est important d'utiliser la fonction LenB.

Notez le deuxième paramètre égal à 1 :
Ce paramètre précise le nombre de chaînes de caractères qui sont passées dans le troisième paramètre.
Ici on n'a qu'une seule chaîne de caractères.
Pour préciser plusieurs chaînes, il faut les stocker dans un tableau.
On donne alors :
- en deuxième paramètre le nombre de lignes dans ce tableau.
- en troisième paramètre un pointeur vers le premier élément de ce tableau.
- et en quatrième paramètre un pointeur vers le premier élément d'un tableau contenant les tailles de chaque chaîne de caractères.

Il faut maintenant compiler le Shader :

' Compile le Shader
glCompileShader lShader

Cette compilation est effectuée par la carte graphique.
On peut ensuite lire le statut de la compilation :

' Lecture du status de compilation
Dim lStatus As Long
glGetShaderiv lShader, GL_COMPILE_STATUS, lStatus

Si lStatus contient GL_TRUE, alors la compilation s'est correctement déroulée.
Dans le cas contraire il est possible de lire le journal de compilation :

If lStatus <> GL_TRUE Then
    ' Taille du journal
    glGetShaderiv lShader, GL_INFO_LOG_LENGTH, lSize
    ' Lecture du journal
    lLog = Space(lSize)
    glGetShaderInfoLog lShader, lSize, lSize, StrPtr(lLog)
    ' Ecriture du journal dans la fenêtre de débogage
    Debug.Print StrConv(lLog, vbUnicode)
End If

La lecture de ce journal se fait en deux temps :
1 - il faut d'abord lire la taille du journal.
2 - ensuite on lit le journal en spécifiant sa taille.

La chaîne de caractères qui reçoit le journal doit être d'une taille suffisante, on initialise donc la variable lLog avec autant d'espaces que la taille du journal.
Puis la fonction glGetShaderInfoLog demande un pointeur vers cette variable ; on utilise ici encore la fonction StrPtr.
Finalement, on écrit le journal en prenant soin de convertir la variable au format Unicode.

Pour tester ce journal de compilation, modifiez le code source de manière à générer une erreur.

Par contre si la compilation s'est correctement déroulée, on continue le traitement en générant le programme.

On utilise un identifant de programme déclaré en en-tête de module :

' Identifiant du programme
Private gProgram As Long

Puis on génère le programme à la suite du code précédent :

Else
    ' Génère un identifiant de programme
    gProgram = glCreateProgram
    ' Attache le shader au programme
    glAttachShader gProgram, lShader
    ' Génère le programme exécutable
    glLinkProgram gProgram
    ' Statut du liage
    glGetProgramiv gProgram, GL_LINK_STATUS, lStatus
    If lStatus <> GL_TRUE Then
        ' Taille du journal
        glGetProgramiv lShader, GL_INFO_LOG_LENGTH, lSize
        ' Lecture du journal
        lLog = Space(lSize)
        glGetProgramInfoLog lShader, lSize, lSize, StrPtr(lLog)
        ' Ecriture du journal dans la fenêtre de débogage
        Debug.Print StrConv(lLog, vbUnicode)
    End If
    ' Supprime le shader
    glDeleteShader lShader
End If

glLinkProgram peut également provoquer une erreur : on récupère alors le journal de la même manière que pour la compilation du Shader.

C'est seulement lorsque cette étape de lien s'est correctement déroulée que le Program est utilisable.
On peut alors supprimer le Shader qui n'est plus utile (glDeleteShader).

Il est maintenant très simple d'utiliser le programme.
Il suffit d'appeler la fonction glUseProgram afin de définir l'utilisation du programme.

Avant le dessin du cube, activez le programme :

' Active le programme
glUseProgram gProgram

Et après le dessin du cube, désactivez-le :

' Désactive le programme
glUseProgram 0&

Exécutez l'application : le cube est coloré en rouge.



Cet effet n'est pas spectaculaire, mais en utilisant des shaders plus complexes on peut mettre en oeuvre des effets comme ceux qu'on voit souvent dans les jeux vidéo.

Les Shaders

Access
VB6