Les extensions OpenGL

Les extensions dans OpenGL permettent d'ajouter des fonctionnalités sans modifier le cœur d'OpenGL (norme donnée par Khronos). Les extensions sont produites par les entreprises enregistrées dans le groupe Khronos telles que Nvidia, ATI, Apple et bien d'autres. Bien souvent, une fois que l'extension est reconnue comme essentielle, elle est intégrée dans le cœur d'OpenGL et la version d'OpenGL change. La liste des extensions pour OpenGL peut être trouvée en bas de cette page : http://www.opengl.org/registry/. Il faut savoir qu'aucun constructeur n'est tenu d'inclure des extensions dans ses cartes graphiques. En effet pour être conforme à la norme OpenGL, il suffit de correctement implémenter le cœur d'OpenGL. Cela signifie que rien ne vous certifie que vous aurez une extension dans la machine exécutant votre programme.

Principalement pour expliquer précisément ce que sont les extensions et pour savoir les utiliser dans tous les cas, avec ou sans bibliothèques externes.

Il vous sera utile de savoir comment créer un projet OpenGL ainsi que d'ouvrir une fenêtre OpenGL. Vous pouvez trouver des tutoriels sur ce point en suivant les liens suivants :

• WinAPI : https://nehe.developpez.com/tutoriel/01-introduction/ ;
• SDL : https://tbayart.developpez.com/articles/opengl/fenetrage/sdl/ ;
• Glut : https://jeux.developpez.com/tutoriels/cours-opengl/.

Comme je l'ai dit un peu avant, différentes sociétés développent leurs extensions. Il existe une norme de nommage pour les extensions qui permet de connaître la bibliothèque intégrant l'extension, le nom de la compagnie à l'origine de l'extension et, finalement, le nom de l'extension.

Le nom de l'extension est constitué comme suit :

• GL_ID-DEVELOPPEUR_nom-de-l'extension ;
• GLX_ID-DEVELOPPEUR_nom-de-l'extension ;
• WGL_ID-DEVELOPPEUR_nom-de-l'extension.

GL / GLX et WGL désignent la bibliothèque sur laquelle l'extension agit. Nous ne nous intéressons qu'aux extensions OpenGL (donc GL), mais le principe est exactement le même pour les autres.

ID-DEVELOPPEUR est le nom de la compagnie qui a créé la norme de l'extension. On peut entre autres voir les noms suivants :

• ARB pour Architecture Review Board (qui correspond au Comité d'évaluation de l'architecture d'OpenGL. C'est le groupe qui valide les spécifications d'OpenGL) ;
• EXT pour les extensions mises au point par un groupe de compagnies, sans particularité quelconque ;
• NV pour Nvidia ;
• ATI pour ATI, maintenant appelé AMD ;
• SGI pour Silicon Graphic International (la société à l'origine d'OpenGL).

Et j'en passe.

Et à la fin, le nom de l'extension, qui se doit d'être clair.

Voici quelques exemples tirés de cette page :

• GL_ARB_half_float_pixel ;
• GL_ARB_vertex_shader ;
• GL_NV_texture_shader2 ;
• GL_EXT_vertex_array_bgra.

Comme il a été dit, les constructeurs présentent leurs extensions. Celles-ci ne sont pas réservées à la compagnie à l'origine de l'extension et peuvent être implémentées par toutes autres compagnies. Une fois qu'une extension est présentée par une compagnie (ou un ensemble de compagnies), elle va être revue par l'ARB. Lorsque l'extension sera validée par l'ARB elle changera de nom pour prendre les lettres ARB, à la place des lettres désignant le constructeur. Il y a de très fortes chances que les extensions ayant obtenu cette ratification soient implémentées sur toutes les cartes sorties après le jour de cette ratification. Une fois qu'une extension a atteint ce stade, il est probable de voir cette extension dans la prochaine version d'OpenGL en intégrant le cœur d'OpenGL (et qu'elle soit donc incluse d'office sur toutes les cartes compatibles avec cette version d'OpenGL).

Comme il est dit en introduction, chaque machine embarque son lot d'extensions, et une extension présente dans une machine peut ne pas l'être dans une autre. C'est pourquoi il est important de savoir récupérer la liste des extensions présentes dans la machine, sinon votre programme va vouloir exécuter des morceaux de code qu'il n'y a pas (ça va crasher !).

Pour ce faire, nous utilisons la commande glGetString() avec comme paramètre 'GL_EXTENSIONS'.

void displayExtensions(void)
{
    printf("%s\n",glGetString(GL_EXTENSIONS));
}

Bien sûr, on pourrait améliorer l'affichage de la liste des extensions (en remplaçant les espaces par des sauts de ligne par exemple, mais cela ne nous est pas utile pour la suite du tutoriel).

Maintenant, il faut faire en sorte que notre programme sache si les extensions dont nous avons besoin sont présentes. Si elles ne le sont pas, le programmeur pourra soit arrêter le programme avec un message d'erreur, soit passer outre et faire en sorte de ne pas utiliser toutes les fonctionnalités du programme.

Pour cela nous allons analyser la chaine de caractères retournée par glGetString(GL_EXTENSIONS).

char hasExtension(const char* extensionName)
{
/*
    Le cast est nécessaire à cause du type de pointeur retourné
    ( GLubyte* correspondant à un const unsigned char* )
*/
    const char* extensionsList = (const char*)glGetString(GL_EXTENSIONS);
    char* extensionMatch = NULL;

    while ( (extensionMatch = strstr(extensionsList, extensionName)) != NULL )
    {
        // Vérification: avons-nous la même chaine que l'extension voulue ?
        if ( strncmp(extensionMatch,extensionName,strlen(extensionName)) == 0 )
        {
            // Vérification: le nom trouvé se termine-t-il bien ici ?
            if ( extensionMatch[strlen(extensionName)] == ' ')
            {
                return 1;
            }
        }

        // On déplace le pointeur de recherche après la chaine trouvée pour continuer la recherche
        extensionsList = extensionMatch + strlen(extensionMatch);
    }

    return 0;
}

L'utilisation est la suivante :

printf("Est-ce que j'ai les Geometry Shader 4 : ? -> ");
if ( hasExtension("GL_ARB_geometry_shader4") )
{
    printf("OUI\n");
}
else
{
    printf("NON\n");
}

Lorsque nous voulons utiliser les fonctions d'une extension, la seule chose que nous connaissons, c'est son prototype, écrit dans le fichier d'en-têtes des extensions d'OpenGL.

En fait, le programme ne connaît pas encore les adresses des fonctions des extensions, car comme je vous l'ai dit, ces extensions peuvent être présentes, ou pas. De ce fait, nous allons devoir récupérer l'adresse de la fonction nous-même.

Pour ce faire, les bibliothèques qui se chargent de l'ouverture de la fenêtre OpenGL nous proposent une fonction ayant ce but. Son nom est *GetProcAddress (je mets une étoile avant le nom de la fonction, car il y a généralement des lettres avant GetProcAddress() selon la bibliothèque que vous utilisez).

La fonction va retourner un pointeur sur une fonction, qu'il faudra caster pour que ce soit un pointeur sur le prototype de la fonction réelle (comme indiqué dans la documentation ou dans le fichier d'en-têtes). Si vous ne faites pas ce cast, le compilateur n'acceptera pas que vous passiez des paramètres à une fonction qui pour lui, ne prend pas de paramètres. Dans le cas contraire (utilisation de la fonction sans avoir fait le cast, sans paramètres alors qu'elle est censée en avoir) un bogue se produira.

Finalement, si la fonction voulue n'est pas trouvée, *GetProcAddress() retournera un pointeur NULL.

Prenons la fonction ayant le prototype suivant (pris du glext.h) :

GLAPI void APIENTRY glFramebufferTextureFaceARB (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);

avec un peu plus bas dans le fichier :

typedef void (APIENTRYP PFNGLFRAMEBUFFERTEXTUREFACEARBPROC) (GLenum target, GLenum attachment, GLuint texture, GLint level, GLenum face);

Le premier prototype n'est inclus que si GL_GLEXT_PROTOTYPES est défini. Mais cela ne peut marcher que si la fonction est obligatoirement dans le code du pilote de la carte graphique. Sinon, cela ne compile pas (erreur de liaison, le code de la fonction n'est pas trouvé).

Pour que la fonction soit opérationnelle, nous définissons le pointeur comme suit :

PFNGLFRAMEBUFFERTEXTUREFACEARBPROC glFramebufferTextureFaceARB_Fct;

Et afin de récupérer le pointeur :

glFramebufferTextureFaceARB_Fct = (PFNGLFRAMEBUFFERTEXTUREFACEARBPROC)glutGetProcAddress("glFramebufferTextureFaceARB");

Une fois que cela est fait, la fonction peut être utilisée comme toute autre :

glFramebufferTextureFaceARB_Fct(param1,param2,param3,param4,param5);

Malheureusement, Microsoft Windows n'a jamais été distribué avec une version d'OpenGL supérieure à la version 1.1. Cela veut dire que pour avoir, par exemple, les shaders (inclus dans le cœur de la version 2.0) nous allons devoir récupérer les adresses des fonctions comme si elles étaient encore des extensions.

Du coup, il est aussi important de vérifier la version d'OpenGL que vous utilisez (avec glGetString(GL_VERSION))

GLEW est une bibliothèque qui permet une gestion simplifiée des extensions. La bibliothèque fait elle-même tout le processus que j'ai expliqué auparavant.

Après la création de la fenêtre, GLEW doit être initialisé afin que la bibliothèque puisse assigner et définir les pointeurs sur les extensions ainsi que d'autres variables permettant de connaître facilement la version d'OpenGL présente.

GLenum err = glewInit();
if (GLEW_OK != err)
{
  /* Problème : glewInit a échoué, quelque chose va sérieusement mal */
  fprintf(stderr, "Erreur : %s\n", glewGetErrorString(err));
  ...
}

Il reste toujours à vérifier si les extensions voulues sont présentes :

depuis la version 1.1.0 de GLEW vous pouvez savoir si une extension est présente grâce aux variables ayant la forme GLEW_{nom_de_l_extension}.

if (GLEW_ARB_vertex_program)
{
  /* C'est bon, vous pouvez utiliser l'extension ARB_vertex_program. */
  glGenProgramsARB(...);
}

Pour plus d'informations sur les possibilités de la bibliothèque, je vous invite à voir ce lien : http://glew.sourceforge.net/basic.html (en anglais).

GLEE est une bibliothèque qui a le même rôle que GLEW. À vrai dire, GLEE existait avant l'apparition de GLEW, mais n'intègre pas les dernières extensions et fonctionnalités d'OpenGL.

L'utilisation de GLEE est simple. Il suffit d'inclure le fichier d'en-têtes de la bibliothèque et de vérifier si l'extension est présente :

if (GLEE_ARB_multitexture)    // Est-ce que le support des multitexture est présent
{
  glMultiTexCoord2fARB(...);  // Aucun risque d'utiliser la fonction.
}
else
{
   // Retour d'erreur
}