s
19 708 Pages

OpenGL
logo
noyau Linux et OpenGL vidéo games.svg
promoteur Silicon Graphics
puis Khronos Group de 2000
Date première version janvier 1992
dernière version 4,6 (31 Juillet 2017)
le système d'exploitation multiplateformes
langue C
sexe Bibliothèque de logiciels (Non liste)
Infographie
licence Licence multiple
(licence gratuite)
site Web

OpenGL (ouvert solcharte graphique Library) est une spécification qui définit un API pour plusieurs langues et de multiples plates-formes pour les applications d'écriture qui produisent infographie 2D et 3D. L'interface se compose d'environ 250 appels de fonctions différentes qui peuvent être utilisées pour dessiner des scènes complexes en trois dimensions à partir de primitives simples. Développé en 1992 par le Silicon Graphics Inc., Il est largement utilisé dans l'industrie du jeu (qui est en concurrence avec DirectX sur Microsoft Windows), Pour les applications CAD, la réalité virtuelle, et CAE. Il est la norme de facto pour l'environnement de l'infographie 3D Unix.

spécification

Un OpenGL de niveau inférieur est une spécification, ou il est tout simplement un document qui décrit un ensemble de fonctions et le comportement précis que ceux-ci doivent avoir. De cette spécification, les fournisseurs de matériel créent des implémentations, ou bibliothèques de fonctions, créées en utilisant les détails sur la spécification OpenGL, ce qui rend l'utilisation de l'accélération matérielle lorsque cela est possible. Les fabricants doivent dépasser les tests spécifiques pour pouvoir se vanter de leurs produits admissibles implémentations OpenGL.

Il existe des implémentations efficaces d'OpenGL (qui utilisent plus ou moins complète la GPU) à Microsoft Windows, Linux, de nombreuses plates-formes Unix, Playstation 3 et Mac OS. Ces mises en œuvre sont généralement fournis par les fabricants d'équipement vidéo et comptent beaucoup sur le matériel fourni. Il y a des projets de logiciels qui apportent OpenGL sur les plates-formes qui ne supportent pas les fabricants de matériel. Le plus connu est la bibliothèque open source mesa, API basée uniquement sur les bibliothèques de logiciels graphiques qui est compatible avec OpenGL. Toutefois, en raison des licences, l'API ne peut prétendre être « très similaire ».

La spécification OpenGL a été initialement supervisé dall'OpenGL Architecture Review Board (ARB), formé en 1992. Le ARB était composé d'un groupe d'entreprises intéressées par la mise en place d'une API cohérente et largement disponible. Les membres des fondateurs ARB comprenaient des sociétés telles que le calibre 3Dlabs, pomme, ATI Technologies, Dell, IBM, Intel, NVIDIA, SGI, Sun Microsystems et Microsoft, mais il a quitté le groupe en 2003. Mars La participation de tant d'entreprises ayant des intérêts très différents, OpenGL a conduit au fil du temps pour devenir une API polyvalente avec un large éventail de capacités.

Le contrôle OpenGL est passé, au début de 2007, le consortium Khronos Group en vue d'améliorer la commercialisation et de supprimer les barrières entre le développement OpenGL et OpenGL ES[1]

structure

OpenGL
Un processus pipeline graphique

OpenGL a deux tâches fondamentales:

  • cacher la complexité de l'interface avec différents accélérateurs 3D, offrant un programmeur API unique et uniforme;
  • cacher les possibilités offertes par les différents accélérateurs 3D, en exigeant que toutes les implémentations supportent pleinement l'ensemble des fonctions OpenGL, en utilisant un logiciel d'émulation si nécessaire.

La tâche d'OpenGL est de recevoir des primitives telles que des points, des lignes et des polygones, et les convertir en pixels (rastérisation ou pixellisation). Ceci est accompli par un pipeline graphique connu sous le nom machine d'état OpenGL[2]. La plupart des commandes OpenGL fournissent des primitives au pipeline graphique ou Instruire pipeline sur la façon de les traiter. Avant l'introduction d'OpenGL 2.0, chaque étape du pipeline a réalisé une fonction fixe et est configurable que dans certaines limites, mais de la version 2.0 de nombreuses étapes sont entièrement programmables par la langue GLSL.

OpenGL est une API de procédure et de faible niveau de travail, ce qui nécessite le programmeur les étapes précises pour dessiner une scène. Cette approche est en contraste avec le descriptif API de haut niveau qui, opérant sur Les données de structure arborescente (graphe de scène), Exiger le programmeur qu'une description générique de la scène, en prenant soin des détails les plus complexes de la interprétation. La nature OpenGL nécessite donc des programmeurs d'avoir une bonne connaissance du pipeline graphique lui-même, mais en même temps laisse une certaine liberté de mettre en œuvre des algorithmes complexes interprétation.

Historiquement, OpenGL a exercé une influence notable sur le développement des accélérateurs 3D, la promotion d'un niveau de fonctionnalité de base qui est commune aujourd'hui dans les cartes vidéo pour le grand public:

  • des points, des lignes et des polygones dessinés en tant que primitive de base;
  • un pipeline pour la transformation et l'éclairage;
  • Z-buffer
  • Le mappage de texture
  • mélange alpha

L'un des plus appréciés dans les fonctions professionnelles est rétrocompatibilité entre les différentes versions d'OpenGL: des programmes écrits pour la version 1.0 de la bibliothèque devrait fonctionner sans modification sur les implémentations qui suivent la version 2.1.

versions

Les révisions 1

1 est une évolution d'OpenGL (et a un style très similaire) IRIS GL, SGI interface 3D. L'une des seule restriction IRIS GL est qu'il a fourni l'accès aux fonctionnalités prises en charge par le matériel sous-jacent. Si votre matériel graphique ne prend pas en charge une fonction, l'application ne pouvait pas l'utiliser. OpenGL a surmonté ce problème en fournissant un soutien dans les logiciels pour les fonctionnalités non pris en charge par le matériel, ce qui permet aux applications d'utiliser des graphiques de pointe sur les systèmes relativement faible puissance. Le projet Fahrenheit est un effort commun entre Microsoft, SGI, et Hewlett-Packard dans le but d'unifier les interfaces OpenGL et Direct3D. Dans un premier temps, il a montré une certaine promesse de mettre de l'ordre dans le monde de l'API graphique 3D interactif informatique, mais en raison des contraintes financières SGI et le manque général de soutien dans l'industrie, a été abandonnée.

OpenGL 1.0

publié en 1992.

La première spécification OpenGL a été publié par Mark Segal et Kurt Akeley.

OpenGL 1.1

Publié en Janvier 1997.

OpenGL 1.1 est destiné à soutenir les textures fonctions et les formats de texture sur le matériel GPU.

  • cartes: tous

OpenGL 1.2

Mars publié 16 1998.

OpenGL 1.2 est destiné à soutenir les fonctions textures de volume, pixels compressés, renormalisation normale, serré / bord échantillonnage de texture et traitement d'image.

  • Cartes: Rage 128, Rage 128 GL, Rage XL / XC, Rage 128 Pro, Rage Fury MAXX et versions ultérieures.
1.2.1 OpenGL

Envoyé le 14 Octobre 1998.

OpenGL 1.2.1 est une publication intermédiaire qui ajoute des fonctionnalités de multi-texture, ou des unités de texture, le pipeline de rendu. Cela vous permet de mélanger plusieurs textures à base de pixels pendant la pixellisation.

  • Cartes: Radeon, Radeon Mobility Radeon 7500 Mobility Radeon 8500, Radeon 9000, Radeon 9200, Radeon 9600, Radeon 9800, GeForce 3, GeForce 4Ti, GeForce FX et plus récents.

OpenGL 1.3

Envoyé le 14 Août 2001.

OpenGL 1.3 ajoute le support pour la texture fonctions cubemap, multi-texturing, multi-échantillonnage, et les unités de texture combinent des fonctions d'exploitation (par exemple: ajouter, combiner et pince de bordure dot3).

  • Cartes: Radeon 32/36, 64/7200 Radeon, Radeon 7000, Radeo AIW, Radeon 7500, Radeon IGP 320M Radeon IGP 345M, ES1000, Radeon 8500, Radeon 9000 / Pro, Radeon 9100/9200/9250 (Pro IGP), GeForce 3, GeForce 4Ti, GeForce FX et versions ultérieures.

OpenGL 1.4

Publié le 24 Juillet 2002.

OpenGL 1.4 introduit le support matériel pour les fonctions d'ombrage, les coordonnées de brouillard, la génération automatique de mipmap, et les fonctions de texture supplémentaires.

  • Cartes: Quadro DCC, Quadro4 380 XGL, Quadro4 500XGL, 550XGL, Quadro4 700XGL, 750XGL, 900XGL, 980XGL et versions ultérieures.

OpenGL 1.5

Envoyé le 29 Juillet 2003.

OpenGL 1.5 ajoute le support pour: objets vertex buffer (des VBOs), les requêtes d'occlusion, et l'observation prolongée.

  • Cartes: Radeon X800, Radeon 9600, Radeon 9700, Radeon 9800, GeForce FX, et plus tard.

2 révisions

Les feuilles publiées OpenGL 2.0 est le premier à offrir des shaders programmables.

OpenGL 2 a été conçu par 3Dlabs pour répondre aux préoccupations que OpenGL stagnait et manquait une direction forte. 3Dlabs a proposé quelques grands ajouts à la norme, le plus important étant GLSL (à partir de ouvertGL SHading Language, c'est la langue d'ombrage OpenGL). Cela permettrait aux programmeurs de remplacer le code prédéfini pour vertex pipeline OpenGL et le traitement de shader fragment avec les écrits dans une langue comme C. GLSL a été marquée par l'échec d'adapter le matériel alors disponible; ce fut un retour à la tradition OpenGL de fixer des objectifs ambitieux et projeté vers l'avenir pour les nouveaux accélérateurs 3D, au lieu de simplement courir après l'état du matériel actuellement disponible. La finale OpenGL 2.0 spécifique[3] Elle comprenait un soutien pour GLSL, mais omis beaucoup d'autres fonctionnalités proposées à l'origine - ceux-ci ont été reportées aux futures versions d'OpenGL, bien que certains sont déjà disponibles sous forme d'extensions.

OpenGL 2.0

Affiché le 7 Septembre 2004.

OpenGL 2.0 ajoute le support pour un véritable langage d'assemblage, sur la base GPU, appelé ARB (Architecture Review Board parce conçu par), qui vise à devenir la norme pour toutes les fonctions vertex et fragment shaders.

  • Cartes: Radeon 9650, Radeon 9500, Radeon 9500/9550/9600/9700/9800 (Pro, SE, XT), Radeon X1050, Radeon Xpress 200/1100, Radeon X300, Radeon X550, Radeon X600 / Pro, Radeon X700, Radeon X800 (VE, SE, GT, Pro), Radeon X850, Radeon Xpress 1250, Radeon X1200, Radeon X1250, Radeon 2100, Radeon X1300, X1550, X1600, X1650, X1800, X1900, X1950 (Pro, XT, GT), GeForce 6800, Quadro 600, Quadro FX 500, Quadro FX 700, Quadro FX 1000, FX 2000, FX 3000, Quadro FX 1400, Quadro FX 1500, Quadro FX 3450, Quadro FX 3500, Quadro FX 4500X2, Quadro FX4500 SDI et plus tard.

OpenGL 2.1

Posté le 2 Juillet 2006.

OpenGL 2.1 introduit le support objets de mémoire tampon pixel (PBOS), sRGB textures (les textures corrigées gamma) et de matrices non carrée, en plus de la révision de 01:20 Shading Language GLSL[4].

  • Cartes: Radeon GD 2350, GeForce FX (avec les pilotes 175.19), GeForce 6000 séries, GeForce 7000 séries, GeForce Go 7000 série, Quadro FX 4000, Quadro FX 350, Quadro FX 550, Quadro FX 560, Quadro FX 1400, Quadro FX 1500, Quadro FX 5500 et versions ultérieures.

3 révisions

OpenGL 3.0 ajoute un mécanisme simplifié pour l'API futures révisions.

OpenGL 3.0

Publié le 11 Juillet 2008.

OpenGL 3.0 introduit le support pour les fonctions de shaders de géométrie, des objets de mémoire tampon de trame, l'instanciation du matériel, des objets de réseau de sommet (VANOS) et framebuffers sRGB (gamma 2.2)[5].

  • Cartes: Radeon série HD; GeForce 8000, 9000, GTX 100, GTX 200 et GTX série 300.

OpenGL 3.1

Publié le 28 mai 2009.

OpenGL 3.1 ajoute un certain nombre de fonctionnalités pour rendre l'API la plus pratique pour une utilisation, en plus d'un éventail de fonctionnalités orientées vers la performance[6]; également introduit un examen de langue 01:40 OpenGL Shading Language.

Avec la sortie de OpenGL 3.1, il a été introduit l'extension de compatibilité qui permet aux développeurs d'accéder aux fonctionnalités OpenGL dépréciée 1.X / 2.x et supprimé dans OpenGL 3.1.

La fonctionnalité obsolète et le profil de noyau enlevé comprennent:

  • tout le pipeline de fonction fixe
  • Le mode immédiat
  • le mode d'index de couleur
  • toutes les fonctions d'imagerie

OpenGL 3.2

Posté 3 Août 2009 et mis à jour 7jours Décembre 2009.

  • Cartes: Radeon série HD; GeForce 8000, 9000, GTX 100, GTX 200 et GTX série 300.

OpenGL 3.3

Posté le 11 Mars 2010.

Cette version est destinée à permettre le GPU des générations précédentes de bénéficier d'une partie de la fonctionnalité OpenGL 4.0. Aussi vue Pensée de développer OpenGL ES (API dédiée aux appareils mobiles tels que ceux basés sur androïde, webOS et iPhone OS).[7]

Introduit Révision 3.30 OpenGL Shading Language langue.

4 révisions

OpenGL 4.0

Posté le 11 Mars 2010.

Cette version inclut le support pour tessellation (tessellation), Et virgule flottante à 64 bits double précision (pour améliorer la qualité) pour shaders. Il améliore également le support du standard OpenCL, dédié à GPGPU, à-dire la possibilité de tirer parti du GPU pour un grand type d'utilisations.[7]

OpenGL 4.1

Envoyé le 26 Juillet 2010.

Cette version améliore l'interopérabilité avec OpenCL et introduit la compatibilité avec OpenGL ES 2.0.

OpenGL 4.2

Publié le 8 Août 2011.[8]

OpenGL 4.3

Envoyé le 6 Août 2012.[9]

Cette version présente, entre autres, la version 4.30 du langage d'ombrage GLSL, la nouvelle méthode de texture ETC2 / compression EAC, les vues de texture et une compatibilité totale avec OpenGL ES 3.0.

  • Cartes: NVIDIA GeForce série 400, série NVIDIA GeForce 500, NVIDIA GeForce série 600

OpenGL 4.4

Publié le 22 Juillet 2013.

OpenGL 4.5

Posté le 11 Août, 2014, est introduit dans la commande de chasse qui permet de meilleures performances dans les applications multithread, le DSA (accès direct État) permet un contrôle indépendant des différents objets, est également optimisé le moteur de rendu WebGL[10].

OpenGL 4.6

31 Juillet Posté, 2017, en plus de nombreuses extensions et améliorations, il introduit le support SPIR-V.

extensions

La norme OpenGL permet aux fabricants individuels de fournir des fonctionnalités supplémentaires par extensions les nouvelles technologies sont créées. Une extension est ensuite répartie en deux parties: la façon dont le fichier d'en-tête contenant les prototypes de fonction d'extension, et comment conducteur fabricant. Chaque fabricant a abréviation alphabétique qui est utilisé pour nommer leurs nouvelles fonctions et constantes. Par exemple, l'abréviation NVIDIA (Nevada) Il est utilisé dans la définition de leur fonction exclusive glCombinerParameterfvNV () et leur constante GL_NORMAL_MAP_NV. Il est possible que davantage de producteurs acceptent de mettre en œuvre les mêmes fonctionnalités étendues.

Dans ce cas, nous utilisons l'abréviation EXT. Il peut aussi arriver que l'ARB approuve l'extension. Il devient alors connu sous le nom extension standard, et en utilisant l'abréviation ARB. La première extension ARB était GL_ARB_multitexture. Après avoir suivi le chemin de la promotion des extensions officielles, le multitexture est plus en option mis en œuvre l'extension ARB, mais il a été intégré dans l'API basée sur OpenGL à partir de la version 1.4. Spécifications pour presque toutes les extensions peuvent être trouvés dans le dépôt officiel des extensions[11].

Plusieurs bibliothèques ont été construites sur OpenGL pour fournir des fonctionnalités non disponibles dans OpenGL lui-même:

  • GLU
  • GLUT
  • GLUI

En particulier, la bibliothèque OpenGL Performer, développé par SGI et disponible pour IRIX, Linux, et différentes versions de Microsoft Windows, Elle repose sur OpenGL pour permettre la création d'applications de simulation visuelle En temps réel.

fixation

Afin d'imposer ses caractéristiques multi-langues et multi-plateformes, divers lier et ports Ils ont été développés pour OpenGL dans de nombreuses langues. Parmi les plus notables, la bibliothèque Java 3D Il peut appuyer sur OpenGL pour tirer parti de l'accélération matérielle. Très récemment, Sun a publié les versions bêta du système JOGL, qui fournit des liaisons aux commandes OpenGL C, Contrairement à Java 3D, il ne fournit pas un tel soutien à faible niveau. La page officielle répertorie différentes liaisons OpenGL pour les langues Java, Fortran 90, Perl, Pike, python, Ada, et Visual Basic. Reliures sont également disponibles pour C ++ et C #.

Fonctions de haut niveau

OpenGL est conçu pour être sortie seule: ne fournit que des fonctions interprétation. L'API de base ne comprend pas la gestion des fenêtres, audio, impression, clavier, souris ou autres périphériques d'entrée. Bien que cela puisse sembler restrictive, ce qui permet le code de rendu d'être complètement indépendant du le système d'exploitation sur lequel il fonctionne, ce qui permet le développement d'un code de plate-forme indépendante. Cependant, pour permettre une interaction avec le système hôte, vous devez intégrer le logiciel avec un système de fenêtrage natif. Cela se fait à travers les API suivantes:

  • GLX - X11 (y compris la transparence du réseau)
  • GTL - Microsoft Windows

Dans les bibliothèques d'addition GLUT et SDL Ils offrent des fonctionnalités à une gestion de la fenêtre principale avec OpenGL, de manière portable. MacOS Il a trois API pour obtenir le soutien OpenGL: agl carbone, NSOpenGL pour cacao et Core OpenGL (CGL) pour un accès direct.

code source échantillon

Voici un programme simple C qui attire l'aide des primitives OpenGL un triangle. Notez que ce programme utilise des fonctionnalités dépréciées de OpenGL 3.0.

/ ************************************************* ************
 * Pour compiler avec gcc sous Linux: *
 * Gcc file.c -lglut *
 * Ou: *
 * Gcc file.c -L / usr / X11R6 / lib -lglut -lXmu -lGL -lGLU -lXi *
 ************************************************** *********** /
#include  // fichiers d'en-tête pour OpenGL
#include  // fichiers d'en-tête pour la bibliothèque GLUT
#include  // fichiers d'en-tête pour une utilisation « exit () »
/ * Fonction invoquée lorsque la fenêtre est redimensionnée (même lors de sa création) * /
vide
redimensionner (int largeur, int hauteur)
{
glViewport (0, 0, largeur, hauteur); // Nous utilisons toute la fenêtre
glMatrixMode (GL_PROJECTION);     // Sélectionnez cette option pour utiliser la matrice « PROJECTION »
glLoadIdentity ();                // Réinitialiser la matrice « PROJECTION »
glMatrixMode (GL_MODELVIEW);      // Sélectionnez cette option pour utiliser la matrice « modèle-vue »
glLoadIdentity ();                // Réinitialiser la matrice « modèle-vue »
}
/ * Fonction Dessin * /
vide
dessiner ()
{
glClearColor (0.0f, 0.0f, 0.0f, 0.0f); // Fond noir
glClear (GL_COLOR_BUFFER_BIT);         // Effacer la scène
glBegin (GL_TRIANGLES);                // Dessine un triangle
glColor3f (1.0f, 0.0f, 0.0f);          // Nous avons mis le rouge
glVertex3f ( 0.0f, 0.5f, 0.0f);        // Top coin
glColor3f (0.0f, 1.0f, 0.0f);          // Définir la couleur verte
glVertex3f (-0.5f, -0.5f, 0.0f);       // Faible angle gauche
glColor3f (0.0f, 0.0f, 1.0f);          // Définir la couleur bleue
glVertex3f (0.5f, -0.5f, 0.0f);        // angle droit vers le bas
glEnd ();                              // Fin du triangle
glutSwapBuffers ();                    // Draw!
}
/ * Fonction qui est appelée à chaque fois qu'une touche est pressée * /
vide
keyPressed (non signé carboniser clé, int x, int y)
{
si (clé == 'Q') // Si le bouton est pressé q,
sortie (0);     // sortie
}
/ * Principal * /
int
principal (int argc, carboniser **argv)
{
glutInit (argc, argv);                     // Initialisation de la bibliothèque GLUT
glutInitDisplayMode (GLUT_RGB|GLUT_DOUBLE); // Sélectionnez le mode d'affichage: RVB et utilise le double buffering
glutInitWindowSize (640, 480);              // Définissez la taille d'une fenêtre 640x480
glutInitWindowPosition (0, 0);              // Définir la position angulaire du coin supérieur gauche de la fenêtre
glutCreateWindow (« Exemple d'utilisation OpenGL »);    // Créer la fenêtre
glutDisplayFunc (dessiner);                     // Définir la fonction de dessin
glutReshapeFunc (redimensionner);                   // Définir la fonction de mise à l'échelle
glutKeyboardFunc (keyPressed);              // Définit la fonction pour les événements de clavier
glutMainLoop ();                            // Accueil
retour (1);
}

L'avenir pour Microsoft Windows

Le 6 Août 2005, ceux qui étaient au début des intentions de Microsoft concernant le support OpenGL windows Vista Ils ont été révélés dans une annonce de nouvelles sur Opengl.org[12].

« Plans actuels de Microsoft pour OpenGL sur Windows Vista pour soutenir OpenGL sur Direct3D afin d'utiliser OpenGL sur un ordinateur de bureau composite pour l'expérience AeroGlass. Si vous utilisez un OpenGL ICD - le typographe de bureau s'éteint - dégrader de manière significative l'expérience utilisateur.

Dans la pratique, pour OpenGL sous AeroGlass, cela signifie:

Les performances OpenGL sera considérablement réduite - peut-être jusqu'à 50%.

OpenGL sur Windows sera portée à une version de base d'OpenGL 1.4.

Aucune prolongation ne sera possible d'exposer les innovations matérielles futures. Il serait techniquement fournir immédiatement un ICD OpenGL (pilote installable client, à savoir un pilote spécifique pour OpenGL) dans l'ensemble de l'expérience AeroGlass sans compromettre la stabilité ou la sécurité du système d'exploitation. Lay OpenGL sur Direct3D est une décision stratégique de la technique. »

Ainsi, l'avenir de l'OpenGL comme la bibliothèque principale pour les jeux vidéo semblait précaire. Microsoft a pris la décision de ne pas publier les informations nécessaires pour permettre à des tiers (tels que NVIDIA, ATI ou d'autres grands fabricants de cartes) pour développer pilote de remplacement, ne laissant aucun moyen d'éviter la chute de la vitesse de 50%.

Peut-être en raison des pressions qui venaient de l'industrie du logiciel et les mêmes fabricants de matériel, Microsoft a révisé ultérieurement cette politique et sont maintenant disponibles CIM en mesure de fonctionner sans problème conjointement avec le sous-système AeroGlass, sans diminution des performances. Voir à ce sujet la présentation relative à OpenGL sur Windows Vista publiée par NVIDIA au SIGGRAPH 2006[13].

Comme avec le prédécesseur windows XP, Aussi le CD d'installation windows Vista Il ne comprend pas la CIM (Installable Client Driver), qui doit être installé par l'utilisateur. En l'absence d'un ICD, Vista offre encore des fonctionnalités OpenGL 1.4 sans extensions, à travers une couche d'émulation basée sur Direct3D.

L'avenir de l'OpenGL dans le domaine du jeu est donc maintenant entre les mains des producteurs de jeux vidéo, qui ne semble toujours pas très susceptibles d'utiliser cette API, ainsi que démontrent une décision d'un de ses partisans les plus éminents dans ce domaine, à savoir John Carmack de Id Software. Ce dernier a tenu[14] un QuakeCon 2005 que sa plate-forme de développement principale Xbox 360, fait que se penche DirectX.

notes

bibliographie

  • Conseil OpenGL Architecture Review; Dave Shreiner. OpenGL Manuel de référence: Le document officiel de référence OpenGL, version 1.4 (4e édition), Addison-Wesley Professional, 2004. ISBN 0-321-17383-X
  • Conseil OpenGL Architecture Review; Dave Shreiner; Mason Woo; Jackie Neider; Tom Davis. OpenGL Guide de programmation: Le Guide officiel d'apprentissage OpenGL, version 2 (5e édition). Addison-Wesley Professional, 2005. ISBN 0-321-33573-2
  • Randi J. Rost. OpenGL Shading Language, Addison-Wesley Professional, 2004. ISBN 0-321-19789-5

Articles connexes

D'autres projets

  • Il contribue à Wikimedia Commons Wikimedia Commons: Il contient des images ou d'autres fichiers OpenGL

liens externes

  • (FR) site officiel, opengl.org.
  • (FR) Registre OpenGL - toutes les spécifications, les en-têtes, les extensions et les documents connexes

Ressources pour les développeurs