OpenGL

OpenGL


Développeur	Silicon Graphics (SGI)
Dernière version	4.5 (11 août 2014) _[+/-]
Écrit en	C
Environnements	Multiplate-forme
Type	API
Site web	OpenGL.org
modifier

Un traitement de pipeline 3D (Graphics Pipeline Process).

OpenGL (Open Graphics Library) est un ensemble normalisé de fonctions de calcul d'images 2D ou 3D lancé par Silicon Graphics en 1992^[1]. 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^[1].

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^[2]^,^[3].

L'interface regroupe environ 250 fonctions 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 mars 2003.

OpenGL 1.5

Le 29 juillet 2003 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 3 extensions ARB_shader_objects, ARB_vertex_shader et ARB_fragment_shader.

OpenGL 2.0

Le 7 septembre 2004 est annoncé OpengGL 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 31 juillet 2006 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 21 septembre 2006, mais pour des raisons historiques, l'acronyme « ARB » a été conservé^[4].

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^[5]. 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 supporter les dernières technologies graphiques^[6]. 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^[7]. 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 4.0

Le 11 mars 2010, 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 OpenGL Next, Vulkan revoit d'importants concept 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 principaux 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 ;
GLUI ;
GLEW ;
GLEE ;
GLFW ;
GLM.

On notera en particulier la bibliothèque OpenGL Performer, développée par Silicon Graphics et disponible pour IRIX, Linux et quelques versions de Windows, qui permet la création d'applications de rendus temps réel.

Exemple 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^[8]. Celui-ci est compilé et exécuté, sous Linux, parcc colorswap.c -lglut -lGL -lGLU && ./a.out. Les bibliothèques OpenGL sont juste à installer depuis les dépôts de votre distribution particulière, ce qui est très simple. L'objectif du code est ici la lisibilité davantage que la performance.

Sortie initiale du programme OpenGL "colorswap.c". Il s'agit d'une simple démonstration montrant les premiers concepts. A ce stade, OpenGL n'est utilisé que comme le GDDM (graphical data display manager) d'IBM : en 2D.

Une pression sur la touche g (pour green) change instantanément la couleur du triangle, montrant la vélocité d'OpenGL et son intérêt même en 2D pour des graphiques interactifs simples.

La pression de R (pour red, majuscule ici pour indiquer que cela concerne le fond) bascule tout aussi instantanément le fond en rouge.

/*
 * colorswap.c -- Compiler avec les options -lglut -lGL -lGLU :
 * cc colorswap.c -lglut -lGL -lGLU && ./a.out
 * 
 * Placer le pointeur dans la fenêtre, puis pressez :
 * R G ou B pour changer la couleur du fond
 * r g ou b pour changer celle de l'encre
 * q pour quitter.
 * 
 * Ce programme a été écrit sous OpenSuSE avec Geany
 * depuis un Sony Satellite G50 qui bootant en Linux sur SSD connecté en USB
 * à condition qu'on inhibe le secure boot et qu'on donne la 
 * priorité de boot à l'USB. 
 * 
 */

#include <GL/glut.h>

int puceau=1;          /* le "once" du langage Eiffel n'existe pas en C */

// Nous avons besoin d'associer une fonction ("callback") à la fenêtre.
// C'est elle qui sera chargée de tout redessiner si nous la redimensionnons

void displayCB(void)	
{

  glClear(GL_COLOR_BUFFER_BIT);		/* Mettre l'écran à "blanc" */
  if (puceau) { glColor3f(0, 0, 1.0);   /* Encre bleue la première fois */
	        puceau=0;}
  
  // Nous définissons maintenant un polygone fermé de trois points :

  glBegin(GL_POLYGON);			// "Je commence un polygone"
  glVertex2i(100,100);		        // Coordonnées des trois points
  glVertex2i(400,100);
  glVertex2i(250,400);
  glEnd();				// "J'ai défini le polygone"
  glFlush();				// "Maintenant, DESSINER le polygone"
}

void keyCB(unsigned char key, int x, int y)	/* action sur caractère pressé */
{
  if( key == 'q' ) exit(0);  			// q => "quitter"
  
  if (key == 'R') glClearColor(1, 0, 0, 0);	// R G et B : couleur du fond
  if (key == 'G') glClearColor(0, 1, 0, 0);
  if (key == 'B') glClearColor(0, 0, 1, 0);
  if (key == 'Y') glClearColor(1, 1, 0, 0);
  
  if (key == 'r') glColor3f(1, 0, 0);		// r g et b : couleur de l'encre
  if (key == 'g') glColor3f(0, 1, 0);
  if (key == 'b') glColor3f(0, 0, 1);
  if (key == 'y') glColor3f(1, 1, 0);          // y pour le jaune

  displayCB();		// On affiche
}


int main(int argc, char *argv[])
{
  int win;	// Identificateur de fenêtre. Mais il n'y en aura ici qu'une.

  glutInit(&argc, argv);		/* initialise GLUT */

  glutInitDisplayMode(GLUT_RGB);	// On travaille en RGB
  glutInitWindowSize(500,400);		// Fenêtre 500px de large 400px de haut

  win = glutCreateWindow("Triangle interactif r/g/b/R/G/B/q");	/* create window */

  // Les ordres sont maintenant exécutés dans la fenêtre "win"

  glClearColor(0.9, 0.9, 0.2, 0); 	// Jaune pisseux
  gluOrtho2D(0,600,0,600);		// On travaillera dans ces coordonnées
  glutDisplayFunc(displayCB);		// Callback associé à la fenêtre
  glutKeyboardFunc(keyCB);		// Callback associé au clavier

  glutMainLoop();			/* Et on part dans la boucle infinie... */

  /* execution never reaches this 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 qui utilise la même API, ce qui permet :

de se passer de la licence OpenGL dans la plupart des cas^[pas clair] ;
de faire tourner des applications OpenGL sur des terminaux X qui y sont en principe inaptes (les performances sont alors médiocres, mais cela vaut parfois mieux que pas d'exécution du tout si l'on n'a pas besoin d'utiliser d'animation en temps réel). Ces stations ne disposant pas en général de fonctions 3D, on ne peut toutefois les utiliser que pour des modèles simples comportant peu de polygones.

Intérêt d'OpenGL pour Silicon Graphics

Cette section ne cite pas suffisamment ses sources. Pour l'améliorer, ajoutez des références vérifiables [Comment faire ?] ou le modèle {{Référence nécessaire}} sur les passages nécessitant une source.

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 marketing :

décourage la concurrence (OpenGL étant gratuit et ouvert, pourquoi développer autre chose ?) ;
dissuade la modification d'OpenGL (car tout ajout serait à recommencer dans la version d'OpenGL suivante) ;
donne aux stations Silicon Graphics un avantage concurrentiel substantiel, puisque GL a toujours une longueur d'avance sur OpenGL ;
constitue une forme de sponsorage (mécénat) améliorant l'image de la société qui met ses travaux anciens dans le domaine public.

Arguments pour et contre OpenGL

Dans la pratique, tout en continuant à assurer un certain support d'OpenGL, les constructeurs et éditeurs de logiciel ont mis d'autres cordes à leur arc, comme Direct3D pour Microsoft (Google Earth permet par exemple un choix entre OpenGL et Direct3D). L'une des raisons était de mieux tirer parti d'innovation matérielles introduites dans les cartes graphiques, comme le nombre de processeurs, leur spécialisation ou non, etc.

En sens inverse a été cependant développé WebGL, qui donne des potentialités 3D à n'importe quel navigateur qui le supporte. OpenGL garde donc l'atout de la généralité, tandis que des solutions plus spécialisées restent préférées pour les applications demandant des calculs graphiques intensifs, comme les jeux.

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^[9]^,^[10]. Leurs doléances suggérant d'un coté 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.

Voir aussi

Bibliographie

Open GL 2.0 : Guide officiel, Jackie Neider, Mason Woo, Tom Davis, Dave Shreiner, Véronique Campillo, 2006, CampusPress (ISBN 978-2-7440-2086-5)
(en) OpenGL Programming Guide: The Official Guide To Learning OpenGL, Version 2, Dave Shreiner, Mason Woo, Jackie Neider, 2005, Addison-Wesley (ISBN 978-0-321-33573-9)
(en) OpenGL Reference Manual: The Official Reference Document to Open Gl, Version 1.4, Dave Shreiner, 2004, Addison-Wesley (ISBN 978-0-321-17383-6)
(en) OpenGL Shading Language, Randi J. Rost, 2005, Addison-Wesley (ISBN 978-0-321-33489-3)
OpenGL Superbible, Richard S., Jr. Wright, Benjamin Lipchak, 2004, Sams (ISBN 978-0-672-32601-1)
(en) Beginning Opengl Game Programming, Dave Astle, Kevin Hawkins, 2004, Course Technology (ISBN 1-59200-369-9)

Spécifications

(en) OpenGL & OpenGL Utility Specifications

Notes et références

1 2 (en)Dave Astle et Kevin H. Hawkins, Beginning OpenGL: Game Programming, Cengage Learning - 2004 (ISBN 9781592003693).
↑ (en)Paul Martz,OpenGL Distilled,Addison-Wesley Professional - 2006,(ISBN 9780132701785).
↑ (en)PJ Cabrera, Peter Bakhirev, Ian Marsh, Ben Smith, Eric Wing, Scott Penberthy, Beginning iPhone Games Development, Apress - 2010 (ISBN 9781430226000).
↑ (en) « The OpenGL Pipeline Newsletter - Volume 002 », Transitions, novembre 2006.
↑ Long Peaks : présentation sur le site d'Icare3D.
↑ http://www.presence-pc.com/tests/Opengl-DirectX-guerre-22813/.
↑ (en) http://www.opengl.org/discussion_boards/ubbthreads.php?ubb=showflat&Number=243307&#Post243307.
↑ Un dérivé de ce programme est également partagé par son auteur dans une bibliothèque publique de Github : https://github.com/fdarmingaud/colorswap/blob/master/colorswap.c
↑ (en) Rich Geldreich, « Things that drive me nuts about OpenGL », Rich Geldreich's Tech Blog, 11 mai 2014.
↑ (en) Michael Larabel, « Former AMD Developer: OpenGL Is Broken », Phoronix, 31 mai 2014.

Liens externes

(en) Site officiel
(en) Catégorie OpenGL de l’annuaire DMOZ
(en) Mesa 3D, implémentation libre d'OpenGL

Portail de l’imagerie numérique

This article is issued from Wikipédia - version of the Wednesday, October 21, 2015. The text is available under the Creative Commons Attribution/Share Alike but additional terms may apply for the media files.