OpenGL
OpenGL () est un ensemble normalisé de fonctions de calcul d'images 2D ou 3D lancé par Silicon Graphics en 1992. Cette interface de programmation est disponible sur de nombreuses plateformes où elle est utilisée pour des applications qui vont du jeu vidéo jusqu'à la CAO en passant par la modélisation.

OpenGL permet à un programme de déclarer la géométrie d'objets sous forme de points, de vecteurs, de polygones, de bitmaps et de textures. OpenGL effectue ensuite des calculs de projection en vue de déterminer l'image à l'écran, en tenant compte de la distance, de l'orientation, des ombres, de la transparence et du cadrage.

L'interface regroupe environ  différentes qui peuvent être utilisées pour afficher des scènes tridimensionnelles complexes à partir de simples primitives géométriques. Du fait de son ouverture, de sa souplesse d'utilisation et de sa disponibilité sur toutes les plates-formes, elle est utilisée par la majorité des applications scientifiques, industrielles ou artistiques 3D et certaines applications 2D vectorielles. Cette bibliothèque est également utilisée dans l'industrie du jeu vidéo où elle est souvent en rivalité avec la bibliothèque de Microsoft : Direct3D. Une version nommée OpenGL ES a été conçue spécifiquement pour les applications embarquées (téléphones portables, agenda de poche, consoles de jeux…).

Histoire 
OpenGL est une évolution d'IrisGL, API 3D développée par Silicon Graphics (SGI). Cette dernière étant difficile à faire évoluer et à étendre, il a été décidé chez Silicon Graphics qu'OpenGL pouvait être assimilé à un sur-ensemble d'IrisGL.
Les spécifications et développements de base ont été réalisés par une équipe de Silicon Graphics. Le projet Fahrenheit, initiative de Microsoft et de Silicon Graphics, tenta d'unifier les interfaces OpenGL et Direct3D. Celui-ci apporta au début l'espoir de mettre de l'ordre dans le monde des API 3D, mais pour des contraintes financières de la part de Silicon Graphics, le projet dut être abandonné.

La spécification OpenGL est actuellement surveillée par l'Architecture Review Board (ARB), formé en 1992. L'ARB se compose d'entreprises ayant un profond intérêt pour la création d'une API cohérente et largement disponible. Selon le site officiel d'OpenGL, AMD/ATI, Apple, Dell, Evans & Sutherland, Hewlett-Packard, IBM, Intel, Matrox, Nvidia, SGI et Sun font partie des membres votants (juin 2002). Microsoft, l'un des membres fondateurs, s'est retiré en .

OpenGL 1.5 
Le  est annoncé OpenGL 1.5. Au même moment, ARB annonce les spécifications d'une première ébauche de l'OpenGL Shading Language ainsi que les trois extensions ARB_shader_objects, ARB_vertex_shader et ARB_fragment_shader.

OpenGL 2.0 
Le  est annoncé OpenGL 2.0. l'OpenGL Shading Language (GLSL, également surnommé GLslang) à la syntaxe proche du langage C y est intégré dans une version définitive.

OpenGL ES 

Le  lors de la conférence de la Siggraph, l'ARB a annoncé sa décision de transférer le contrôle de la spécification OpenGL au Khronos Group, qui s'occupait déjà de différentes spécifications OpenGL pour les systèmes embarqués et les consoles de jeux vidéo dont OpenGL ES. L'Architecture Review Board a été dissoute le , mais pour des raisons historiques, l'acronyme « ARB » a été conservé.

OpenGL 3.0 
Les spécifications officielles de OpenGL 3.0 ont été présentées le 11 août 2008. À l'origine, OpenGL 3 devait constituer un changement majeur, avec une refonte totale de l'API pour la rendre plus concurrentielle face à Direct3D. Il était notamment question d'abandonner les fonctionnalités obsolètes qui n'étaient, jusque-là, conservées que par souci de compatibilité avec les anciennes versions, l'utilisation d'un nouveau modèle objet plus cohérent qui encapsule notamment les états, etc. Cependant, après un an de retard et une absence totale de communication de la part du groupe Khronos, cette refonte totale a été abandonnée au profit d'une mise à jour incrémentale permettant simplement de prendre en charge les dernières technologies graphiques. Cette décision serait due à la volonté de rassurer certains marchés, par exemple en CAO, qui ne souhaitaient pas voir disparaître ces anciennes fonctionnalités. Malgré tout, les fonctions obsolètes seront marquées « deprecated » dans les nouvelles spécifications, et pourraient être supprimées dans les versions futures.

OpenGL 3.1 
Les spécifications d'OpenGL 3.1 ont été publiées le 28 mai 2009. Il supprime toutes les fonctionnalités qui étaient déclarées obsolètes dans OpenGL 3.0.

OpenGL 3.2 
Les spécifications d'OpenGL 3.2 ont été publiées le 3 août 2009. Les spécifications sont divisées, en 2 ; profil principal () et profil compatible ().

Sa sortie est accompagnée de la sortie des spécifications du langage de shaders GLSL 1.50.

OpenGL 3.3 
Les spécifications d'OpenGL 3.3 ont été publiées le 11 mars 2010, ce sont les dernières spécifications de la série 3.3. Comme pour OpenGL 3.2, il y a un profile principal et un profil compatible.

Cette version est souvent utilisée comme version charnière à atteindre avant un portage d'un logiciel d'OpenGL à Vulkan.

OpenGL 4.0 
Le , OpenGL 4.0 est annoncé, il a pour but d'exploiter pleinement le matériel compatible avec DirectX 11.

Au même moment OpenGL 3.3 est également annoncé.

Vulkan 

Au début annoncé sous l’appellation , Vulkan revoit d'importants concepts d'OpenGL afin de s'adapter aux 25 ans d'évolution des processeurs graphiques 3D depuis la première version. La compatibilité avec les anciennes versions n'est plus assurée.

Les changements les plus notables sont :
 OpenGL et OpenGL ES sont unifiés ;
 Les pilotes sont simplifiés, le processeur contrôle lui-même directement le GPU et la mémoire utilisée par celui-ci.

Extensions 
La norme OpenGL permet à différents fabricants d'ajouter de nouvelles fonctionnalités sous forme d'extensions. Une extension est distribuée en 2 parties : un fichier d'en-têtes qui contient les fonctions prototypes de l'extension et les drivers du fabricant. Chacun d'eux possède une abréviation qui est utilisée pour nommer leurs nouvelles fonctions et constantes. Par exemple, l'abréviation de nVidia (« NV ») est utilisée pour définir leur fonction propriétaire « glCombinerParameterfvNV() » et leur constante « GL_NORMAL_MAP_NV ». Il peut arriver que plus d'un fabricant implémente la même fonctionnalité. Dans ce cas, l'abréviation « EXT » est utilisée. Il peut également arriver que l'ARB officialise une extension. Celle-ci devient alors un standard et l'abréviation « ARB » est utilisée. La première extension ARB fut GL_ARB_multitexture.

Bibliothèques 
Plusieurs bibliothèques sont développées à partir d'OpenGL afin d'apporter des fonctionnalités qui ne sont pas disponibles dans la bibliothèque OpenGL elle-même :
 GLU ;
 GLUT  (GL Utility Toolkit : combine l'accès à des fenêtres graphiques OpenGL et, de façon unifiée, aux interfaces utilisateur du système d'exploitation, quel que soit celui-ci);
 GLUI ;
 GLEW ;
 GLEE ;
 GLFW ;
 GLM.
On notera en particulier la bibliothèque OpenGL Performer, développée par  et disponible pour IRIX, Linux et quelques versions de Windows, qui permet la création d'applications de rendus temps réel.

Exemple simple de programme OpenGL 
Voici un programme simple, en 2D, dessinant un triangle et permettant de modifier instantanément sa couleur en pressant l'une des touches r, g, b et celle du fond avec R, G, B. La touche q quitte le programme. Celui-ci, qui utilise GLUT pour simplifier la programmation (penser à l'installer par Synaptic ou autre), est compilé et exécuté, sous Linux ou WSL sous Windows 10, parcc colorswap.c -lglut -lGL -lGLU && ./a.out. Les bibliothèques OpenGL sont à installer depuis les dépôts de votre distribution particulière. L'objectif du code est ici la lisibilité et non la performance.

/*
 * colorswap.c - Options -lglut -lGL -lGLU :
 * cc colorswap.c -lglut -lGL -lGLU && ./a.out
 * 
 * Donnez le focus à la fenêtre, puis pressez :
 * R G B ou Y pour couleur du fond
 * r g b ou y pour celle de l'encre
 * q pour quitter.
 * 
 * Programme écrit sous OpenSuSE avec Geany sous
 * Sony Satellite G50 bootant Linux d'un SSD USB3
 * en inhibant le secure boot et en donnant la 
 * priorité de boot à l'USB.  
 */

#include <GL/glut.h>

int firstPass = 1; // simule le « once » d'Eiffel

// Fonction associée (« callback ») à la fenêtre.
// Elle redessine tout quand on redimensionne.
void Rafraichir(void)	
{
  glClear(GL_COLOR_BUFFER_BIT);	// Effacer la surface graphique

  if (firstPass) {
    glColor3f(0, 0, 1.0);  // Encre bleue au départ
    firstPass = 0;
  }

  // Dessiner un triangle
  glBegin(GL_POLYGON); 	// Commencer un polygone
  glVertex2i(100, 100); // Coordonnées des trois points
  glVertex2i(400, 100);
  glVertex2i(250, 400);
  glEnd(); 				// Fermer le polygone
  glFlush(); 			// Dessiner le polygone
}

// Action sur frappe d'une touche au clavier
void Clavier(unsigned char key, int x, int y)
{
  switch(key) { 
    case 'q' : exit(0); // q => « quitter »
  
    case 'R' : glClearColor(1, 0, 0, 0); break; 	// R G B : couleur fond
    case 'G' : glClearColor(0, 1, 0, 0); break;
    case 'B' : glClearColor(0, 0, 1, 0); break;
    case 'Y' : glClearColor(1, 1, 0, 0); break; 	// Y : jaune
  
    case 'r' : glColor3f(1, 0, 0); break; 	// r g b : couleur encre
    case 'g' : glColor3f(0, 1, 0); break;
    case 'b' : glColor3f(0, 0, 1); break;
    case 'y' : glColor3f(1, 1, 0); break; 	// y ; jaune
  }

  Rafraichir();	// Affichage
}

int main(int argc, char *argv[])
{
  int win; 					// Identificateur de fenêtre (une seule)
  glutInit(&argc, argv); 			// initialise GLUT
  glutInitDisplayMode(GLUT_RGB); 	// On travaille en RGB
  glutInitWindowSize(500,400);   	// 500px large, 400px haut
  win = glutCreateWindow("Pressez r/g/b/y/R/G/B/Y/q");

  // Ordres maintenant exécutés dans la fenêtre « win »
  glClearColor(0.9, 0.9, 0.2, 0); 	// Jaune
  gluOrtho2D(0,600,0,600);			// On garde ces coordonnées

  glutDisplayFunc(Rafraichir); 		// Callback de la fenêtre
  glutKeyboardFunc(Clavier); 		// Callback du clavier

  glutMainLoop();					// Boucle infinie

  /* Le programme n'atteint jamais ce point */

  return 0;
}

Implémentations 
Plusieurs implémentations d'OpenGL (exploitant l'accélération 3D fournie par le matériel) existent pour Windows, de nombreuses stations Unix et Mac OS. Ces implémentations sont généralement fournies par les constructeurs de matériels graphiques et y sont étroitement liées. Il existe une implémentation libre de cette bibliothèque, nommée Mesa, créée en 1993 par Brian Paul et utilisant la même API, ce qui permettait : 
 de se passer de la licence OpenGL dans la plupart des cas, l'implémentation de SGI étant sous licence, mais l'API elle-même ne pouvant l'être ;
 de faire tourner des applications OpenGL sur des terminaux X de base qui y étaient inaptes (les performances sont alors quelconques faute d'accélération matérielle, mais cela vaut souvent mieux que pas d'exécution du tout et reste acceptable si l'on n'a pas besoin d'animation en temps réel). Ces stations ne disposant pas en général d'accélération 3D matérielle, on ne peut les utiliser que pour des modèles simples comportant relativement peu de polygones : de quelques dizaines à quelques milliers.

Intérêt d'OpenGL pour Silicon Graphics 

 a eu pour politique de mettre à chaque fois dans le domaine public l'avant-dernière version de GL, bibliothèque graphique de GL. Cette approche :
 évitait la concurrence (OpenGL étant gratuit et ouvert, pourquoi le réinventer ?) ;
 dissuadait de modifier OpenGL, car tout ajout serait à recopier dès la version suivante ;
 donnait aux stations  un avantage notable, GL ayant toujours une version d'avance sur OpenGL ;
 constituait une forme de mécénat bon pour le « karma » de la société dans les milieux Open Source

Utilisations 
Certains logiciels utilisent OpenGL pour gérer l'ensemble de leur interface, même 2D, comme Blender, Google Earth (version OpenGL), GLtron, XBMC, ou la version SGI de X11.

Critiques 
Rich Geldreich et Joshua Barczak, sur leur blogs personnels, critiquent OpenGL. Leurs doléances suggérant d'un côté le besoin d'une remise à plat totale à la lumière de l'expérience acquise, de l'autre le besoin de mieux maîtriser la dispersion des portages. Il s'agit cependant d'utilisateurs à haute technicité devant utiliser les fonctions les plus avancées des cartes graphiques de 2014.

Notes et références

Voir aussi

Articles connexes 
 Direct3D
 OpenGL ES
 OpenAL
 Mesa 3D
 OpenCL, de la même fondation
 Liste de bibliothèques 3D

Bibliographie 
 Open GL 2.0 : Guide officiel, Jackie Neider, Mason Woo, Tom Davis, Dave Shreiner, Véronique Campillo, 2006, CampusPress 
  OpenGL Programming Guide: The Official Guide To Learning OpenGL, Version 2, Dave Shreiner, Mason Woo, Jackie Neider, 2005, Addison-Wesley 
  OpenGL Reference Manual: The Official Reference Document to Open Gl, Version 1.4, Dave Shreiner, 2004, Addison-Wesley 
  OpenGL Shading Language, Randi J. Rost, 2005, Addison-Wesley 
 OpenGL Superbible, Richard S., Jr. Wright, Benjamin Lipchak, 2004, Sams 
  Beginning Opengl Game Programming, Dave Astle, Kevin Hawkins, 2004, Course Technology

Spécifications 
  OpenGL & OpenGL Utility Specifications

Liens externes 
 
  Mesa 3D, implémentation libre d'OpenGL

Bibliothèque logicielle graphique
Interface de programmation
3D
Norme ou standard informatique