OpenGL étant une API en constante évolution, nous comptons sur vous pour enrichir cette FAQ et participer à sa maintenance. Si vous avez remarqué une erreur, une simple faute d'orthographe, si vous souhaitez nous faire part d'un manque, ou n'importe quoi d'autre : vous pouvez , ou poster à la suite de ce sujet consacré à la FAQ OpenGL.

Merci !

Pensez tout d'abord à consulter la FAQ Programmation 3D : celle-ci contient des notions de 3D d'ordre plus général, notamment des problèmes que vous pourriez rencontrer avec OpenGL, mais qui ne sont pas spécifiques à cette API.

Si vous ne trouvez de réponse à votre question dans aucune FAQ, et que celle-ci vous paraît pertinente, vous pouvez nous en faire part afin que nous l'ajoutions à cette FAQ. Voir https://jeux.developpez.com/faq/opengl/?page=generalites#GENERALITES_participer.

OpenGL (pour Open Graphics Library) est une spécification portable de rendu graphique 2D et 3D créée en 1992 par SGI (Silicon Graphics).

La spécification est un document décrivant des fonctions et le comportement de celles-ci dans le but de proposer une bibliothèque qui soit unifiée et prévisible pour le développeur d'applications 2D et 3D.

Grâce à OpenGL, vous allez pouvoir créer des applications 2D et/ou 3D utilisant la puissance de la carte graphique. Ainsi, si vous souhaitez un rendu utilisant les pleines capacités de votre machine, pour un jeu ou toute autre application 3D, vous allez sûrement devoir utiliser OpenGL. Un des buts d'OpenGL est d'être portable. Cela veut dire qu'OpenGL fonctionne aussi bien sous Windows, Linux, Mac OS X.

La spécification, maintenant décidée par le consortium Khronos, est ouverte et disponible sur le site officiel.

OpenGL ES (pour OpenGL Embedded Systems) est une spécification parallèle à OpenGL spécialisée dans les appareils embarqués. Celle-ci décrit généralement un sous‑ensemble des fonctionnalités de la spécification OpenGL.

C'est cette version qui est disponible sur les téléphones mobiles, certaines consoles et la majorité des appareils embarqués.

Khronos est un consortium, un comité regroupant des acteurs du monde des graphismes 3D. Celui-ci publie des spécifications telles qu'OpenGL, WebGL, EGL, OpenCL, SPIR…

Depuis 2006, Khronos gère l'évolution d'OpenGL. Parmi les acteurs participant aux discussions autour d'OpenGL, on retrouve : NVIDIA, AMD, Intel, Apple, Imagination Technologies, Valve…

OpenGL a beaucoup évolué pour suivre les nouvelles fonctionnalités des cartes graphiques. À l'origine (en 1992), OpenGL était une bibliothèque fonctionnant en mode immédiat (glBegin()/glEnd()). Pour chaque commande OpenGL, la carte graphique était directement sollicitée. Avec les évolutions des cartes graphiques, ce mode ne reflétait plus le fonctionnement des cartes graphiques (dépendance trop forte entre le CPU et le GPU).

À partir de la version 2, OpenGL s'est vu intégrer des fonctionnalités remplaçant le mode immédiat et les outils nécessaires à la programmation des cartes graphiques (celles-ci devenant programmables). Toutefois, même si le mode immédiat pouvait être évité, il était encore présent dans OpenGL.

Ce n'est qu'à partir de la version 3, que le mode immédiat a été complètement déprécié. Pour effectuer un rendu, il est nécessaire de passer par des tampons et de définir des shaders (ou nuanceurs en français) décrivant comment traiter les informations envoyées par le CPU à la carte graphique. C'est ce que l'on appelle l'OpenGL Moderne (à partir de la version 3 d'OpenGL).

Remarque : même si le mode immédiat est déprécié, il est toujours possible de l'utiliser.

Le pipeline de rendu est l'enchaînement d'opérations permettant de transformer les données de l'utilisateur (des points en 3D, avec texture, effets de lumière, effet de brouillard…) en pixels (points 2D à l'écran ayant la couleur appropriée).

Jusque dans les années 2000, le pipeline de rendu était fixe. Les puces embarquées sur la carte graphique ne faisaient qu'une seule chose et ne savaient faire que celle-ci.

Avec l'arrivée d'OpenGL 2 et des cartes graphiques de nouvelle génération, ce pipeline fixe est devenu de plus en plus programmable. Maintenant, les opérations pour transformer les données de l'utilisation en pixels sont personnalisables et peuvent ainsi mieux correspondre aux besoins des programmeurs.

Pour des raisons de compatibilité, le pipeline fixe et les anciennes versions d'OpenGL sont toujours supportés. Toutefois, le matériel a bien changé et ces fonctionnalités ne sont plus qu'implémentées sous la forme de shader généré à la volée par le pilote.

Les shaders sont des programmes compilés par le pilote graphique afin d'être exécutés par la carte graphique lors du rendu.

Il existe deux niveaux de portabilité lorsque l'on parle d'OpenGL :

• la portabilité au niveau de la plateforme : il existe des implémentations d'OpenGL pour Windows, Linux, Mac… Il est possible de créer un programme sur un système et ensuite faire tourner ce même programme sous un autre système ;
• la portabilité au niveau du matériel : chaque vendeur de cartes graphiques pouvant ajouter ses propres extensions, il est tout à fait possible avec OpenGL de créer des programmes qui ne tournent que sur un type de carte graphique donné. De même, un programme tournant sur une génération de cartes a peu de chances de tourner sur une génération plus ancienne si jamais elle utilise des extensions apportées par la nouvelle génération. Pour éviter les problèmes de portabilité entre cartes graphiques, il est donc conseillé de n'utiliser que les extensions ARB ou EXT (bien que les extensions EXT ne garantissent pas d'être présentes sur toutes les cartes, elles sont généralement implémentées par la plupart).

OpenGL est portable, c'est là son plus grand intérêt.
Son apprentissage est également très facile.
Il est très rapide, il exploite aujourd'hui toute la puissance des cartes graphiques du marché.
Il est évolutif grâce à un système d'extensions.

En 2014, Khronos a annoncé travailler sur une nouvelle version, complètement réécrite de la bibliothèque.

En 2015, Vulkan, le successeur d'OpenGL a été annoncé et est maintenant publié. Vulkan vise à enlever tout ce qui était en trop dans l'implémentation d'OpenGL, de simplifier la bibliothèque et d'ajouter les fonctionnalités suivantes :

• un contrôle direct du GPU avec un impact minimal sur les performances par le pilote. Un exemple en est l'écriture des données directement sur le GPU au lieu de passer par des appels tels que glUniform(). Ainsi les applications peuvent implémenter leur propre stratégie d'allocation ;
• les passes de rendu (render pass) permettant de contrôler le chargement des cibles de rendu au début et à la fin du rendu ;
• une architecture compatible avec le multithread. Les tampons de commandes peuvent être remplis par plusieurs threads à la fois et même être envoyés au GPU par un thread séparé ;
• une bibliothèque unifiée pour les PC, les mobiles et les plateformes embarquées. Il n'est plus question d'avoir une version pour les PC (OpenGL) et une autre pour les mobiles (OpenGL ES). Vulkan est une seule bibliothèque pour toutes les plateformes ;
• un code intermédiaire pour les shaders. Ces derniers peuvent être maintenant envoyés au pilote au format bytecode SPIR-V. Khronos fournit un compilateur GLSL vers SPIR-V. Il sera possible à tout un chacun de faire son propre compilateur.

Même si Vulkan arrive, OpenGL ne va pas pour autant disparaître et devrait toujours être supporté sur nos ordinateurs.

Vulkan est encore plus bas niveau (par rapport à la carte graphique) que ne l'est OpenGL. Pour les débutants, ou encore les amateurs, OpenGL est à préférer. En effet, le code minimal pour arriver à son premier rendu nécessite plus de lignes et de notions à intégrer avec Vulkan qu'avec OpenGL. De plus, Vulkan est créé pour la haute performance et l'intérêt que peuvent avoir les grands studios de développement à l'utiliser ne se retrouve pas chez les particuliers. OpenGL est donc la bibliothèque bas niveau de rendu à choisir.

OpenGL n'est pas un produit. OpenGL est une spécification implémentée par les constructeurs de cartes graphiques. Ce sont eux qui fournissent OpenGL à travers les pilotes de leurs cartes. En conclusion, il suffit d'installer ou de mettre à jour le pilote de votre carte graphique pour avoir OpenGL.

Pour les programmeurs, il peut être nécessaire de charger les pointeurs des fonctions OpenGL ou d'utiliser une bibliothèque supplémentaire (GLEW, GLEE, glad, GLXW…).

Nombreux sont les tutoriels sur OpenGL. Notamment, vous pouvez déjà trouver de bons tutoriels sur Developpez.com. Ensuite, si les tutoriels ne suffisent pas, il ne faut plus hésiter à passer le cap et lire la spécification d'OpenGL. Cela sera toujours la plus grande et la plus précise source d'informations.

OpenGL vous permet d'obtenir diverses informations. Ces informations sont accessibles en utilisant la fonction :

const GLubyte * glGetString(GLenum name)

Pour obtenir le modèle de la carte :

glGetString(GL_RENDERER)

Pour obtenir le nom du fabricant de la carte ou de l'implémentation d'OpenGL :

glGetString(GL_VENDOR)

Pour obtenir la version d'OpenGL et du driver :

glGetString(GL_VERSION)

Pour obtenir l'ensemble des extensions disponibles :

glGetString(GL_EXTENSIONS)

Même si OpenGL est une bibliothèque C, de nombreuses surcouches existent :

• en C++ : oglplus ;
• en C# : OpenTK;
• en Python : pyopengl ;
• en Java : JOGL ;
• ….

C'est impossible, vous devrez utiliser la version fournie par votre système d'exploitation. Sous Windows par exemple aucune mise à jour n'a été faite depuis Windows 98, la version d'OpenGL fournie étant donc toujours la 1.1.

Pas de panique cependant : vous pourrez bien entendu utiliser les fonctionnalités des versions supérieures, pour cela il suffit de les charger dynamiquement via le système d'extensions.