Faq Ogl

Cette FAQ est un condensé des questions les plus fréquemment posées sur les forums
de http://www.developpez.com, ainsi que de l'expérience des auteurs. Toutefois il se

peut qu'une erreur se soit glissée dans celle-ci, ou qu'une information soit manquante ou
plus à jour. Dans ce cas n'hésitez pas à nous contacter et à contribuer à l'enrichissement
de cette FAQ.
Sur ce, l'équipe vous souhaite une bonne lecture !

Ont contribué à cette FAQ :
Laurent Gomila - loka - shenron666 -

bafman - Zoso_ - Info-Rital - fearyourself -
1. Généralités (18) ......................................................................................................................................................................... 4
1.1. OpenGL et les autres langages / bibliothèques (8) .......................................................................................................... 8
2. Les extensions (4) ....................................................................................................................................................................12
3. Optimisations (3) ..................................................................................................................................................................... 15
4. Techniques (15) ....................................................................................................................................................................... 17
5. Problèmes (2) ...........................................................................................................................................................................27
6. GLU (1) ................................................................................................................................................................................... 28
7. GLUT (17) ............................................................................................................................................................................... 29
-3-
Les sources présentées sur cette pages sont libres de droits, et vous pouvez les utiliser à votre convenance. Par contre la page de présentation de ces sources
constitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2005 - 2006 Developpez LLC. Tout droits réservés Developpez LLC. Aucune
reproduction, même partielle, ne peut être faite de ce site et de l'ensemble de son contenu : textes, documents et images sans l'autorisation expresse de Developpez
LLC. Sinon vous encourez selon la loi jusqu'à 3 ans de prison et jusqu'à 300 000 E de dommages et intérêts.
http://jeux.developpez.com/faq/opengl/
Sommaire > Généralités
Comment participer à cette FAQ ?
Auteurs : Laurent Gomila ,
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 contacter le responsable par MP (loka), ou poster à la suite de ce
sujet consacré à la FAQ OpenGL.
Merci !
Ma question n'est pas traitée ici, que faire ?

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 Comment participer à cette FAQ ?.
Qu'est-ce qu'OpenGL ?
Auteurs : shenron666 , Laurent Gomila ,
OpenGL (pour Open Graphics Library) est une bibliothèque portable de rendu graphique 2D et 3D créée en 1992 par
SGI (Silicon Graphics) : http://www.sgi.com/.
Elle se compose de plusieurs centaines de fonctions qui permettent au programmeur la création d'images de haute
qualité. OpenGL est utilisé dans de nombreux domaines, aussi bien dans les moteurs de jeux vidéo (la série Quake est
un bon exemple), dans des logiciels de modélisation 3D professionnels payants (3D Studio Max, Lightwave) ou gratuits
(Blender), ou encore dans l'imagerie médicale.
OpenGL est maintenu par un groupe indépendant : l'ARB (Architecture Review Board), composé des plus grands acteurs
du marché (Compaq, Microsoft, SGI, IBM, 3DLabs, HP, Intel, Evans & Sutherland). C'est l'ARB qui contrôle donc les
propositions d'évolution de l'API, les étudie et les approuve.
Que signifie "portable" ?

Auteurs : shenron666 , bafman ,
Il existe deux niveaux de prortabilitée 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 hardware : chaque vendeur de carte graphique 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 carte a peu de chances
-4-
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 presentes sur toute les
cartes, elle sont généralement implementées par la plupart).
Quels sont les intérêts d'utiliser OpenGL ?

Auteurs : shenron666 ,
OpenGL est portable, c'est là sont plus grand intérêt.
Il est également très facile d'apprentissage.
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.
Quel est le futur d'OpenGL ?

Aujourd'hui en version 1.5, OpenGL doit évoluer vers une architecture orientée vers la souplesse qu'offrent les nouvelles
cartes graphiques. La technologie des shaders fera donc partie intégrante d'OpenGL 2.0 tout en restant compatible
avec les précédentes versions 1.x de la bibliothèque.
La version 2.0 de la bibliothèque OpenGL, disponible depuis le 7 septembre 2004, est la 6ème évolution d'OpenGL
depuis sa création.
Plus d'informations sur OpenGL 2.0 sur le site officiel :

http://opengl.org/documentation/opengl_current_version.html.
Où trouver des tutoriels pour OpenGL ?

Un peu partout sur Internet, nombre d'entre eux sont en anglais mais quelques sites proposent des tutoriels ou des
exemples simples en français.
Tutoriels en français
C et C++ :
•
GLInFrench : cours généraux
•
LinuxGraphic : didacticiels divers
•
G-Truc : nombreux tutoriaux OpenGL divers
•
Ze zglut code depot : projets OpenGL avec code source
•
Principes et astuces : trucs et astuces OpenGL
•
Guide du routard OpenGL : tutoriels de base pour OpenGL 1.2
Delphi
-5-
•
DelphiPage : Introduction à OpenGL avec Delphi
•
Installer GLScene9 dans Delphi 2005
•
OpenGL avec Delphi
Tutoriels en anglais
•
NeHe Productions : articles, tutoriels, liens, ... la référence pour développer avec OpenGL
•
CodeSampler : codes sources
•
Nate Robins : programmes-tutoriels
•
LightHouse 3D : tutoriels avancés
•
Le site developpeur de nVidia : pas mal de choses sur la programmation 3D, les techniques récentes, les
outils et SDK nVidia, des articles, des tutoriels, des démos, ...
•
Le site developpeur de ATI : même chose que chez nVidia, codes sources, démos, outils, articles, ...
•
Humus : démos avancées avec code source inclus
•
Advanced Graphics Programming Techniques Using OpenGL : techniques avancées avec OpenGL
(présentation SIGGRAPH `98)
•
Paul's projects : codes sources avancés
•
Delphi OpenGL Projects : projets OpenGL réalisés en Delphi
Où trouver de la documentation de référence sur OpenGL ?

Le site officiel d'OpenGL est incontournable : http://www.opengl.org/.
La section "Documentation" propose entre autres :
• L'accès en ligne au manuel de référence OpenGL : The OpenGL Reference Manual (Bluebook)
• L'accès en ligne au guide de programmation OpenGL : The OpenGL Programming Guide (Redbook)
• Les spécifications de toutes les versions d'OpenGL : http://opengl.org/documentation/spec.html
• La documentation sur toutes les extensions OpenGL ainsi que la dernière version de l'en-tête pour les exploiter :
http://oss.sgi.com/projects/ogl-sample/registry/
• La documentation du système de shaders : http://opengl.org/documentation/oglsl.html
• Les implémentations pour les différentes plateformes supportées : http://opengl.org/documentation/
implementations.html
Comment obtenir diverses informations comme le

modèle de la carte graphique ou la version des drivers ?
Auteurs : Info-Rital ,
OpenGL vous permet d'obtenir diverses informations. Ces informations sont accessibles en utilisant la fonction :
const GLubyte * glGetString(GLenum name)
-6-
Pour obtenir la modèle de la carte :
glGetString(GL_RENDERER)
Pour obtenir le nom du fabriquant 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)
Comment mettre à jour ma version d'OpenGL ?

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'Comment charger une fonction liée à une extension ?.
-7-
Sommaire > Généralités > OpenGL et les autres langages / bibliothèques
Qu'est-ce que AUX ?
Auteurs : Zoso_ ,
Tout comme Qu'est-ce que GLUT ?, AUX s'occupe des opérations relatives au système de fenêtrage et à la gestion des
évènements. Son utilisation est trés similaire à GLUT, à tel point qu'il suffit bien souvent de remplacer le préfixe des
fonctions "glut" par "aux" pour retrouver les fonctions correspondantes.
Pour l'utiliser il faut posséder glaux.lib et glaux.h, qui sont livrés la plupart du temps avec les EDI classiques. Cependant
AUX est confiné à un seul système d'exploitation qui se trouve être Windows.
lien : Tutoriels OpenGL utilisant AUX
Quelles bibliothèques utiliser avec OpenGL ?

La bibliothèque OpenGL ne couvrant que l'aspect graphique, il faut qu'elle soit secondée au moins par une bibliothèque
de fenêtrage afin de pouvoir exploiter ses possibilités. Il est également possible d'utiliser les fonctions de base du système
sur lequel on programme mais dans ce cas on pert la portabilité d'OpenGL. Voici donc une liste de bibliothèques
utilisables avec OpenGL (classées par catégorie) :
Fenêtrage (permet la création de la fenêtre d'affichage et l'interfaçage avec le système)

Voir Quelle bibliothèque de fenêtrage utiliser ?.
GUI (interface graphique) (apporte une gestion des boutons et autres controles à l'application)
•
SDL_gui : http://www.newimage.com/~rhk/SDL_gui/
•
GLgooey : http://glgooey.sourceforge.net/
•
GLui : http://www.cs.unc.edu/~rademach/glui/
Texte (permet de générer / afficher du texte, lire les fichier truetype)
•
SDL_ttf : http://www.libsdl.org/projects/SDL_ttf/
•
Freetype : http://www.freetype.org/
Graphique/Image (apporte des routines de traitement d'images, la gestion des fichiers graphiques)
•
OpenIL (Devil) : http://openil.sourceforge.net/
•
SDL_Image : http://www.libsdl.org/projects/SDL_image/
Extensions (simplifie l'accès aux extensions OpenGL)
•
Glew : http://glew.sourceforge.net/
Son (encodage / décodage des sons, gestion des fichiers sonores)
-8-
•
OpenAL : http://www.openal.org/
•
SDL_mixer : http://www.libsdl.org/projects/SDL_mixer/
•
SDL_sound : http://icculus.org/SDL_sound/
Réseau (communication entre machines via différents protocoles)
•
SDL_net : http://www.libsdl.org/projects/SDL_net/
•
HawkNL : http://www.hawksoft.com/hawknl/
Physique (gestion de la physique, de la détection des collisions, ...)
•
Tokamak : http://www.tokamakphysics.com/
•
ODE : http://ode.org/
•
NovodeX : http://novodex.com/
Quelle bibliothèque de fenêtrage utiliser ?

La bibliothèque de fenêtrage permet la création de la fenêtre d'affichage et l'interfacage avec le système. L'utilisation
d'une bibliothèque permet de conserver la portabilité qui fait la force d'OpenGL. Pour cela, il existe plusieurs
bibliothèques qui, selon l'utilisateur, auront leurs avantages et / ou leurs inconvénients :
GLUT (GL Utility Toolkit) : http://www.xmission.com/~nate/glut.html. Voir Qu'est-ce que GLUT ?.
FreeGlut : http://freeglut.sourceforge.net/.
OpenGLut : http://openglut.sourceforge.net/.
Adaptations de la bibliothèque GLUT qui n'est plus mise à jour. OpenGLut apporte également des fonctions
supplémentaires aux fonctions de GLUT. Les 2 bibliothèques se veulent compatibles avec la dernière version de GLUT.
GLFW (GL FrameWork) : http://glfw.sourceforge.net/.

Bibliothèque portable (Windows, MacOS, Linux, ...) relativement simple d'utilisation et surtout très légère. Parmis les
possibilités offertes par la bibliothèque, et outre la création de la fenêtre de rendu, le programmeur aura accès à la
gestion du couple clavie r/ souris, les joysticks, le multi-taches, le chargement de textures et d'autres fonctionalités.
SDL (Simple Directmedia Layer) : http://www.libsdl.org/.

SDL est une bibliothèque portable qui a bonne réputation, d'autant plus qu'elle a servi à l'adaptation des jeux "Unreal
Tournament" et "Civilization : Call To Power" sous Linux. Puissante et stable, elle offre la gestion du couple clavier /
souris, des joysticks, du son, des images, du multi-tâches et bien d'autres en plus de la gestion du fenêtrage.
Aujourd'hui, de nombreux programmes d'exemple et tutoriaux trouvables sur Internet utilisent GLUT. La majorité
d'entre eux datent et même si GLUT est une bibliothèque stable elle n'est pas approprié à la conception d'un jeu,
notamment par sa mauvaise gestion du mode plein écran.
-9-
La bibliothèque SDL est tout aussi facile à programmer, stable et performante, elle a tout pour satisfaire les besoins au
sein de gros projets. Elle a non seulement fait ses preuves avec des adaptations de jeux commerciaux, mais qui plus est
elle est toujours suivie tandis que le développement de GLUT s'est arrêté il y a plusieurs années.
Autre point important, la documentation très complète et plutot bien faite est directement accessible depuis le site
officiel de SDL.
Une version SDL 2.0 plus orientée objet serait en cours de développement, à suivre...
Quel langage utiliser pour développer avec OpenGL ?

Auteurs : bafman ,
Il existe des portages d'OpenGL dans de très nombreux langages, allant de l'assembleur au Java en passant par C, C
++, Python et autres.
Pour se faire une idée de l'ensemble des langages qui peuvent être utilisés, il suffit de faire un tour sur le site de
NeHe, et de regarder les différentes versions de chaque tutoriel.
Comment utiliser OpenGL avec les MFC ?

Sous Windows, il est tout à fait possible d'utiliser OpenGL dans une interface construite avec les MFC (Microsoft
Foundation Classes) de Visual C++.
Il existe de nombreux tutoriels qui pourront vous aider à intégrer OpenGL aux MFC :
•
OpenGL I : quick start (MSDN)
•
MFC and OpenGL
•
OpenGL MFC GLUT tutorials
•
Setting up OpenGL in an MFC control
•
NeHe OpenGL MFC basecode
•
MFCOGL, un exemple de code OpenGL MFC générique
•
OpenGL et MFC
•
Tutoriels OpenGL utilisant les MFC
Comment utiliser OpenGL avec les langages .NET ?

Plusieurs bibliothèques existent pour utiliser OpenGL en .NET (C#, VB.NET, ...) :
Tao est une collection de bibliothèques fonctionnant avec Mono et .NET. Parmi celles-ci : OpenGL, GLU, FreeGlut,
OpenAL, DevIL, SDL, ...
Site web : http://www.mono-project.com/Tao
CsGL (CSharp Graphics Library) est une bibliothèque permettant également d'utiliser OpenGL en .NET.
- 10 -
Site web : http://csgl.sourceforge.net/
Tutoriel en français : Programmer OpenGL en CSharp
Comment utiliser OpenGL dans une interface wxWidgets ?

wxWidgets fournit un composant spécialisé pour l'affichage OpenGL : WxGLCanvas. Ainsi il devient très simple
d'intégrer une scène OpenGL à une interface graphique développée avec wxWidgets.
Voir la documentation sur le wiki de wxWidgets :

WxGLCanvas - wiki.
Ainsi que la documentation de référence de la classe :

WxGLCanvas
Comment utiliser OpenGL dans une interface Qt ?

Tout comme Comment utiliser OpenGL dans une interface wxWidgets ?, Qt propose un composant pour intégrer une
scène OpenGL à votre interface : QGLWidget.
Pour une utilisation plus poussée, Qt fournit également d'autres classes en relation avec OpenGL dans son module
QGL. Cependant, la classe QGLWidget seule sera suffisante la plupart du temps.
Voir également ce tutoriel en français sur l'utilisation d'OpenGL avec Qt :

Le tutoriel Qt indépendant - Chapitre 14 : OpenGL.
- 11 -
Sommaire > Les extensions
Comment fonctionne le système d'extensions d'OpenGL ?
Contrairement à DirectX qui n'est développé que par Microsoft et mis à jour tous les deux mois, la standardisation
d'OpenGL est contrôlée par l'ARB, commité composé des constructeurs de hardware les plus importants (voir Qu'est-
ce qu'OpenGL ?). Ainsi, il faut parfois plusieurs mois (voire plusieurs années) avant qu'une nouvelle fonctionnalité soit
intégrée au coeur d'OpenGL.
Afin de pouvoir exploiter sans attendre les nouvelles fonctionnalités du hardware, OpenGL inclut un mécanisme
d'extensions, qui permet d'utiliser certaines fonctions sans qu'OpenGL ne les connaisse.
Utiliser une extension se fait en deux temps : il faut tout d'abord vérifier que l'extension que vous souhaitez utiliser
est bien supportée par votre système (voir Comment savoir si une extension est supportée par mon hardware ?), puis
charger dynamiquement les fonctions associées à celle-ci (voir Comment charger une fonction liée à une extension ?).
Vous pourrez ensuite utiliser vos nouvelles fonctions comme n'importe quelle autre fonction incluse au coeur d'OpenGL.
Attention cependant : la plupart des extensions sont spécifiques à un seul constructeur, et seront inutilisables sur
d'autres types de cartes. Par exemple, celles dont le nom commence par "NV" sont spécifiques aux cartes nVidia, et
celles commençant par "ATI" ne concernent que les cartes ATI. Les extensions "ARB" par contre, ont été officialisées
par l'ARB à partir d'une certaine version d'OpenGL, et tout hardware compatible avec cette version devrait en
théorie supporter ces extensions (par exemple, toutes les cartes compatibles OpenGL 1.5 supportent l'extension
ARB_fragment_program). Pour finir il y a également les extensions "EXT", qui sont à peu près officielles mais n'ont
pas encore été validées par l'ARB.
Enfin, il est important de noter qu'il existe des bibliothèques permettant de faciliter la gestion des extensions, par
exemple GLEW.
Comment savoir si une extension est supportée par mon hardware ?

Il est possible de demander à OpenGL la liste de toutes les extensions supportées par le hardware, via la fonction
glGetString appelée avec l'option GL_EXTENSIONS. La liste retournée est une chaîne de caractère, 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
- 12 -
}
Comment charger une fonction liée à une extension ?

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ère, 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 derniere
version de glext.h ?).
Pour faciliter le chargement des extensions et le rendre quasiment transparent, vous pouvez également utiliser
GLEW, une bibliothèque conçue pour faire ce boulot.
Où puis-je trouver la derniere version de glext.h ?

Auteurs : shenron666 , Laurent Gomila ,
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 extentions OpenGL dans un programme.
Vous pouvez trouver la dernière version de glext.h sur le site de SGI.
Sous Delphi, l'équivalent GLext.pas pourra être trouvé par exemple dans Delphi OpenGL Toolkit (DOT). 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;
- 13 -
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.
- 14 -
Sommaire > Optimisations
Comment améliorer les performances de mon application OpenGL ?
Auteurs : bafman ,
Il n'existe pas de méthode pré-établie pour améliorer les performances d'un programme tournant sous OpenGL ; tout
dépend de ce que vous voulez lui faire faire exactement. Un moteur 3D destiné à rendre des scène en interieur s'orientera
plutot vers des optimisations du type portal + PVS, alors qu'un moteur créé pour rendre des exterieurs aura plutôt
tendance à s'orienter vers des octrees / quadtrees.
Dans tout moteur 3D en général, la première optimisation n'est pas d'utiliser les commandes les plus rapides pour
afficher, mais bien d'utiliser des algorithmes appropriés pour ce que l'on veut effectuer. Néanmoins d'un point de vue
strictement OpenGL, il existe quelques "bonnes techniques" à utiliser pour ne pas se retrouver limité par des erreurs
de programmation.
La règle de base est de savoir qu'OpenGL est une machine à états, c'est-à-dire que tout état acitvé à un instant T restera
actif durant tous les instants suivants, à moins de désactiver cet état. Ceci implique pour le programmeur de bien savoir
quels états sont actif à quel moment, afin d'utiliser le moins possible de fonctionnalités inutiles.
Un bon exemple de ce qu'il ne faut pas faire est d'utiliser du blending en mode (SRC_ONE, DST_ZERO). En effet,
quand cette fonction de blending est activée, elle n'a aucun effet visible sur le rendu (la scène est rendue exactement
de la même manière que si le blending était désactivé), ce qui signifie que le pipeline OpenGL calcule une opération de
blending sans que cela ait une quelconque influence sur le rendu final. C'est du temps de calcul perdu.
Un autre type d'optimisation est d'utiliser les listes d'affichage (display lists) pour effectuer du batching de commandes
OpenGL (voir qu'est ce que le batching faq 3D). En effet, les listes d'affichage peuvent contenir presque tout type de
commandes OpenGL (avec quelque limitations specifiée dans le Red Book), ce qui permet en un seul appel de commande,
d'effectuer plusieurs opérations OpenGL.
Il existe de nombreux sites sur internet parlant d'optimisation de code OpenGL, le plus documenté étant sûrement le
site de nVidia section "développeurs", qui contient notament un document décrivant les principales erreurs à éviter en
OpenGL : Avoiding common OpenGL pitfalls.
Qu'est ce qui est le plus rapide ? glVertex, display list, vertex array ou VBO ?
Auteurs : bafman ,
Malheureusement la réponse n'est pas évidente, elle est adaptée à chaque type de moteur.
Basiquement on peut trier les différentes méthodes comme ceci :
VBO compilé > VBO > vertex array compilé > display list > vertex array > glVertex
Mais malheureusement ceci depend beaucoup du constructeur de la carte graphique, voire même de la version des
drivers. De plus, une mauvaise utilisation d'une des méthodes peut faire perdre beaucoup en rapidité. Par exemple,
compiler un vertex array à chaque frame est plus lent que d'utiliser un vertex array simple, car le driver fait une passe
d'optimisation lors de la compilation qui du coup fait perdre du temps. De même, utiliser une display liste pour un objet
très petit est une mauvaise idée, car l'appel à la display list a un coût important qui sera superieur au coût d'affichage
du même objet avec glVertex.
- 15 -
La seul chose qui soit à peu près sûre, c'est que la methode la plus lente est l'utilisation de glVertex.
Comment mesurer les performances d'une application OpenGL ?

La première chose à faire, la plus banale et simple, est d'intégrer à votre application un compteur de FPS (frames par
seconde). Le principe est de mesurer à l'aide de compteur très précis (QueryPerformanceCounter sous Windows) la
durée du rendu d'une frame.
Pour connaître le framerate de votre application en temps réel, vous pouvez également utiliser le freeware FRAPS
( http://www.fraps.com).
Des programmes plus poussés ont également été développés afin de tester les performances d'une application OpenGL :
• La page "Benchmarks" du site officiel d'OpenGL fournit une liste des benchs les plus utilisés
• GLTrace (code source fourni)
• glTest est également disponible dans les distributions de GLUT, dans "progs/bucciarelli/gltest.c"
- 16 -
Sommaire > Techniques
Comment faire de la 2D avec OpenGL ?
OpenGL n'offre aucune fonction destinée à la 2D, du moins pas directement. Il est cependant très simple de faire du
rendu 2D si l'on considère qu'il s'agit de rendu 3D avec un axe fixe.
En pratique, il suffit de paramétrer correctement les matrices de transformation :
// On place la matrice de modelview à l'identité, mais rien n'empêche par la suite

// d'appliquer des rotations, translations ou mises à l'échelle
glMatrixMode(GL_MODELVIEW);
glLoadIdentity();
// On définit une matrice orthogonale pour la perspective, ce qui permettra d'avoir une vue 2D et non en perspec
glMatrixMode(GL_PERSPECTIVE);
glOrtho(left, right, bottom, top, near, far);
// Ou gluOrtho2D(left, right, bottom, top);
Puis, ne pas oublier d'utiliser des fonctions manipulant des coordonnées 2D, comme par exemple glVertex2f() au lieu
de glVertex3f().
Comment désactiver l'écriture dans le color buffer ?

Auteurs : bafman ,
Certains effets necessitent d'écrire dans le Z-Buffer sans écrire dans le color buffer (par exemple pour les shadow
volumes).
Afin d'effectuer cet effet il existe 2 possibilités en OpenGL :
1- Positionner les paramètres de blending sur GL_ZERO, GL_ONE. Cela fonctionne mais est coûteux (les fragments
sont tout de même traités), et cela risque d'interférer avec le blending utilisé dans certains autres effets.
glBlendFunc(GL_ZERO, GL_ONE);
2- Utiliser la fonction glColorMask :
glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);
En positionnant tous les paramètres à GL_FALSE, cette fonction désactive l'écriture dans le color buffer tout en
continuant à écrire dans les autres buffers (stencil, depth).
Comment désactiver l'écriture dans le Z-buffer ?

L'écriture dans le Z-buffer (ou encore depth-buffer) est contrôlée par la fonction glDepthMask :
/* Activer l'écriture dans le Z-buffer */
- 17 -
glDepthMask(GL_TRUE);
/* Désactiver l'écriture dans le Z-buffer */

glDepthMask(GL_FALSE);
Comment activer l'écriture dans le stencil buffer ?

L'activation ou la désactivation de l'écriture dans le stencil buffer (ainsi que les tests) s'effectue en appelant glEnable /
glDisable avec le flag GL_STENCIL_TEST :
/* Activer l'écriture et les tests de stencil */

glEnable(GL_STENCIL_TEST);
/* Désactiver l'écriture et les tests de stencil */

glDisable(GL_STENCIL_TEST);
Comment rendre une couleur transparente, par exemple sur un sprite ?

Il faut pour cela que la texture utilisée ait un canal alpha correctement défini, c'est-à-dire que les pixels transparents
aient une valeur alpha à 0.
Il ne faut donc pas oublier de spécifier lors de la création de la texture (avec glTexImage2D ou autre) que le format
de l'image source contient un canal alpha (GL_RGBA), et que la texture doit également en contenir un (nombre de
composantes égal à 4 et non 3).
glTexImage2D(GL_TEXTURE_2D, 0, 4, largeur, hauteur, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);
Si votre image ne possède pas de canal alpha mais plutôt une couleur que vous souhaitez rendre transparente, vous
pouvez très bien parcourir les pixels de celle-ci et affecter manuellement les valeurs alpha selon la couleur des pixels.
Une fois la texture correctement munie d'un canal alpha, il existe deux solutions pour activer la transparence. Comme
expliqué dans la FAQ 3D ( "Comment avoir une texture trouée"), le meilleur moyen est d'activer l'alpha-test.
Sous OpenGL, l'alpha-test s'active via le code suivant :
glEnable(GL_ALPHA_TEST);
glAlphaFunc(GL_GREATER, 0.0f);
/* Dessin du sprite avec transparence */
glDisable(GL_ALPHA_TEST);
Ici, nous paramètrons l'alpha-test pour qu'il ne garde que les pixels ayant une valeur alpha strictement supérieure 0.
La seconde option est d'activer l'alpha-blending de la manière suivante :
glEnable(GL_BLEND);
glBlendFunc(GL_SRC_ALPHA, GL_ONE_MINUS_SRC_ALPHA);
/* Dessin du sprite avec transparence */
- 18 -
glDisable(GL_BLEND);
Ceci-dit cette méthode a plusieurs inconvénients : premièrement les sprites devront être triés d'arrière en avant, de plus
ce ne sera pas aussi performant que l'alpha-test.
Comment faire une capture écran (screenshot) ?

OpenGL fournit un moyen très simple de récupérer le contenu du color buffer avec la fonction glReadPixels :
// Width et Height représentent les dimensions du backbuffer

// Buffer est un pointeur vers une zone mémoire suffisamment grande pour recevoir les pixels
glReadPixels(0, 0, Width, Height, GL_BGRA, GL_UNSIGNED_BYTE, Buffer);
Par contre aucun mécanisme n'est fourni pour enregistrer l'image récupérée dans un fichier, pour cela il vous faudra
passer par une bibliothèque tierce (voir Quelles bibliothèques utiliser avec OpenGL ?).
Attention : récupérer les pixels du color buffer est une opération très lente et à n'utiliser que dans cette optique.
N'envisagez par exemple pas d'utiliser ce mécanisme pour effectuer des traitements en temps réel.
Comment charger et afficher un modèle 3D ?

Ni OpenGL, ni GLU ou encore GLUT ne fournit de mécanisme aidant au chargement ou à l'affichage de modèles 3D,
quelque soit leur format. Ainsi il vous faudra mettre la main à la patte pour gérer ceux-ci. Plusieurs solutions s'offrent
à vous :
La première est d'utiliser un format ASCII simple à décortiquer (ASE par exemple) et de coder un loader capable de
charger ce format. Le site des formats de fichiers fournit une description détaillée de la plupart des formats existant ;
si jamais vous n'y trouviez pas le vôtre alors pensez à Google.
Game Tutorials propose également de nombreux tutoriels permettant de charger les formats les plus courants (3DS,
OBJ, ASE, MD2, MD3), mais il faudra payer pour accéder à ceux-ci...
Un format spécialement conçu pour OpenGL a également vu le jour : il s'agit de XGL. Suivant une syntaxe XML, il
est très facile à manipuler ; il est également prévu pour pouvoir stocker n'importe quelle information utilisable par
OpenGL.
Sa page officielle fournit les spécifications du format, des exemples, des liens, des modèles, et même un convertisseur
3DS -> XGL.
A noter que la distribution de GLUT contient un code source permettant de charger les fichiers au format OBJ (voir
progs/demos/smooth/glm.c).
La seconde solution est d'utiliser un programme permettant de convertir un modèle directement en code C, contenant
les appels OpenGL permettant de construire et d'afficher le modèle. Cette alternative est toutefois déconseillée dans le
sens où elle n'est absolument pas flexible : pour afficher un nouveau modèle il faudra en effet recompiler l'application.
Quelques logiciels proposent cette conversion, par exemple PolyTrans ou encore 3D Exploration.
- 19 -
Enfin, pour les plus courageux, il est bien sûr possible de concevoir un format de modèles perso. Deux solutions pour
créer les modèles : coder des scripts d'exportation pour votre logiciel de modelisation préféré (pas forcément évident...),
ou coder un convertisseur à partir d'un format existant (mais dans ce cas autant utiliser ce format directement).
Pour plus d'informations sur les formats à utiliser n'ayant pas de lien avec OpenGL, vous pouvez consulter Quel
format de modèle 3D utiliser ?.
Comment afficher du texte avec OpenGL ?

Auteurs : Info-Rital ,
OpenGL ne fournit pas de moyen direct pour afficher du texte, c'est pourquoi vous devrez utiliser d'autres
fonctionnalités d'OpenGL pour l'affichage de polices, comme l'affichage de bitmaps ou de pixmaps, la création de
texture maps contenant une table complète de caractères, ou encore la création de formes géométriques 3D.
Utilisation de bitmaps ou pixmaps La manière la plus classique d'afficher du texte avec OpenGL est l'utilisation de
glBitmap() ou glDrawPixels() pour chaque caractères. Le résultat est un simple texte 2D qui convient dans la majorité
des cas. Préfèrez glBitmap() à glDrawPixels() car ce dernier est bien plus lent. Généralement, chaque appel à glBitmap(),
un pour chaque caractère, est placé dans une display list, qui est indexé par sa valeur de caractère ASCII. Ensuite, un
appel à glCallLists() permet d'afficher un chaîne entière de caractères.
Vous pouvez aussi utiliser des fonctions propres à certains toolkits et API comme glXUseXFont() pour le serveur X,
wglUseFontBitmaps() pour Windows ou encore glutBitmapCharacter() pour GLUT.
Par texture mapping Dans beaucoup d'implémentations OpenGL, glBitmap() et glDrawPixels() sont très lents par
rapport à un carré texturé. Utilisez dans ces cas là cette solution. L'idée est de créer une texture qui contient tous les
caractères d'une police (ou au moins ceux qui seront affichés). Pour afficher un charactère, dessinez un carré texturé,
avec les coordonnées de la texture configurées pour séléctionner le charactère voulu dans la texture. Vous pouvez aussi
jouer avec la valeur alpha pour désactiver le fond de la police.
Voilà les deux méthodes les plus classiques pour afficher du texte dans une scène OpenGL. Ces méthodes sont applicables
dans de nombreux contextes (langages, plateformes, OS..). Cependant, si le résultat obtenu ne vous convient pas (si vous
souhaitez avoir des polices 3D etc..), il existe des solutions plus techniques. Cependant la plupart de ces solutions sont
propres à une API ou à un système d'exploitation.
Pour la création d'images pour les textures, il existe sur internet de petits programmes vous les générant. Vous pouvez
cependant coder votre propre FontFactory.
Si vous utilisez Java, n'hésitez pas à faire appel aux API du JDK et plus particulièrement à Java2D qui vous facilitera
grandement la tâche.
Il existe aussi des bibliothèques vous facilitant grandement l'affichage de texte avec OpenGL :
• FNT
• GLTT
• OGLFT
lien : NeHe - Bitmap fonts

lien : NeHe - Outline fonts
lien : NeHe - Texture mapped outilne fonts
lien : NeHe - 2D texture fonts
- 20 -
lien : Texture mapped fonts
Comment et pourquoi utiliser une meta-texture?

Auteurs : fearyourself ,
La fonction glBindTexture est une fonction relativement lourde. Ce qui veut dire que lorsque vous voulez afficher une
scène, il est généralement déconseillé de passer d'une texture à une autre trop souvent.
Une technique intéressante est de regrouper les images dans une unique texture et de s'en servir comme meta-texture.
En utilisant les paramètres passés à la fonction glTextureCoord2f, on peut sélectionner les parties de la meta-texture
afin d'avoir la texture que l'on cherche.
Une question qui peut se poser est de savoir comment gérer ce genre de meta-texture, surtout lorsque la texture que
l'on veut se compose aussi de sous-parties.
Prenons d'abord un exemple, supposons que la texture A se compose de 4 parties :
Et une texture B se compose de 2 autres parties :
Lorsqu'on les mettra ensemble, cela donnera la texture C :
- 21 -
Lorsqu'on avait une seule texture A, on faisait :
glBindTexture(GL_TEXTURE_2D, index_de_la_texture_A);
Si on voulait avoir la partie noire, on aurait fait :
glBegin(GL_QUADS);
glTexCoord2f(0.0f, 1.0f);
glVertex3f(-1.0f, 1.0f, 0.0f); /* coin haut-gauche */
glVertex3f( 1.0f, 1.0f, 0.0f); /* coin haut-droit */
glVertex3f( 1.0f, -1.0f, 0.0f); /* coin bas-droit */
glVertex3f(-1.0f, -1.0f, 0.0f); /* coin bas-gauche */
glEnd();
Mais avec la texture C, qu'est-ce qui change ? Déjà la fonction glBindTexture va devoir charger la texture C, mais les
arguments de glTexCoord2f changent également... C'est là où avoir un gestionnaire de texture est pratique. Il suffit
d'avoir un gestionnaire qui nous donne les coordonnées et l'indice de la texture que l'on cherche.
Lorsque je veux afficher mon carré noir, mon programme a son propre indice pour savoir que je veux cette partie.
Pourquoi ? Parce que rien n'oblige OpenGL à redonner à chaque exécution les mêmes indices de textures (c'est pour
cela qu'on utilise glGenTextures).
Donc pour lorsque je veux avoir l'indice OpenGL d'une texture, rien ne vaut un gestionnaire central des ressources
(voir ce tutoriel sur la gestion des ressources).
Pour revenir à notre problème, nous avons donc un gestionnaire de texture à qui nous pouvons dire :
tex = gestionnaireTextures.getTexture(indice_carre_noir);
Qu'est-ce que nous mettons dans tex ? Les coordonnées de la sous-texture voulue dans la meta-texture.
Les coordonnées seront données par position du coin inférieur gauche (comme en OpenGL le coin inférieur gauche est
donné par les coordonnées (0.0,0.0)) et (largeur / hauteur). Donc une structure de ce type :
typedef struct sTexture

{
float debx, deby;
float larg, haut;
- 22 -
} STexture;
Finalement, notre code de départ doit être modifié ; en effet, nous devons prendre en compte la position de la sous-
texture. La transformation de code se fera en deux étapes. Pour la première, nous allons enlever les coordonnées écrites
en hard et passer par des variables :
float gauche = 0.0f, droite = 0.5f, haut = 1.0, bas = 0.5;
glBegin(GL_QUADS);
glTexCoord2f(gauche, haut);
glTexCoord2f(droite, haut);
glTexCoord2f(droite,bas);
glTexCoord2f(gauche, bas);
glEnd();
Ensuite, pour prendre en compte la position dans la meta-texture, il suffit de modifier le calcul fait aux variables gauche,
droite, haut et bas.
Dans notre cas (si nous voulions la sous-texture A), nous aurions comme valeurs :
tex.begx = 0.0;
tex.begy = 0.0f;
tex.haut = 1.0f;
tex.larg = 0.5;
Et le code d'affichage deviendrait :
float gauche = tex.begx + tex.larg * 0.0f;

float droite = tex.begx + tex.larg * 0.5f;
float haut = tex.begy + tex.haut * 1.0f;
float bas = tex.begy + tex.haut * 0.5;
glBegin(GL_QUADS);
glTexCoord2f(gauche, haut);
glTexCoord2f(droite, haut);
glTexCoord2f(droite,bas);
glTexCoord2f(gauche, bas);
glEnd();
Un dernier point important : quand faire un glBindTexture ?
En effet, n'oublions pas que nous avons fait cela pour limiter les appels à la fonction glBindTexture. Le plus simple est
de laisser le gestionnaire le faire. Nous lui demandons de le faire, et il pourra vérifier si la sous-texture que nous voulons
est déjà en place (si elle se trouve dans la meta-texture déjà chargée). Si ce n'est pas le cas, le gestionnaire la charge.
Finalement, si vos sous-textures sont mises ensemble de façon optimale, il est possible de faire tenir en une seule meta-
texture toutes les textures d'une scène.
- 23 -
Voilà, vous savez maintenant utiliser une meta-texture et la gérer correctement.
lien : Comment créer une meta-texture?
Comment créer une meta-texture?

Il existe deux techniques prnicipales : la création avant le lancement du programme, et la création pendant le
programme.
La première solution est de prendre votre programme de dessin favori, ouvrir les deux textures qui vous intéresse et
les mettre ensemble pour former une texture plus grande.
Un exemple est donné dans la question Comment et pourquoi utiliser une meta-texture?.
La deuxième technique est de créer virtuellement cette texture en juxtaposant les images lorsqu'elles sont chargées en
mémoire. Lorsque le programme se charge, il va demander à un gestionnaire de ressource de charger plusieurs textures.
Le gestionnaire ne va pas les charger individuellement mais va les mettre ensemble pour former des meta-textures. Ceci
est bien sûr fait pour limiter le nombre d'appels à glBindTexture.
Cette technique demande que le programme utilise le gestionnaire pour :
• Charger la texture
• Récupérer les coordonnées d'une texture
• Faire appel à la fonction glBindTexture, s'il le faut
Lorsqu'on charge une image, avant de la donner à OpenGL, on la stocke dans un tableau contenant les couleurs rouge,
vert et bleu de chaque pixel. Il est donc facile de garder ce tableau et de le concaténer avec une autre texture avant de
passer ce nouveau tableau à la fonction glTexImage2D.
Comment effectuer un rendu dans une image (offscreen) ?

Il arrive parfois que l'on ait besoin d'effectuer le rendu d'une scène non pas à l'écran, mais dans une image ou une
quelconque surface en mémoire système ; c'est ce que l'on appelle le rendu offscreen.
Un tel rendu n'est pas disponible directement avec les fonctionnalités d'OpenGL. En effet, cela dépend du contexte
d'affichage et non de l'API ne elle-même, ce qui est donc dépendant du système d'exploitation.
Voici un lien expliquant comment réaliser un rendu offscreen sous différents systèmes : OpenGL/Mesa off-screen
rendering.
Comment savoir quel objet se trouve sous le poineur (picking) ?

Afin de déterminer quel objet de la scène 3D se trouve sous un point donné (en général le pointeur de la souris), il faut
utiliser ce que l'on appelle le picking. Il existe plusieurs méthodes pour réaliser du picking.
- 24 -
Habituellement, on utilise le mode de rendu GL_SELECT fourni par OpenGL, qui permet d'identifier instantanément
quel objet se trouve sous un point de l'écran.
Voici quelques tutoriels expliquant comment utiliser le mode GL_SELECT :
- Picking tutorial
- Sélection et picking avec OpenGL
Cependant il existe d'autres méthodes, qui fonctionnent tout aussi bien.
La première méthode alternative consiste à transformer les coordonnées 2D du point dans l'espace 3D. Pour cela il
suffit de lui faire subir les transformations inverses de celles qui sont appliquées aux objets 3D, ce qui donnera un rayon
(et non un point unique, puisqu'on ajoute une dimension). Il suffira ensuite d'effectuer des tests d'intersection entre ce
rayon et les objets de la scène afin de déterminer lequel se trouve sous le pointeur. La fonction gluUnproject permet
de générer facilement un tel rayon.
Une autre méthode est d'effectuer un rendu de la scène en assignant à chaque objet une couleur unique et constante,
puis d'aller lire dans le back buffer la couleur du point en question, ce qui vous donnera instantanément l'identifiant
de l'objet que vous recherchez.
Comment placer une vidéo dans une texture ?

Lire une vidéo et placer son contenu dans une texture OpenGL est une tâche difficile, et surtout dépendante du système
d'exploitation. De ce fait, OpenGL ne fournit aucune fonctionnalité pour réaliser ce genre de manipulation.
Voici tout de même un tutoriel de NeHe expliquant comment lire une vidéo dans une texture sous Windows :
http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=35.
Comment avoir de l'anti-aliasing ?

Auteurs : bafman ,
Il existe plusieurs méthodes pour effectuer de l'anti-alising avec OpenGL.
La première, que l'on voit souvent dans la littérature, est d'utiliser les parametres suivants :
glHint(GL_LINE_SMOOTH_HINT,GL_NICEST);
glHint(GL_POLYGON_SMOOTH_HINT,GL_NICEST);
glEnable(GL_POLYGON_SMOOTH);
glEnable(GL_LINE_SMOOTH);
Cette méthode est à éviter à tout prix. En effet pour avoir un anti-alising correct avec cette méthode, il faut :
• Trier les polygones du plus lointain au plus proche

• Ne pas avoir d'intersection entre polygones
Une autre méthode présentée est d'utiliser le tampon d'accumulation, puis de rendre la scène plusieurs fois en modifiant
légèrement la position de la caméra. Bien que moins contraignante d'un point de vue structure de données, cette méthode
est aussi à éviter car elle est très consommatrice de ressources (plusieurs rendus pour une même scène...).
- 25 -
la dernière méthode, utilisée dans les jeux vidéo, consiste à utiliser le Comment activer le multi-sampling ? qui permet
d'avoir un anti-aliasing de qualité pour un coût de traitement moindre.
lien : Qu'est-ce que l'anti-aliasing ?
Comment activer le multi-sampling ?

Auteurs : bafman ,
L'activation du multi-sampling avec OpenGL dépend du système de fenêtrage utilisé.
Sous GLUT, il suffit de passer le paramètre GLUT_MULTISAMPLE lors de l'initialisation du contexte. Par exemple :
glutInitDisplayMode(GLUT_DOUBLE | GLUT_RGB | GLUT_MULTISAMPLE);
Avec la SDL il faut utiliser l'attribut SDL_GL_MULTISAMPLEBUFFERS :
/* Utilisation de l'anti-aliasing possible ? */

if (SDL_GL_SetAttribute(SDL_GL_MULTISAMPLEBUFFERS, 1) == -1)
{
fprintf(stderr, "Impossible d'initialiser SDL_GL_MULTISAMPLEBUFFERS à 1\n");
}
/* Nombre de tampons utilisés pour l'anti-

aliasing (la valeur utilisée dépend de la carte graphique) */
if (SDL_GL_SetAttribute(SDL_GL_MULTISAMPLESAMPLES, 6) == -1)
{
fprintf(stderr, "Impossible d'initialiser SDL_GL_MULTISAMPLESAMPLES à 6\n", fsaa);
}
Où le nombre de tampons définit le niveau d'anti-aliasing (dépend de la carte graphique).
Enfin, avec l'API Win32, le code est un peu plus long mais est très bien décrit dans ce tutoriel de NeHe : Leçon 46.
- 26 -
Sommaire > Problèmes
Pourquoi ma lumiere n'éclaire-t-elle pas mon polygone quand je lui applique une texture ?
Auteurs : bafman ,
Généralement, c'est que la texture est mise en mode REPLACE au lieu de MODULATE.
En mode REPLACE, OpenGL ne prend en compte lors de l'affichage que la couleur de la texture, alors qu'en mode
MODULATE, la couleur de la texture est multipliée par la couleur du polygone.
Pour definir le mode d'utilisation de la texture il faut utiliser le code suivant :
glBindTexture(/* binding de la texture dont on veut modifier les parametres */);

glTexEnvf(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, parametre);
Où parametre vaut GL_REPLACE ou GL_MODULATE, selon ce que l'on veut réaliser.
Mon programme ne passe pas l'édition de liens ("undefined reference to ..."), que faire ?
Comme toute bibliothèque, OpenGL nécessite d'être liée à votre programme si vous souhaitez l'utiliser, sans quoi
l'éditeur de lien ne trouvera pas les fonctions correspondantes et vous jettera à la figure des messages tels que ceux-ci :
undefined reference to `glViewport@16'

...
Il faut donc lier avec les bibliothèques que vous utilisez.
Avec Visual C++ : il faut aller dans les propriétés du projet, "édition de liens", "entrée", et y ajouter les fichiers .lib
correspondant aux bibliothèques GL que vous utilisez (opengl32.lib pour OpenGL, glu32.lib pour GLU, et glut32.lib
pour GLUT). Vous pouvez également lier en ajoutant la directive #pragma comment(lib, "xxx.lib") dans l'un de vos
fichiers sources.
Avec MinGW : il faut également aller dans les propriétés du projet, "édition de liens", et ajouter les fichiers adéquats
(libopengl32.a pour OpenGL, libglu32.a pour GLU, et libglut32.a pour GLUT). Vous pouvez également ajouter
directement à la ligne de commande "-lxxx" pour lier avec la bibliothèque libxxx.a.
A noter que sous Windows vous aurez également besoin de lier avec GDI (libgdi32.a ou gdi32.lib), pour tout ce qui est
création du contexte d'affichage.
Avec gcc : de la même manière qu'avec MinGW, il faut ajouter dans la ligne de commande "-lgl", "-lglu" ou "-lglut"
pour utiliser ces bibliothèques.
Dernières remarques : vérifiez d'une part que tous ces fichiers sont dans des répertoires prédéfinis de l'éditeur de lien,
et d'autre part... assurez-vous que vous les avez bien installé !
- 27 -
Sommaire > GLU
Qu'est-ce que GLU ?
GLU (pour OpenGL Utility Library) est une bibliothèque d'outils destinés à OpenGL, et basés sur la même conception
que cette dernière.
Elle possède de nombreuses fonctions destinées entre autres à créer des mip-mapsà partir d'une seule image, de générer
des coordonnées de texture, de dessiner des surfaces quadriques et des NURBS, de faire appel à un tesselator, et bien
d'autres encore.
La version 1.2 de GLU était destinée à OpenGL 1.1, la version actuelle de la bibliothèque GLU est la 1.3 qui apporte de
nouvelles fonctionnalités correspondant aux capacités d'OpenGL version 1.2.
- 28 -
Sommaire > GLUT
Qu'est-ce que GLUT ?
GLUT (GL Utility Toolkit) est une bibliothèque portable apportant principalement la gestion du fenêtrage à OpenGL.
La version originale de GLUT a été créée par Mark Kilgard puis portée sous Win32 (Windows 95, 98, Me, NT, 2000,
XP) par Nate Robins.
De nombreux tutoriaux et exemples trouvables sur internet utilisent GLUT, c'est la bibliothèque la plus répandue.
Malheureusement aujourd'hui, GLUT n'est plus mis à jour et la dernière version (3.7.6) date du 8 novembre 2001. (voir
aussi Quelle bibliothèque de fenêtrage utiliser ?).
Où trouver GLUT ?
Le FTP de GLUT contient de nombreux fichiers utiles :
• Les dernières versions pour différentes plateformes, binaires et fichiers de développement

• Les versions précédentes
• Le code source de GLUT
• Des FAQs
• La documentation de référence (HTML, PS, PDF)
Vous trouverez également tout ce qu'il faut concernant le portage Windows de GLUT, sur le site de Nate Robins.
Enfin, FreeGlut, une version open source de GLUT possédant une licence beaucoup moins restrictive est disponible
sur le site de FreeGlut.
Comment se passer de la console sous Windows ?

Par défaut sous Windows, une console s'affiche lors de l'execution de votre application, en plus de la fenêtre de rendu.
Il est très simple de s'en passer : il faut créer un projet "Application Windows" et non "Application Console". Attention
toutefois à bien changer le point d'entrée : il s'agira de WinMain et non plus de main.
Si vous souhaitez tout de même conserver main comme point d'entrée (pour des raisons de portabilité par
exemple), certains EDI permettent de modifier celui-ci. Par exemple sous Visual Studio, il faut ajouter l'option "/
ENTRY:mainCRTStartup" dans la ligne de commande de l'éditeur de liens.
Comment texturer les primitives créées avec GLUT ?

GLUT permet de créer des formes de base via ses fonctions glutSolidCone, glutSolidCube, ... mais ces formes ne
possèdent pas de coordonnées de textures, ainsi il est impossible de les texturer correctement.
- 29 -
Il n'y a aucun moyen de forcer GLUT à ajouter des coordonnées de texture, ainsi il vaudra mieux passer par les fonctions
de GLU pour générer ces formes (gluCylinder, gluSphere, ...). Leur génération est toutefois plus compliquée, puisqu'il
faut passer par les quadriques. Plus d'informations sur l'utilisation des quadriques ici :
http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=18.
Pour activer la génération de coordonnées de texture, il suffit d'intercaler un petit appel à gluQuadricTexture avec
GL_TRUE en paramètre.
Pourquoi ma fonction GLUT ne fonctionne pas ?

Comme beaucoup de fonctions GLUT, il faut avoir une fenêtre valide pour pouvoir l'appeler. Vérifiez donc que votre
programme ouvre d'abord une fenêtre correctement avant tout autre appel GLUT.
Une ouverture de base se fait comme ceci :
int main(int argc, char **argv)

{
/* On utilisera le mode RGB, un double tampon et le tampon Z */
glutInit(&argc,argv);
/* On voudra une fenêtre 640x480 */

glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE | GLUT_DEPTH);
glutInitWindowSize(640,480);
glutCreateWindow("OpenGL - Glut");
glutMainLoop();
return EXIT_SUCCESS;
}
Comment récupérer les extensions OpenGL avec GLUT ?

Sous OpenGL, la technique est d'appeler glGetString et parcourir la chaîne de caractères renvoyée.
Mais avec GLUT, on peut utiliser plus simplement la fonction suivante pour déterminer si une extension est supportée :
int glutExtensionSupported(char *extension);
Où extension est la chaîne de caractères associée à l'extension (par exemple "GL_ARB_texture_compression").
Comment afficher du texte avec GLUT dans une perspective orthogonale ?

Pour afficher du texte avec GLUT, la fonction à utiliser est glutBitmapCharacter. Mais cette fonction ne marchera pas
toute seule, il faut utiliser glRasterPos2f pour initialiser correctement la position d'écriture.
Voici un exemple :
void render_string(float x, float y, float z, void* font, const char* s)

{
- 30 -
glDisable(GL_TEXTURE_2D);
glDisable(GL_DEPTH_TEST);
glRasterPos2f(x, y);
while(*s)
{
glutBitmapCharacter(font, *s);
s++;
}
}
Les deux glDisable permettent d'être sûr d'avoir le texte affiché dans la couleur souhaitée.
Pour savoir quoi passer pour le paramètre font, voir Comment connaître les fonts que l'on peut utiliser avec
glutBitmapCharacter ?.
Comment connaître les fonts que l'on peut utiliser avec glutBitmapCharacter ?
Il faut regarder dans vos fichiers d'inclusion GLUT des lignes suivantes :
/* Bitmap font constants (use these in GLUT program). */

#define GLUT_BITMAP_9_BY_15 ((void*)2)
#define GLUT_BITMAP_8_BY_13 ((void*)3)
#define GLUT_BITMAP_TIMES_ROMAN_10 ((void*)4)
#define GLUT_BITMAP_TIMES_ROMAN_24 ((void*)5)
#define GLUT_BITMAP_HELVETICA_10 ((void*)6)
En principe ceux-là ne bougeront pas donc vous pouvez vous en servir. Mais il y en aura peut-être d'autres...
Comment connaître la taille d'un caractère affiché par glutBitmapCharacter ?

On utilise la fonction suivante :
int glutBitmapWidth(void *font, int character);
Le paramètre font est le même que celui passé à glutBitmapCharacter (voir Comment connaître les fonts que l'on peut
utiliser avec glutBitmapCharacter ?).
Comment gérer un évènement ?

Sous GLUT, tout se fait avec des fonctions de rappel (callbacks). Ce sont des fonctions qui seront appelées lorsque la
gestion d'un évènement est nécessaire.
- 31 -
Avant de lancer la boucle avec glutMainLoop(), on définira donc les fonctions qui vont gérer le clavier, la souris,
l'affichage, etc.
Voir par exemple :
• Comment gérer le clavier ?

• Comment gérer la souris ?
• Comment gérer l'affichage ?
• Comment savoir si la souris a quitté la fenêtre ?
• Comment savoir si la fenêtre est visible ou non ?
• Comment mettre en place un timer ?
• Comment faire exécuter du code lorsque le processus ne fait rien ?
Comment gérer le clavier ?

Pour gérer le clavier, on peut utiliser quatre fonctions qui se divisent en deux groupes :
Lorsqu'une touche est appuyée, elle peut être une touche dite normale ou spéciale. Par exemple, les touches F1 - F12
sont considérées spéciales ; les lettres de l'alphabet sont elles des touches normales.
Voici les deux fonctions qui permettent de gérer l'appui d'une touche sur un clavier :
void glutKeyboardFunc(void (*func)(unsigned char key, int x, int y));

void glutSpecialFunc(void (*func)(int key, int x, int y));
Ensuite, on peut gérer le fait qu'un utilisateur relâche une touche en utilisant les fonctions suivantes :
void glutKeyboardUpFunc(void (*func)(unsigned char key, int x, int y));

void glutSpecialUpFunc(void (*func)(int key, int x, int y));
Exemple :
void AppuiTouche(int key, int x, int y)

{
if (key == GLUT_KEY_F1)
{
/* La touche F1 est appuyée */
}
}
void RelachementTouche(int key, int x, int y)

{
if (key == GLUT_KEY_F1)
{
/* La touche F1 est relâchée */
}
}
int main()
{
/* Initialisation de la fenêtre ... */
/* Enregistrement de nos fonctions de gestion des touches spéciales */
- 32 -
glutKeyboardFunc(&AppuiTouche);
glutSpecialUpFunc(&RelachementTouche);
/* Lancement de la boucle principale */

glutMainLoop();
}
Comment gérer la souris ?

Il y a trois fonctions pour la gestion de la souris :
void glutMouseFunc(void (*func)(int button, int state, int x, int y));

void glutMotionFunc(void (*func)(int x, int y));
void glutPassiveMotionFunc(void (*func)(int x, int y));
La fonction glutMouseFunc permet de savoir si un bouton de la souris a été appuyé. Le premier paramétre est lequel
des boutons a été appuyé, voici les possibilités :
#define GLUT_LEFT_BUTTON 0
#define GLUT_MIDDLE_BUTTON 1
#define GLUT_RIGHT_BUTTON 2
Ensuite l'état est le fait d'appuyer un bouton ou le relâcher. En effet, cette fonction est appelée deux fois pour un clic
souris (une fois pour l'appui du bouton et une fois pour le relâchement).
#define GLUT_DOWN 0
#define GLUT_UP 1
La fonction glutMotionFunc génère des événements lorsque la souris bouge et qu'un bouton est appuyé. Elle donnera
la nouvelle position de la souris mais, pour connaître quel bouton est appuyé, il faudra utiliser en même temps une
fonction callback définie par glutMouseFunc.
Enfin, la fonction glutPassiveMotionFunc permet de générer des évènements lorsque la souris bouge et lorsqu'aucun
bouton n'est appuyé. De nouveau, c'est la nouvelle position qui sera passée à la fonction callback.
void BoutonSouris(int button, int state, int x, int y)

{
/* Gestion du bouton appuyé "button" et éventuellement de la position du curseur "x, y" */
}
void MouvementSouris(int x, int y)

{
/* Gestion de la position du curseur "x, y" */
}
int main()
{
/* Enregistrement de notre fonction de gestion des boutons souris */

glutMouseFunc(&BoutonSouris);
- 33 -
/* Enregistrement de notre fonction de gestion des mouvements souris */
glutPassiveMotionFunc(&MouvementSouris);

glutMainLoop();
}
Comment gérer l'affichage ?

On utilise deux fonctions. Une pour l'affichage qui s'appelle glutDisplayFunc, et une autre pour le redimensionnement
de la fenêtre (et donc les changements à prendre en compte pour l'affichage), glutReshapeFunc.
void glutDisplayFunc(void (*func)(void)); void glutReshapeFunc(void (*func)(int width, int height));
Exemple :
void Affichage()
{
/* Affichage de la scène */
}
void Redimensionnement(int width, int height)

{
/* width et height sont les nouvelles dimensions de la fenêtre */
}
int main()
{
/* Enregistrement de notre fonction d'affichage */

glutDisplayFunc(&Affichage);
/* Enregistrement de notre fonction d'affichage */

glutReshapeFunc(&Redimensionnement);

glutMainLoop();
}
Comment savoir si la souris a quitté la fenêtre ?

Pour gérer les moments où la souris quitte la fenêtre ou revient dans celle-ci, on utilise la fonction suivante :
void glutEntryFunc(void (*func)(int state));
Et le paramètre state peut prendre les valeurs suivantes :
- 34 -
#define GLUT_LEFT 0
#define GLUT_ENTERED 1
Attention : certains systèmes d'exploitations ne gèrent pas correctement cette fonction.
Exemple :
void SourisFenetre(int state)

{
if (state == GLUT_ENTERED)
{
/* La souris vient d'entrer sur la fenêtre */
}
else
{
/* La souris vient de sortir de la fenêtre */
}
}
int main()
{
/* Enregistrement de notre fonction de gestion de la souris par rapport à la fenêtre */

glutEntryFunc(&SourisFenetre);

glutMainLoop();
}
Comment savoir si la fenêtre est visible ou non ?

Pour gérer le changement de visibilité de la fenêtre, on utilise la fonction suivante :
void glutWindowStatusFunc(void (*func)(int state));
Le paramètre state peut valoir :
/* Fenêtre entièrement cachée */

#define GLUT_HIDDEN 0
/* Fenêtre entièrement visible */

#define GLUT_FULLY_RETAINED 1
/* Fenêtre partiellement visible */

#define GLUT_PARTIALLY_RETAINED 2
/* Fenêtre entièrement cachée mais visible (la barre de la fenêtre) */
- 35 -
#define GLUT_FULLY_COVERED 3
Comment mettre en place un timer ?

Pour définir un timer, on utilise la fonction suivante :
void glutTimerFunc(unsigned int millis, void (*func)(int value), int value);
• millis représente le nombre de millisecondes avant que la fonction ne soit appelée

• value est la valeur passée à la fonction func lors de l'appel. Ceci permet d'avoir plusieurs temporisateurs qui
tournent en même temps
Exemple :
void FonctionTimer(int value)

{
switch (Value)
{
case 0 :
/* Le délai du premier timer est écoulé */
break;
case 1 :
/* Le délai du second timer est écoulé */
break;
}
}
int main()
{
/* Enregistrement de nos timers */

glutTimerFunc(10, &FonctionTimer, 0);
glutTimerFunc(50, &FonctionTimer, 1);

glutMainLoop();
}
Comment faire exécuter du code lorsque le processus ne fait rien ?

GLUT permet de gérer beaucoup de choses en même temps. Mais lorsque le gestionnaire n'a rien à faire, il permet
d'exécuter du code avec ce callback :
void glutIdleFunc(void (*func)(void));
- 36 -

Faq Ogl

Uploaded by

Document Information

Original Title

Copyright

Available Formats

Share this document

Share or Embed Document

Sharing Options

Did you find this document useful?

Is this content inappropriate?

Copyright:

Available Formats

Faq Ogl

Uploaded by

Copyright:

Available Formats

Cette FAQ est un condensé des questions les plus fréquemment posées sur les forums

de http://www.developpez.com, ainsi que de l'expérience des auteurs. Toutefois il se

Sur ce, l'équipe vous souhaite une bonne lecture !

Laurent Gomila - loka - shenron666 -

Ma question n'est pas traitée ici, que faire ?

Que signifie "portable" ?

Quels sont les intérêts d'utiliser OpenGL ?

Quel est le futur d'OpenGL ?

Plus d'informations sur OpenGL 2.0 sur le site officiel :

Où trouver des tutoriels pour OpenGL ?

Où trouver de la documentation de référence sur OpenGL ?

Le site officiel d'OpenGL est incontournable : http://www.opengl.org/.

La section "Documentation" propose entre autres :

Comment obtenir diverses informations comme le

const GLubyte * glGetString(GLenum name)

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

Pour obtenir la version d'OpenGL et du driver :

Pour obtenir l'ensemble des extensions disponibles :

Comment mettre à jour ma version d'OpenGL ?

lien : Tutoriels OpenGL utilisant AUX

Quelles bibliothèques utiliser avec OpenGL ?

Fenêtrage (permet la création de la fenêtre d'affichage et l'interfaçage avec le système)

Texte (permet de générer / afficher du texte, lire les fichier truetype)

Extensions (simplifie l'accès aux extensions OpenGL)

Son (encodage / décodage des sons, gestion des fichiers sonores)

Réseau (communication entre machines via différents protocoles)

Physique (gestion de la physique, de la détection des collisions, ...)

Quelle bibliothèque de fenêtrage utiliser ?

GLUT (GL Utility Toolkit) : http://www.xmission.com/~nate/glut.html. Voir Qu'est-ce que GLUT ?.

GLFW (GL FrameWork) : http://glfw.sourceforge.net/.

SDL (Simple Directmedia Layer) : http://www.libsdl.org/.

Quel langage utiliser pour développer avec OpenGL ?

Comment utiliser OpenGL avec les MFC ?

Comment utiliser OpenGL avec les langages .NET ?

Comment utiliser OpenGL dans une interface wxWidgets ?

Voir la documentation sur le wiki de wxWidgets :

Ainsi que la documentation de référence de la classe :

Comment utiliser OpenGL dans une interface Qt ?

Voir également ce tutoriel en français sur l'utilisation d'OpenGL avec Qt :

Comment savoir si une extension est supportée par mon hardware ?

// Récupération de la liste des extensions

// Recherche de l'extension qui nous intéresse : GL_ARB_texture_compression

Comment charger une fonction liée à une extension ?

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

// Normalement on a au préalable vérifié que l'extension correspondante était bien supportée,

Où puis-je trouver la derniere version de glext.h ?

Vous pouvez trouver la dernière version de glext.h sur le site de SGI.

function glext_LoadExtension(ext: String): Boolean;

Basiquement on peut trier les différentes méthodes comme ceci :

Comment mesurer les performances d'une application OpenGL ?

En pratique, il suffit de paramétrer correctement les matrices de transformation :

// On place la matrice de modelview à l'identité, mais rien n'empêche par la suite

Comment désactiver l'écriture dans le color buffer ?

2- Utiliser la fonction glColorMask :

glColorMask(GLboolean red, GLboolean green, GLboolean blue, GLboolean alpha);

Comment désactiver l'écriture dans le Z-buffer ?

/* Activer l'écriture dans le Z-buffer */

/* Désactiver l'écriture dans le Z-buffer */

Comment activer l'écriture dans le stencil buffer ?

/* Activer l'écriture et les tests de stencil */

/* Désactiver l'écriture et les tests de stencil */

Comment rendre une couleur transparente, par exemple sur un sprite ?

glTexImage2D(GL_TEXTURE_2D, 0, 4, largeur, hauteur, 0, GL_RGBA, GL_UNSIGNED_BYTE, pixels);