faq_ogl

Cette FAQ est un condensé des questions les plus fréquemment posées sur les forumsde http://www.developpez.com, ainsi que de l'expérience des auteurs. Toutefois il sepeut qu'une erreur se soit glissée dans celle-ci, ou qu'une information soit manquante ouplus à jour. Dans ce cas n'hésitez pas à nous contacter et à contribuer à l'enrichissementde cette FAQ.

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

http://www.developpez.com


Ont contribué à cette FAQ :

Laurent Gomila - loka - shenron666 -bafman - Zoso_ - Info-Rital - fearyourself -


http://www.developpez.net/forums/profile.php?mode=viewprofile&u=19000







- 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 sourcesconstitue une oeuvre intellectuelle protégée par les droits d'auteurs. Copyright © 2005 - 2006 Developpez LLC. Tout droits réservés Developpez LLC. Aucunereproduction, 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 DeveloppezLLC. 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/

1. Généralités (18) ......................................................................................................................................................................... 41.1. OpenGL et les autres langages / bibliothèques (8) .......................................................................................................... 8

2. Les extensions (4) ....................................................................................................................................................................123. Optimisations (3) ..................................................................................................................................................................... 154. Techniques (15) ....................................................................................................................................................................... 175. Problèmes (2) ...........................................................................................................................................................................276. GLU (1) ................................................................................................................................................................................... 287. GLUT (17) ............................................................................................................................................................................... 29





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 à samaintenance. Si vous avez remarqué une erreur, une simple faute d'orthographe, si vous souhaitez nous faire part d'unmanque, ou n'importe quoi d'autre : vous pouvez contacter le responsable par MP (loka), ou poster à la suite de cesujet 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 pouveznous 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 hautequalité. OpenGL est utilisé dans de nombreux domaines, aussi bien dans les moteurs de jeux vidéo (la série Quake estun 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 acteursdu marché (Compaq, Microsoft, SGI, IBM, 3DLabs, HP, Intel, Evans & Sutherland). C'est l'ARB qui contrôle donc lespropositions 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 sousun autre système.

• La portabilité au niveau du hardware : chaque vendeur de carte graphique pouvant ajouter ses propresextensions, il est tout à fait possible avec OpenGL de créer des programmes qui ne tournent que sur un typede carte graphique donné. De même, un programme tournant sur une génération de carte a peu de chances





http://www.developpez.net/forums/viewtopic.php?t=446150

http://www.developpez.net/forums/viewtopic.php?t=446150


http://jeux.developpez.com/faq/3d



http://www.sgi.com/





de tourner sur une génération plus ancienne si jamais elle utilise des extensions apportées par la nouvellegénération. Pour éviter les problèmes de portabilité entre cartes graphiques, il est donc conseillé de n'utiliserque les extensions ARB ou EXT (bien que les extensions EXT ne garantissent pas d'être presentes sur toute lescartes, 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 nouvellescartes graphiques. La technologie des shaders fera donc partie intégrante d'OpenGL 2.0 tout en restant compatibleavec 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'OpenGLdepuis 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 desexemples 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





http://opengl.org/documentation/opengl_current_version.html


http://glinfrench.apinc.org/rubrique.php3?id_rubrique=2

http://www.linuxgraphic.org/section3d/openGL/didact.html

http://www.g-truc.net/tuts.html

http://rlesavre.free.fr/index.php?go=projects.php

http://www-evasion.imag.fr/Membres/Fabrice.Neyret/doc/opengl.html

http://rvirtual.free.fr/programmation/opengl.htm



• 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 lemodè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)



http://delphipage.free.fr/opengl.html

http://jean-marault.developpez.com/glscene/

http://eraquila.developpez.com/opengl/

http://nehe.gamedev.net/

http://www.codesampler.com/oglsrc.htm

http://www.xmission.com/~nate/tutors.html

http://www.lighthouse3d.com/opengl/

http://developer.nvidia.com

http://www.ati.com/developer/index.html

http://www.humus.ca/index.php?page=3D

http://www.opengl.org/resources/tutorials/advanced/advanced98/notes/notes.html

http://www.paulsprojects.net/opengl/projects1.html

http://www.sulaco.co.za/opengl.htm


http://www.opengl.org/

http://opengl.org/documentation/spec.html

http://oss.sgi.com/projects/ogl-sample/registry/

http://opengl.org/documentation/oglsl.html

http://opengl.org/documentation/implementations.html

http://opengl.org/documentation/implementations.html




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 exempleaucune 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 ilsuffit de les charger dynamiquement via le système d'Comment charger une fonction liée à une extension ?.






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 desfonctions "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. CependantAUX 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èquede fenêtrage afin de pouvoir exploiter ses possibilités. Il est également possible d'utiliser les fonctions de base du systèmesur lequel on programme mais dans ce cas on pert la portabilité d'OpenGL. Voici donc une liste de bibliothèquesutilisables 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)




http://rvirtual.free.fr/programmation/OpenGl/GLUT_et_AUX.htm


http://www.newimage.com/~rhk/SDL_gui/

http://glgooey.sourceforge.net/

http://www.cs.unc.edu/~rademach/glui/

http://www.libsdl.org/projects/SDL_ttf/

http://www.freetype.org/

http://openil.sourceforge.net/

http://www.libsdl.org/projects/SDL_image/

http://glew.sourceforge.net/



• 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'utilisationd'une bibliothèque permet de conserver la portabilité qui fait la force d'OpenGL. Pour cela, il existe plusieursbibliothè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 fonctionssupplé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 lespossibilités offertes par la bibliothèque, et outre la création de la fenêtre de rendu, le programmeur aura accès à lagestion 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 "UnrealTournament" 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.



http://www.openal.org/

http://www.libsdl.org/projects/SDL_mixer/

http://icculus.org/SDL_sound/

http://www.libsdl.org/projects/SDL_net/

http://www.hawksoft.com/hawknl/

http://www.tokamakphysics.com/

http://ode.org/

http://novodex.com/


http://www.xmission.com/~nate/glut.html

http://freeglut.sourceforge.net/

http://openglut.sourceforge.net/

http://glfw.sourceforge.net/

http://www.libsdl.org/



La bibliothèque SDL est tout aussi facile à programmer, stable et performante, elle a tout pour satisfaire les besoins ausein de gros projets. Elle a non seulement fait ses preuves avec des adaptations de jeux commerciaux, mais qui plus estelle 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 siteofficiel 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 deNeHe, 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 (MicrosoftFoundation 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.







http://msdn.microsoft.com/library/default.asp?url=/library/en-us/dnopen/html/msdn_gl1.asp

http://home.planet.nl/~monstrous/tutMFC.html

http://www.kencocomputers.com/tutorials/

http://www.codeguru.com/cpp/g-m/opengl/openfaq/article.php/c10975/

http://nehe.gamedev.net/counter.asp?file=files/basecode/nehegl_mfc.zip

http://support.microsoft.com/kb/q127071/

http://freddec.free.fr/tutoriel.php?omfc?00

http://gritche.chez-alice.fr/OpenGL/


http://www.mono-project.com/Tao



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 simpled'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 unescène OpenGL à votre interface : QGLWidget.

Pour une utilisation plus poussée, Qt fournit également d'autres classes en relation avec OpenGL dans son moduleQGL. 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.



http://csgl.sourceforge.net/

http://www.labo-dotnet.com/Articles/Csharp/Programmer%20OpenGL%20en%20CSharp/104.aspx


http://www.wxwidgets.org/wiki/index.php/WxGLCanvas

http://www.wxwidgets.org/manuals/2.6.3/wx_wxglcanvas.html


http://doc.trolltech.com/4.4/qglwidget.html

http://doc.trolltech.com/4.1/qtopengl.html

http://doc.trolltech.com/4.1/qtopengl.html

http://www.digitalfanatics.org/projects/qt_tutorial/fr/chapter14.html



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 standardisationd'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é soitintégrée au coeur d'OpenGL.

Afin de pouvoir exploiter sans attendre les nouvelles fonctionnalités du hardware, OpenGL inclut un mécanismed'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 utiliserest bien supportée par votre système (voir Comment savoir si une extension est supportée par mon hardware ?), puischarger 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 surd'autres types de cartes. Par exemple, celles dont le nom commence par "NV" sont spécifiques aux cartes nVidia, etcelles commençant par "ATI" ne concernent que les cartes ATI. Les extensions "ARB" par contre, ont été officialiséespar l'ARB à partir d'une certaine version d'OpenGL, et tout hardware compatible avec cette version devrait enthéorie supporter ces extensions (par exemple, toutes les cartes compatibles OpenGL 1.5 supportent l'extensionARB_fragment_program). Pour finir il y a également les extensions "EXT", qui sont à peu près officielles mais n'ontpas 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 fonctionglGetString appelée avec l'option GL_EXTENSIONS. La liste retournée est une chaîne de caractère, dans laquelle lesextensions 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 lesspé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 extensionsstd::string Extensions = reinterpret_cast<const char*>(glGetString(GL_EXTENSIONS));

// Recherche de l'extension qui nous intéresse : GL_ARB_texture_compressionif (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




http://glew.sourceforge.net




}

Comment charger une fonction liée à une extension ?


OpenGL fournit une fonction pour charger dynamiquement une fonction : wglGetProcAddress sous Windows, etglxGetProcAdress sous Unix. Celle-ci prend en paramètre le nom de la fonction sous forme de chaîne de caractère, etrenvoie 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éressePFNGLBINDBUFFERARBPROC glBindBufferARB;

// Chargement de la fonctionglBindBufferARB = (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 fonctionif (glBindBufferARB == NULL){ // Erreur : fonction non chargée}

// UtilisationglBindBufferARB(0);

Toutes les définitions de types et de constantes relatives aux extensions se trouvent dans le fichier glext.h, il vaut doncmieux avoir une version à jour si vous souhaitez utiliser des extensions récentes (voir Où puis-je trouver la derniereversion 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èreversion 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 utilisationest très simple, puisqu'une seule fonction est nécessaire pour charger les fonctions associées à une extension.

function glext_LoadExtension(ext: String): Boolean;




http://glew.sourceforge.net/



http://oss.sgi.com/projects/ogl-sample/sdk.html

http://www.delphi3d.net/dot/

http://www.delphi3d.net/dot/GLunits.htm



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éantles fonctions associées.





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 ; toutdépend de ce que vous voulez lui faire faire exactement. Un moteur 3D destiné à rendre des scène en interieur s'orienteraplutot vers des optimisations du type portal + PVS, alors qu'un moteur créé pour rendre des exterieurs aura plutôttendance à 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 pourafficher, mais bien d'utiliser des algorithmes appropriés pour ce que l'on veut effectuer. Néanmoins d'un point de vuestrictement OpenGL, il existe quelques "bonnes techniques" à utiliser pour ne pas se retrouver limité par des erreursde 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 resteraactif durant tous les instants suivants, à moins de désactiver cet état. Ceci implique pour le programmeur de bien savoirquels é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 exactementde la même manière que si le blending était désactivé), ce qui signifie que le pipeline OpenGL calcule une opération deblending 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 commandesOpenGL (voir qu'est ce que le batching faq 3D). En effet, les listes d'affichage peuvent contenir presque tout type decommandes 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 lesite de nVidia section "développeurs", qui contient notament un document décrivant les principales erreurs à éviter enOpenGL : 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 desdrivers. 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 passed'optimisation lors de la compilation qui du coup fait perdre du temps. De même, utiliser une display liste pour un objettrè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'affichagedu même objet avec glVertex.




http://developer.nvidia.com/object/Avoiding_Common_ogl_Pitfalls.html




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 parseconde). Le principe est de mesurer à l'aide de compteur très précis (QueryPerformanceCounter sous Windows) laduré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"




http://www.fraps.com

http://www.opengl.org/resources/benchmarks

http://www.hawksoft.com/gltrace/



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 durendu 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'échelleglMatrixMode(GL_MODELVIEW);glLoadIdentity();

// On définit une matrice orthogonale pour la perspective, ce qui permettra d'avoir une vue 2D et non en perspectiveglMatrixMode(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 lieude 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 shadowvolumes).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 fragmentssont 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 encontinuant à é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 */








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 transparentsaient 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 formatde l'image source contient un canal alpha (GL_RGBA), et que la texture doit également en contenir un (nombre decomposantes é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, vouspouvez 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. Commeexpliqué 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 */





http://jeux.developpez.com/faq/3d/?page=techniques#TECHNIQUES_tex_trou



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 plusce 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 faudrapasser 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 decharger 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, ilest très facile à manipuler ; il est également prévu pour pouvoir stocker n'importe quelle information utilisable parOpenGL.

Sa page officielle fournit les spécifications du format, des exemples, des liens, des modèles, et même un convertisseur3DS -> XGL.

A noter que la distribution de GLUT contient un code source permettant de charger les fichiers au format OBJ (voirprogs/demos/smooth/glm.c).

La seconde solution est d'utiliser un programme permettant de convertir un modèle directement en code C, contenantles appels OpenGL permettant de construire et d'afficher le modèle. Cette alternative est toutefois déconseillée dans lesens 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.





http://www.wotsit.org/

http://www.gametutorials.com/gtstore/c-1-test-cat.aspx

http://www.xglspec.org/

http://www.okino.com/conv/conv.htm

http://www.clubic.com/telecharger-fiche10492-3d-exploration.html



Enfin, pour les plus courageux, il est bien sûr possible de concevoir un format de modèles perso. Deux solutions pourcré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 Quelformat 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'autresfonctionnalités d'OpenGL pour l'affichage de polices, comme l'affichage de bitmaps ou de pixmaps, la création detexture 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 deglBitmap() 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, unappel à 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 parrapport à un carré texturé. Utilisez dans ces cas là cette solution. L'idée est de créer une texture qui contient tous lescaractè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 aussijouer 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 applicablesdans de nombreux contextes (langages, plateformes, OS..). Cependant, si le résultat obtenu ne vous convient pas (si voussouhaitez avoir des polices 3D etc..), il existe des solutions plus techniques. Cependant la plupart de ces solutions sontpropres à 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 pouvezcependant 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 faciliteragrandement 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



http://jeux.developpez.com/faq/3d/?page=techniques#TECHNIQUES_format_modele

http://jeux.developpez.com/faq/3d/?page=techniques#TECHNIQUES_format_modele


http://plib.sourceforge.net/fnt/index.html

http://gltt.sourceforge.net/

http://oglft.sourceforge.net/

http://nehe.gamedev.net/data/lessons/lesson.asp?lesson=13






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 unescè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-textureafin 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 quel'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 :



http://www.levp.de/3d/




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 */ glTexCoord2f(0.5f, 1.0f); glVertex3f( 1.0f, 1.0f, 0.0f); /* coin haut-droit */ glTexCoord2f(0.5f, 0.5f); glVertex3f( 1.0f, -1.0f, 0.0f); /* coin bas-droit */ glTexCoord2f(0.0f, 0.5f); 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 lesarguments de glTexCoord2f changent également... C'est là où avoir un gestionnaire de texture est pratique. Il suffitd'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 pourcela 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 estdonné 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;



http://loulou.developpez.com/tutoriels/moteur3d/partie4/



} 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 écritesen 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); glVertex3f(-1.0f, 1.0f, 0.0f); /* coin haut-gauche */ glTexCoord2f(droite, haut); glVertex3f( 1.0f, 1.0f, 0.0f); /* coin haut-droit */ glTexCoord2f(droite,bas); glVertex3f( 1.0f, -1.0f, 0.0f); /* coin bas-droit */ glTexCoord2f(gauche, bas); glVertex3f(-1.0f, -1.0f, 0.0f); /* coin bas-gauche */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); glVertex3f(-1.0f, 1.0f, 0.0f); /* coin haut-gauche */ glTexCoord2f(droite, haut); glVertex3f( 1.0f, 1.0f, 0.0f); /* coin haut-droit */ glTexCoord2f(droite,bas); glVertex3f( 1.0f, -1.0f, 0.0f); /* coin bas-droit */ glTexCoord2f(gauche, bas); glVertex3f(-1.0f, -1.0f, 0.0f); /* coin bas-gauche */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 estde laisser le gestionnaire le faire. Nous lui demandons de le faire, et il pourra vérifier si la sous-texture que nous voulonsest 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.





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 leprogramme.

La première solution est de prendre votre programme de dessin favori, ouvrir les deux textures qui vous intéresse etles 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 enmé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. Ceciest 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 depasser 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 unequelconque 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 contexted'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-screenrendering.

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 faututiliser ce que l'on appelle le picking. Il existe plusieurs méthodes pour réaliser du picking.





http://www.mesa3d.org/brianp/sig97/offscrn.htm

http://www.mesa3d.org/brianp/sig97/offscrn.htm




Habituellement, on utilise le mode de rendu GL_SELECT fourni par OpenGL, qui permet d'identifier instantanémentquel 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 ilsuffit 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 cerayon et les objets de la scène afin de déterminer lequel se trouve sous le pointeur. La fonction gluUnproject permetde 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'identifiantde 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èmed'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 modifiantlégèrement la position de la caméra. Bien que moins contraignante d'un point de vue structure de données, cette méthodeest aussi à éviter car elle est très consommatrice de ressources (plusieurs rendus pour une même scène...).



http://www.lighthouse3d.com/opengl/picking/

http://devernay.free.fr/cours/opengl/makeslide/selection/overview.htm






la dernière méthode, utilisée dans les jeux vidéo, consiste à utiliser le Comment activer le multi-sampling ? qui permetd'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.



http://jeux.developpez.com/faq/3d/?page=definitions#DEFINITIONS_antialiasing





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 modeMODULATE, 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 quoil'é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 .libcorrespondant aux bibliothèques GL que vous utilisez (opengl32.lib pour OpenGL, glu32.lib pour GLU, et glut32.libpour GLUT). Vous pouvez également lier en ajoutant la directive #pragma comment(lib, "xxx.lib") dans l'un de vosfichiers 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 ajouterdirectement à 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 estcré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é !







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 conceptionque 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érerdes coordonnées de texture, de dessiner des surfaces quadriques et des NURBS, de faire appel à un tesselator, et biend'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 denouvelles fonctionnalités correspondant aux capacités d'OpenGL version 1.2.






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. (voiraussi 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". Attentiontoutefois à 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é parexemple), 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 nepossèdent pas de coordonnées de textures, ainsi il est impossible de les texturer correctement.






ftp://ftp.sgi.com/sgi/opengl/glut/index.html


http://freeglut.sourceforge.net/


http://msdn.microsoft.com/library/en-us/winui/winui/windowsuserinterface/windowing/windows/windowreference/windowfunctions/winmain.asp




Il n'y a aucun moyen de forcer GLUT à ajouter des coordonnées de texture, ainsi il vaudra mieux passer par les fonctionsde GLU pour générer ces formes (gluCylinder, gluSphere, ...). Leur génération est toutefois plus compliquée, puisqu'ilfaut 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 avecGL_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 votreprogramme 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 pastoute 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){









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 avecglutBitmapCharacter ?.

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)#define GLUT_BITMAP_HELVETICA_12 ((void*)7)#define GLUT_BITMAP_HELVETICA_18 ((void*)8)

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 peututiliser 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 lagestion d'un évènement est nécessaire.








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 - F12sont 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 */






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 lequeldes 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 clicsouris (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 donnerala nouvelle position de la souris mais, pour connaître quel bouton est appuyé, il faudra utiliser en même temps unefonction callback définie par glutMouseFunc.

Enfin, la fonction glutPassiveMotionFunc permet de générer des évènements lorsque la souris bouge et lorsqu'aucunbouton 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(){ /* Initialisation de la fenêtre ... */ /* Enregistrement de notre fonction de gestion des boutons souris */ glutMouseFunc(&BoutonSouris);






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



Comment gérer l'affichage ?


On utilise deux fonctions. Une pour l'affichage qui s'appelle glutDisplayFunc, et une autre pour le redimensionnementde 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(){ /* Initialisation de la fenêtre ... */ /* Enregistrement de notre fonction d'affichage */ glutDisplayFunc(&Affichage);

/* Enregistrement de notre fonction d'affichage */ glutReshapeFunc(&Redimensionnement);



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 :







#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(){ /* Initialisation de la fenêtre ... */ /* Enregistrement de notre fonction de gestion de la souris par rapport à la fenêtre */ glutEntryFunc(&SourisFenetre);



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) */






#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(){ /* Initialisation de la fenêtre ... */ /* Enregistrement de nos timers */ glutTimerFunc(10, &FonctionTimer, 0); glutTimerFunc(50, &FonctionTimer, 1);



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 permetd'exécuter du code avec ce callback :

void glutIdleFunc(void (*func)(void));





Documents

faq_ogl