OpenGL intègre un mécanisme d'extension. À travers les extensions, les constructeurs peuvent ajouter des fonctionnalités à OpenGL sans que celles-ci soient encore intégrées dans la spécification. Ainsi, dès le moment où une carte graphique possède une nouvelle fonctionnalité, celle-ci peut être utilisée à travers l'extension appropriée fournie par le constructeur.

Par la suite, lors de la conception de la spécification pour la prochaine version d'OpenGL, les membres du consortium Khronos décideront si oui ou non l'extension et les fonctionnalités apportées par celle-ci seront intégrées dans le cœur d'OpenGL (et donc, devront être disponibles sur tout matériel compatible avec cette version d'OpenGL).

Actuellement, il y a plus de 300 extensions disponibles. La documentation de celles-ci est disponible ici.

Il est possible de demander à OpenGL la liste de toutes les extensions supportées par le matériel, via la fonction glGetString appelée avec l'option GL_EXTENSIONS. La liste retournée est une chaîne de caractères, dans laquelle les extensions sont séparées par un espace.

Pour savoir quelle chaîne correspond à l'extension à tester, il suffit d'aller regarder une page Internet décrivant les spécifications de l'extension concernée ; cela se trouve très facilement.

Voici un exemple en C++, on vérifie si l'extension correspondant aux textures compressées est supportée :

// Récupération de la liste des extensions
std::string Extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));

// Recherche de l'extension qui nous intéresse : GL_ARB_texture_compression
if (Extensions.find("GL_ARB_texture_compression") != std::string::npos)
{
    // Extension trouvée : la fonctionnalité est supportée
}
else
{
    // Extension non trouvée : la fonctionnalité ne pourra pas être utilisée
}

La majorité des extensions ajoutent de nouvelles fonctions à OpenGL. Pour pouvoir les utiliser, il faut d'abord récupérer leur adresse dans la mémoire. OpenGL fournit une fonction pour charger dynamiquement une fonction : wglGetProcAddress sous Windows, et glxGetProcAdress sous Unix. Celle-ci prend en paramètre le nom de la fonction sous forme de chaîne de caractères, et renvoie un pointeur sur la fonction.

Par exemple, pour charger la fonction glBindBufferARB qui sert à activer un VBO :

// Déclaration du pointeur sur la fonction qui nous intéresse
PFNGLBINDBUFFERARBPROC glBindBufferARB;

// Chargement de la fonction
glBindBufferARB = (PFNGLBINDBUFFERARBPROC)wglGetProcAddress("glBindBufferARB");

// Normalement, on a au préalable vérifié que l'extension correspondante était bien supportée,
// mais on vérifie tout de même qu'on a bien récupéré notre fonction
if (glBindBufferARB == NULL)
{
    // Erreur : fonction non chargée
}

// Utilisation
glBindBufferARB(0);

Toutes les définitions de types et de constantes relatives aux extensions se trouvent dans le fichier glext.h, il vaut donc mieux avoir une version à jour si vous souhaitez utiliser des extensions récentes (voir Où puis-je trouver la dernière version de glext.h ?).

Pour faciliter le chargement des extensions et le rendre quasiment transparent, vous pouvez également utiliser GLEW, GLEE, glad, GLXW ou toute autre bibliothèque conçue dans ce but.

Le fichier glext.h contient toutes les informations nécessaires à l'exploitation des extensions OpenGL. Avoir la dernière version de ce fichier est donc impératif lorsque l'on souhaite utiliser les extensions OpenGL dans un programme.

Vous pouvez trouver la dernière version de glext.h sur le site d'OpenGL.

Sous Delphi, l'équivalent GLext.pas pourra être trouvé par exemple dans cette archive. Son utilisation est très simple, puisqu'une seule fonction est nécessaire pour charger les fonctions associées à une extension.

function glext_LoadExtension(ext: String): Boolean;

Passez-lui en paramètre le nom de l'extension, elle vérifiera que l'extension est bien supportée et chargera le cas échéant les fonctions associées.