Eric Bittard Cours OpenGL

Open GL
Cours composé par Eric Bittar, d'après le livre The OpenGL Programming Guide Mason Woo, OpenGL
Architectural Review Board, Jackie Neider, Tom Davis, Dave Shreiner. ISBN 0201604582
1
I. Présentation générale .............................................................................................................................................................2
Pipe-Line de Rendu simplifié ..........................................................................................................................................................2
Les Bibliothèques co-existant avec OpenGL ..................................................................................................................................2
Utilisation de GLUT........................................................................................................................................................................2
Les primitives géométriques............................................................................................................................................................3
Les couleurs.....................................................................................................................................................................................4
Le vecteur normal en un point.........................................................................................................................................................4
Le modèle d'ombrage ......................................................................................................................................................................4

II. Vision.....................................................................................................................................................................................5
Principe de la vision ........................................................................................................................................................................5
La transformation de modélisation ..................................................................................................................................................5
La transformation de vision.............................................................................................................................................................6
La transformation de projection ......................................................................................................................................................7
La transformation du viewport ........................................................................................................................................................7
Compréhension par l'exemple .........................................................................................................................................................8
Exercice...........................................................................................................................................................................................8
Modélisation hiérarchique ...............................................................................................................................................................9
Description hiérarchique d'une scène ..............................................................................................................................................9
Pile de transformations ..................................................................................................................................................................10
Manipulation des matrices de transformation................................................................................................................................10
Exercices .......................................................................................................................................................................................10

III. Eclairage ..............................................................................................................................................................................11

Modèle d'éclairage OpenGL..........................................................................................................................................................11
Les lampes.....................................................................................................................................................................................12
Couleur d'un matériau ...................................................................................................................................................................13
Exercice 1......................................................................................................................................................................................14
Elimination des surfaces cachées ..................................................................................................................................................14
Listes d'affichage...........................................................................................................................................................................15
Quadriques ....................................................................................................................................................................................15

IV. Textures ...............................................................................................................................................................................16

Introduction ...................................................................................................................................................................................16
Les coordonnées de texture ...........................................................................................................................................................16
Les Objets-Textures ......................................................................................................................................................................17
Filtrage ..........................................................................................................................................................................................18
Les niveaux de détail.....................................................................................................................................................................18
Lecture d'une image de texture dans un fichier .............................................................................................................................19
Exercice.........................................................................................................................................................................................19

27/09/03 Page 1/19

Eric Bittard Cours OpenGL

I. Présentation générale
OpenGL est un système graphique qui permet de visualiser une scène 3D (et aussi 2D). Les objets de cette
scène peuvent être composés de points, de lignes, de polygones, de quadriques, de nurbs. Ils possèdent des
attributs graphiques : paramètres de réflexion, couleur, texture. L'éclairage de la scène est réalisé par des
lumières de différents types (spot, lumière à l'infini).
La bibliothèque OpenGL a été crée par Silicon Graphics et bénéficie sur ces machines de l'accélération
matérielle. On trouve de plus en plus de cartes 3D grand public qui implémentent les instructions OpenGL.
Une implémentation logicielle libre de droits d'OpenGL très performante a été écrite par Brian Paul : Mesa.
C'est cette implémentation que nous utiliserons. Elle a l'avantage d'utiliser l'accélération des cartes
graphiques 3dfx sous Linux.

Pipe-Line de Rendu simplifié

[Données]-[Evaluateurs]-[Opérations sur les sommets et assemblage de primitives]-[Discrétisation]-
[Opérations sur les fragments]-[Image]
• Les Evaluateurs produisent une description des objets à l'aide de sommets et de facettes.
• Les Opérations sur les sommets sont les transformations spatiales (rotations et translations) qui sont
appliquées aux sommets. Nous les décrirons ultérieurement en détail.
• L' assemblage de primitive regroupe les opérations de clipping : élimination des primitives qui sont
en dehors d'un certain espace et de transformation perspective .
• La discrétisation (Rasterization) est la transformation des primitives géométriques en fragments
correspondant aux pixels de l'image.
• Les Opérations sur les fragments vont calculer chaque pixel de l'image en combinants les fragments
qui se trouvent à l'emplacement du pixel. On trouve entre autres la gestion de la transparence, et le Z-
buffer (pour l'élimination des surfaces cachées).

Les Bibliothèques co-existant avec OpenGL

• GLU : OpenGL Utility Library contient les routines de bas niveau pour gérer les matrices de
transformation et de projection, la facettisation des polygones et le rendu de surface.
• Les bibliothèques d'extension du système de fenêtres permettent l'utilisation du rendu OpenGL. Il
s'agit de GLX pour X Windows (fonctions ayant pour préfixe glX) et de WGL pour Microsoft
Windows (fonctions ayant pour préfixe wgl).
• GLUT : OpenGL Utility Toolkit est une boite à outils indépendante du système de fenêtrage, écrite
par Mark Kilgard pour simplifier la tâche d'utiliser des systèmes différents (fonctions ayant pour
préfixe glut).

Utilisation de GLUT
Pour la compilation, copiez le Makefile et tapez make lin
• Examinez et compilez le programme hello.c Comprenez l'utilité des différentes procédures.
• faites de même pour double.c.
Les fonctions de gestion d'une fenêtre
• glutInit(int * argc, char **argv) initialise GLUT et traite les arguments de la ligne de commande.

27/09/03 Page 2/19

Eric Bittard Cours OpenGL

• glutInitDisplayMode(unsigned int mode) permet de choisir entre couleurs RVB et couleurs

indexées, et de déclarer les buffers utilisés.
• glutInitWindowPosition(int x, int y) spécifie la localisation dans l'écran du coin haut gauche de la
fenêtre.
• glutInitWindowSize(ind width, int size) spécifie la taille en pixels de la fenêtre.
• int glutCreateWindow(char * string) crée une fenêtre contenant un contexte OpenGL et renvoie
l'identificateur de la fenêtre. La fenêtre ne sera affichée que lors du premier glutMainLoop()
La fonction d'affichage
• glutDisplayFunc(void (*func)(void)) spécifie la fonction à appeler pour l'affichage
• glutPostRedisplay(void) permet de forcer le réaffichage de la fenêtre.
Lancement de la boucle d'événements
1. Attente d'un événement
2. Traitement de l'événement reçu
3. Retour en 1.
• glutMainLoop(void) lance la boucle principale qui tourne pendant tout le programme, attend et
appelle les fonctions spécifiques pour traiter les événements.
Traitement des événements
• glutReshapeFunc(void (*func)(int w, int h)) spécifie la fonction à appeler lorsque la fenêtre est
retaillée.
• glutKeyboardFunc(void (*func)(unsigned char key, int x, int y)) spécifie la fonction à appeler
lorsqu'une touche est pressée
• glutMouseFunc(void (*func)(int button, int state, int x, int y)) spécifie la fonction à appeler
lorsqu'un bouton de la souris est pressé.
• glutMotionFunc(void (*func)(int x, int y)) spécifie la fonction à appeler lorsque la souris est
déplacée tout en gardant un bouton appuyé.
Exécution en tâche de fond
• glutIdleFunc(void (*func)(void)) spécifie la fonction à appeler lorsqu'il n'y a pas d'autre événement.
Dessin d'objets Tridimensionnels
GLUT possède des routines pour afficher les objets suivants :
cone cube tetraèdre octaèdre icosaèdre dodécaèdre sphère tore théière0
Animation
Une animation peut se réaliser simplement en utilisant la technique du double buffer : montrer à l'écran
une image correspondant à une première zone mémoire (buffer) et dessiner les objets dans une deuxième
zone mémoire qui n'est pas encore à l'écran, et qui sera affiché lorsque la scène entière y sera calculée, et
à une fréquence régulière. L'échange des buffers peut se faire par la commande glutSwapBuffers(void).

Les primitives géométriques

Déclaration
• glBegin(GLenum mode) ouvre la déclaration des sommets de la primitive
• glEnd(void) termine cette déclaration
• Il y a dix types de primitives différents, qui correspondent à des points, des lignes, des triangles, des
quadrilatères, et des polygones convexes.
27/09/03 Page 3/19
Eric Bittard Cours OpenGL

Les couleurs
La couleur d'un objet est spécifiée par l'appel à glColor(...).

Le vecteur normal en un point

Un vecteur normal (aussi appelé normale ) à une surface en un point de cette surface est un vecteur dont la
direction est perpendiculaire à la surface.
Pour une surface plane, les vecteurs normaux en tous points de la surface ont la même direction. Ce n'est pas
le cas pour une surface quelconque.
C'est grâce au vecteur normal que l'on peut spécifier l'orientation de la surface dans l'espace, et en particulier
l'orientation par rapport aux sources de lumière. L'appel à glNormal*() donne une valeur à la normale
courante. Elle sera associée aux points spécifiés par les appels suivants à glVertex*().

Le modèle d'ombrage
Chaque facette d'un objet peut être affichée d'une unique couleur (ombrage plat) ou à l'aide de plusieurs
couleurs (ombrage lissé). OpenGL implémente une technique de lissage appelée Ombrage de Gouraud. Ce
choix s'effectue avec glShadeModel(GLenum mode).
Compilez scene.c et exécutez le programme obtenu. Changez de mode de rendu avec les touches 's' et 'S'.

27/09/03 Page 4/19

Eric Bittard Cours OpenGL

II. Vision
Principe de la vision
Le processus de transformation qui produit une image à partir d'un modèle de scène 3D est analogue à celui
qui permet d'obtenir une photographie d'une scène réelle à l'aide d'un appareil photo. Il comprend quatre
étapes :
Avec un appareil photo Avec un ordinateur type de transformation
1 Positionner l'appareil photo Placer la caméra virtuelle transformation de vision
Arranger les éléments d'une scène à Composer une scène virtuelle à
2 transformation de modélisation
photographier représenter
3 Choisir la focale de l'appareil photo choisir une projection transformation de projection
Choisir la taille de la photographie au choisir les caractéristiques de
4 transformation du viewport
développement l'image

[Matrice de
[Matrice de [Division [Transformation
[Sommets] - Modélisation- - - - -
Projection] perspective] du viewport]
Vision]
Coordonnées

Coordonnées

Coordonnées

Coordonnées
de la fenêtre
normalisées
de clipping
de l'oeil

La transformation de modélisation
La manipulation d'objets 3D peut mener à des réflexions complexes pour bien positionner et orienter les
objets. En effet, l'application successive d'une translation puis d'une rotation, ou l'inverse mènent à des
résultats différents.

Pour s'y retrouver, il suffit de se dire que la transformation est appliquée au repère local de l'objet.

27/09/03 Page 5/19

Eric Bittard Cours OpenGL

glTranslate*(TYPE x, TYPE glRotate*(TYPE angle, TYPE glScale*(TYPE a, TYPE b, TYPE c)

y, TYPE z) translate le repère x, TYPE y, TYPE z) opère une opère un changement d'échelle sur 3 axes.
local de l'objet du vecteur rotation de l'objet autour du Les coordonnées en x sont multipliées par
(x,y,z). vecteur (x,y,z). a, en y par b et en z par c.

glRotatef(45.0 , 0.0 , 0.0 , 1.0) glScalef(2.0 , -0.5 , 1.0)

La transformation de vision
Elle modifie la position et l'orientation de la caméra virtuelle.
La position par défaut de la caméra est à l'origine du repère de la scène, orientée vers les z négatifs, et la
verticale de la caméra est alignée avec l'axe des y positifs :

En fait, ce qui compte pour la visualisation est la position relative de la caméra par rapport aux objets. Il est
équivalent par exemple de translater la caméra d'un vecteur T ou de translater tous les objets du vecteur -T.
On utilise ainsi les procédures OpenGL de translation et de rotation appliquées aux objets, glTranslate*() et
glRotate*() pour changer le point de vue de la caméra.
On peut également utiliser (et c'est plus simple pour commencer ) la procédure gluLookAt(GLdouble
eyex,GLdouble eyey, GLdouble eyez, GLdouble centerx,GLdouble centery,GLdouble centerz, GLdouble
upx, GLdouble upy, GLdouble upz ).

27/09/03 Page 6/19

Eric Bittard Cours OpenGL

La transformation de projection
N'oubliez pas d'abord d'écrire glMatrixMode(GL_PROJECTION);glLoadIdentity(); avant les commandes
de transformation.
Projection perspective
• glFrustum() ou gluPerspective() peuvent être utilisées.

glFrustum( GLdouble left,GLdouble right, GLdouble bottom,GLdouble top, GLdouble near,

GLdouble far ) définit le volume visible sous la forme d'une pyramide tronquée.
Les coins bas-gauche et haut-droite du plan de clipping proche ont pour coordonnées respectives
(left, bottom, -near) et (right, top, -near). near et far indiquent la distance de la caméra aux plans
proches et lointain, ils doivent être positifs.

Projection orthographique
• glOrtho() sera utilisée.

Clipping
• Les 6 plans de définition du volume de vision sont des plans de clipping : toutes les primitives qui se
trouvent en dehors de ce volume sont supprimées.

La transformation du viewport
• glViewport(GLint x, GLint y, GLint largeur, GLint hauteur) sera utilisée pour définir une zone
rectangulaire de pixels dans la fenêtre dans laquelle l'image finale sera affichée. Par défaut, les
valeurs initiales du viewport sont (0,0, largeurFenêtre, hauteurFenêtre)

27/09/03 Page 7/19

Eric Bittard Cours OpenGL

Compréhension par l'exemple

Examinez le programme cube.c. Modifiez dans le fichier Makefile la ligne commençant par PROGS = en
PROGS = cube . Compilez le programme.
La transformation de vision
• glLoadIdentity() donne à la Matrice courante la valeur identité. En effet, les opérations de
transformation multiplient la matrice courante par leur matrice de transformation associée, alors
autant partir du bon pied.
• gluLookAt() spécifie la matrice de vision, en positionnant l'œil de la caméra virtuelle, le point visé,
et la direction du vecteur verticale de la caméra (ce qui détermine l'orientation de celle-ci).
La transformation de modélisation
• Le modèle est positionné ou orienté, ou encore mis à l'échelle si nécessaire, ou toute combinaison de
ces opérations. Dans l'exemple cube.c, le cube est mis à l'échelle par glScalef().
glLoadIdentity() donne à la Matrice courante la valeur identité. En effet, les opérations de
transformation multiplient la matrice courante par leur matrice de transformation associée, alors
autant partir du bon pied.
• gluLookAt() spécifie la matrice de vision, en positionnant l'oeil de la caméra virtuelle, le point visé,
et la direction du vecteur verticale de la caméra (ce qui détermine l'orientation de celle-ci).
Exercice
• Positionnez la caméra en (0,0,10) et visionnez le cube.
• Comment peut-on obtenir la même image en laissant la caméra en (0,0,5) ?
La transformation de projection
• Elle comprend le choix du champ de vision (comme sur un appareil photo on peut adapter un grand
angle, un objectif normal ou un téléobjectif).
• Elle comprend également le choix du type de projection : perspective ou orthographique.
• La projection perspective fait apparaître les objets lointains plus petits que ceux qui sont
proches. Dans l'exemple, elle est spécifiée par glFrustum().
• La projection orthographique n'affecte pas la taille relative des objets.
Exercice
• Remplacez glFrustum() par gluPerspective() avec les paramètres (60.0,1.0,1.5,20.0).
• Expérimentez différentes valeurs des paramètres de la projection. En particulier fovy et aspect.
La transformation du viewport
• glViewport() spécifie la taille et la position de l'image sur l'écran de l'ordinateur.
•

Exercice
• Créez une image d'une scène comprenant une sphère rouge de rayon unité en (2,0,0),
(glutSolidSphere(GLdouble radius, GLint slices, GLint stacks)), un cube bleu d'arête 2, tourné de
20° autour de l'axe x du repère de toute la scène, positionné en (0,3,0), et un cube jaune tourné de -
20° autour de l'axe z du repère de la scène, positionné en (3,3,3) (glutSolidCube(GLdouble size).
Positionnez la caméra de manière à voir l'ensemble des objets.
• Quelle difficulté éprouvez-vous ?

27/09/03 Page 8/19

Eric Bittard Cours OpenGL

Modélisation hiérarchique
Description hiérarchique d'une scène
Définition
• Un modèle hiérarchique permet de décrire facilement des objets complexes composés d'objets
simples. La scène est organisée dans un arbre tel que les objets ne sont plus définis par leur
transformation absolue par rapport au repère de toute la scène, mais par leur transformation relative
dans cet arbre.
• Comme un même objet peut être inclus plusieurs fois dans la hiérarchie, la structure de données est
un Graphe Orienté Acyclique (DAG)
• A chaque noeud est associé un repère. Le repère associé à la racine est le repère de la scène.
• A chaque arc est associé une transformation géométrique qui positionne l'objet fils dans le repère de
son père.
Construction
La structure hiérarchique du modèle peut être induite par :
• Un processus de construction ascendant ("bottom-up")
dans lequel les composants de base (primitives géométriques) sont utilisés comme des blocs
de construction et assemblés pour créer des entitées de niveau plus élevé, et ainsi de suite.
• Un processus de construction descendant ("top-down")
Dans lequel on effectue une décomposition récursive d'un modèle géométrique en objets plus
simples jusqu'à aboutir à des objets élémentaires (primitives géométriques)
Exemple

27/09/03 Page 9/19

Eric Bittard Cours OpenGL

Pile de transformations
OpenGL utilise les coordonnées homogènes pour manipuler ses objets (cf Cours de Math). Il maintient trois
matrices 4x4 distinctes pour contenir les différentes transformations.
Pour coder l'arbre de description de la scène, il faut utiliser la pile de transformation, en empilant la matrice
de transformation courante (sauvegarde des caractéristiques du repère local associé) avant de descendre dans
chaque noeud de l'arbre, et en dépilant la matrice en remontant (récupération du repère local associé).
• glPushMatrix() Empile la matrice courante pour sauvegarder la transformation courante.
• glPopMatrix() Dépile la matrice courante (La matrice du haut de la pile est supprimée de la pile, et
elle devient la matrice courante)

Manipulation des matrices de transformation

• glMatrixMode(GLenum mode) spécifie quelle matrice sera affectée par les commandes suivantes de
manipulation de transformations : la matrice de modélisation-vision, de projection ou de texture.
• glLoadIdentity() donne à la Matrice courante la valeur identité. (comme déjà indiqué)
• glLoadMatrix*(const TYPE * m) donne à la Matrice courante la valeur de la matrice m.
• glMultMatrix*(const TYPE * m) multiplie la Matrice courante par la matrice m.

Exercices
• Copiez le programme robot.c et compilez-le chez vous.
• Faites le dessin du graphe de la scène avec toutes les transformations.
• Faites un schéma du bras du robot en indiquant les repères locaux de l'épaule (shoulder) et du
coude (elbow)
• Modifiez la scène en ajoutant deux doigts (en opposition) au bras du robot, chaque doigt étant
composé de deux segments. Faites le dessin du nouveau graphe, et le schéma du bras
complet.
• Modifiez le programme en conséquent. Chaque élément doit être mobile de manière
indépendante et doit être animable par l'utilisateur au travers du clavier.
Ajoutez un degré de rotation du poignet : suivant l'axe du bras.

27/09/03 Page 10/19

Eric Bittard Cours OpenGL

III. Eclairage
Modèle d'éclairage OpenGL
La perception de la couleur de la surface d'un objet du monde réel dépend de la distribution de l'énergie
des photons qui partent de cette surface et qui arrivent aux cellules de la rétine de l'œil. Chaque objet
réagit à la lumière en fonction des propriétés matérielles de sa surface.
Le modèle d'éclairage d'OpenGL considère qu'un objet peut émettre une lumière propre, renvoyer dans
toutes les directions la lumière qu'il reçoit, ou réfléchir une partie de la lumière dans une direction
particulière, comme un miroir ou une surface brillante.
Les lampes, elles, vont envoyer une lumière dont les caractéristiques seront décrites par leurs trois
composantes : ambiante, diffuse ou spéculaire.
OpenGL distingue quatre types de lumières :
Lumière émise
Ne concerne que les objets
Les objets peuvent émettre une lumière propre, qui augmentera leur intensité, mais n'affectera pas les
autres objets de la scène.
Lumière ambiante
Concerne les objets et les lampes
C'est la lumière qui a tellement été dispersée et renvoyée par l'environnement qu'il est impossible de
déterminer la direction d'où elle émane. Elle semble venir de toutes les directions. Quand une lumière
ambiante rencontre une surface, elle est renvoyée dans toutes les directions.
Lumière diffuse
Concerne les objets et les lampes
C'est la lumière qui vient d'une direction particulière, et qui va être plus brillante si elle arrive
perpendiculairement à la surface que si elle est rasante. Par contre, après avoir rencontré la surface, elle
est renvoyée uniformément dans toutes les directions.
Lumière spéculaire
Concerne les objets et les lampes
La lumière spéculaire vient d'une direction particulière et est renvoyée par la surface dans une direction
particulière. Par exemple un rayon laser réfléchi par un miroir.
Brillance
Ne concerne que les objets
Cette valeur entre 0.0 et 128.0 détermine la taille et l'intensité de la tâche de réflexion spéculaire. Plus la
valeur est grande, et plus la taille est petite et l'intensité importante.

27/09/03 Page 11/19

Eric Bittard Cours OpenGL

Les lampes
Nombre de lampes
OpenGL offre d'une part une lampe qui génère uniquement une lumière ambiante (lampe d'ambiance), et
d'autre part au moins 8 lampes (GL_LIGHT0, ... , GL_LIGHT7) que l'on peut placer dans la scène et
dont on peut spécifier toutes les composantes.
La lampe GL_LIGHT0 a par défaut une couleur blanche, les autres sont noires par défaut.
La lampe GL_LIGHTi est allumée par un glEnable(GL_LIGHTi)
Il faut également placer l'instruction glEnable(GL_LIGHTING) pour indiquer à OpenGL qu'il devra
prendre en compte l'éclairage.
Couleur des lampes
Dans le modèle d'OpenGL, la couleur d'une composante de lumière d'une lampe est définie par les
pourcentages de couleur rouge, verte, bleue qu'elle émet.
Par exemple voici une lampe qui génère une lumière ambiante bleue :

GLfloat bleu[4] = { 0.0, 0.0, 1.0, 1.0 };

glLightfv(GL_LIGHT0, GL_AMBIENT, bleu);
Il faut donc définir pour chaque lampe la couleur et l'intensité des trois composantes ambiante, diffuse et
spéculaire.
Voici un exemple complet de définition de la lumière d'une lampe :

GLfloat bleu[4] = { 0.0, 0.0, 1.0, 1.0 };

glLightfv(GL_LIGHT0, GL_AMBIENT, bleu);

glLightfv(GL_LIGHT0, GL_DIFFUSE, bleu);
glLightfv(GL_LIGHT0, GL_SPECULAR, bleu);

Lampes directionnelles
Il s'agit d'une lumière qui vient de l'infini avec une direction particulière.
La direction est spécifiée par un vecteur (x,y,z)

GLfloat direction[4];
direction[0]=x; direction[1]=y; direction[2]=z;
direction[3]=0.0; /* notez le zéro ici */
glLightfv(GL_LIGHT0, GL_POSITION, direction);

Lampes positionnelles
La lampe se situe dans la scène au point de coordonnées (x,y,z)

GLfloat position[4];
position[0]=x; position[1]=y; position[2]=z;
position[3]=1.0; /* notez le un ici */
glLightfv(GL_LIGHT0, GL_POSITION, position);

Modèle d'éclairage
Il faut indiquer avec glLightModel*() si les calculs d'éclairage se font de la même façon ou non sur
l'envers et l'endroit des faces des objets.
Il faut également indiquer si OpenGL doit considérer pour ses calculs d'éclairage que l'œil est à l'infini
ou dans la scène. Dans ce dernier cas, il faut calculer l'angle entre le point de vue et chacun des objets,
alors que dans le premier cas, cet angle est ignoré ce qui est moins réaliste, mais moins coûteux en
27/09/03 Page 12/19
Eric Bittard Cours OpenGL

calculs. C'est le choix par défaut. Il est modifié par l'instruction

glLightModeli(GL_LIGHT_MODEL_LOCAL_VIEWER, GL_TRUE).
C'est avec cette même fonction que l'on définit la couleur de la lampe d'ambiance
glLightModelfv(GL_LIGHT_MODEL_AMBIENT, couleur)
Atténuation de la lumière
Dans le monde réel, l'intensité de la lumière décroit quand la distance à la source de lumière augmente.
Par défaut le facteur d'atténuation d'OpenGL vaut un (pas d'atténuation), mais vous pouvez le modifier
pour atténuer la lumière des lampes positionnelles.

La formule est : facteur_d_atténuation = 1.0 / (kc + kl*d + kq*d*d), où

d est la distance entre la position de la lampe et le sommet
kc = GL_CONSTANT_ATTENUATION
kl = GL_LINEAR_ATTENUATION
kq = GL_QUADRATIC_ATTENUATION

exemple de modification du coefficient d'atténuation linéaire pour la lampe 0 :

glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, 2.0);

Lampes omnidirectionnelles et spots

Par défaut, une lampe illumine l'espace dans toutes les directions.
L'autre type de lampe proposé par OpenGL est le spot.
Un spot est caractérisé, en plus de sa position, par sa direction, le demi angle du cône de lumière et
l'atténuation angulaire de la lumière.
La direction par défaut est {0.0, 0.0, -1.0}, c'est le demi-axe -z.

GLfloat direction[]={-1.0, -1.0, 0.0};

glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, 45.0); /* ce spot éclairera jusqu'à 45°
autour de son axe */
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, direction);
glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, 0.5);/* coefficient d'atténuation angulaire
*/

Couleur d'un matériau

Dans le modèle d'OpenGL, la couleur que l'on perçoit d'un objet dépend de la couleur propre de l'objet et
de la couleur de la lumière qu'il reçoit.
Par exemple, un objet rouge renvoie toute la lumière rouge qu'il reçoit et absorbe toute la lumière
verte et bleue qu'il reçoit.
• Si cet objet est éclairé par une lumière blanche (composé en quantités égales de rouge, vert et
bleu), il ne renverra que la lumière rouge et apparaîtra donc rouge.
• Si cet objet est éclairé par une lumière verte, il apparaîtra noir, puisqu'il absorbe le vert et n'a
pas de lumière rouge à réfléchir.

Propriétés matérielles d'un objet

Les propriétés matérielles d'un objet sont celles qui ont été évoquées dans la partie Modèle
d'éclairage OpenGL : la lumière émise, la réflexion ambiante, diffuse et spéculaire du matériau dont
est fait l'objet. Elles sont déterminées par des instructions :

27/09/03 Page 13/19

Eric Bittard Cours OpenGL

glMaterial*(GLenum face, GLenum pname, TYPE param)

Où pname vaut GL_AMBIENT, GL_DIFFUSE, GL_AMBIENT_AND_DIFFUSE,
GL_SPECULAR, GL_SHININESS, ou GL_EMISSION.
Combinaison des coefficients
• Pour une lampe, les coefficients RVB correspondent à un pourcentage de l'intensité totale
pour chaque couleur.
Par exemple R=1.0, V=1.0, B=1.0 correspond au blanc de plus grande intensité, alors que
R=0.5, V=0.5, B=0.5 correspond à un blanc d'intensité moitié moins grande, qui est donc un
gris.
• Pour un objet, les nombres correspondent à la proportion de la lumière renvoyée pour chaque
couleur.
Si une lampe qui a comme coefficients (LR, LV, LB) éclaire un objet (OR, OV, OB), la
couleur perçue sera (LR*OR, LV*OV, LB*OB).
• La combinaison de deux lampes de coefficients (R1, V1, B1) et (R2, V2, B2) produit une
lumière (R1+R2, V1+V2, B1+B2) (et les valeurs supérieures à 1 sont ramenées à 1).

Transparence
La transparence est obtenue en indiquant pour un objet une couleur diffuse RVBA ou la valeur A sur
le canal alpha est strictement plus petite que un.

Exercice 1
4. Copiez et compilez le programme colormat.c. Il permet de modifier indépendamment les
quatre composants du matériau de la sphère.
5. Ajoutez une lampe en (-1,1,1) qui émet une lumière ambiante verte, une lumière diffuse
bleue, et une lumière spéculaire rouge.
Utilisez les touches '0' (resp. '1') pour allumer et éteindre la lampe 0 (resp. 1).

Elimination des surfaces cachées

OpenGL utilise la technique du Z buffer (ou buffer de profondeur) pour éviter l'affichage des surfaces
cachées. On ne voit d'un objet que les parties qui sont devant et pas celles qui se trouvent derrière. Pour
chaque élément de la scène la contribution qu'il aurait à l'image s'il était visible est calculée, et est
stockée dans le Z buffer avec la distance de cet élément à la caméra (c'est cette distance qui est la
profondeur).
Chaque pixel de l'image garde donc la couleur de l'élément qui est le plus proche de la caméra. Dans le
cas plus complexe d'un objet transparent, il y a une combinaison des couleurs de plusieurs éléments.
Fonctions utilisées
• glutInitDisplayMode(GLUT_DEPTH | ... )
• glEnable(GL_DEPTH_TEST)
• glClear (GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT) Avant l'affichage d'une
scène.

27/09/03 Page 14/19

Eric Bittard Cours OpenGL

Listes d'affichage
Il s'agit d'un mécanisme pour stocker des commandes OpenGL pour une exécution ultérieure, qui est
utile pour dessiner rapidement un même objet à différents endroits.
Les instructions pour stocker les éléments d'une liste d'affichage sont regroupées entre une instruction
glNewList(GLuint numList, GLenum mode ) et une instruction glEndList(). Le paramètre numList est
un numéro unique (index)qui est généré par glGenLists() et qui identifie la liste.
Les éléments stockés dans la liste d'affichage sont dessinés par l'instruction glCallList()
Une fois qu'une liste a été définie, il est impossible de la modifier à part en la détruisant et en la
redéfinissant.
Listes d'affichage hiérarchiques
Il est possible de créer une liste d'affichage qui exécute une autre liste d'affichage, en appelant
glCallList() à l'intérieur d'une paire glNewList() et glEndList().
Il y a un nombre maximal d'imbrications qui dépend des implémentations d'OpenGL.

Création et suppression des listes d'affichage

L'instruction glGenLists() génère un numéro de liste qui n'est pas déjà employé, mais il est
également possible d'utiliser un numéro spécifique, en testant par glIsList(GLuint numListe). En
effet, cette fonction renvoie GL_TRUE si la liste numListe existe déjà, et GL_FALSE sinon.
L'instruction glDeleteLists(GLuint list, GLsizei range) permet de supprimer range listes en
commençant par la numéro list. Une tentative de suppression d'une liste qui n'existe pas est
simplement ignorée.

Quadriques
La bibliothèque GLU permet de créer certains objets définis par une équation quadratique : des sphères,
des cylindres, des disques et des disques partiels. Pour celà il y a cinq étapes :
1. Utiliser gluNewQuadric() pour créer une quadrique.
2. Spécifier les attributs de rendu :
• gluQuadricOrientation() indique la direction des normales vers l'extérieur ou
l'intérieur.
• gluQuadricDrawStyle() indique le style de rendu : avec des points, des lignes ou des
polygones pleins.
• gluQuadricNormals() permet de générer des normales pour chaque face ou pour
chaque sommet.
• gluQuadricTexture() permet de générer les coordonnées de texture.
3. Indiquer la fonction qui traite les erreurs dans l'affichage de la quadrique par
gluQuadricCallback()
4. Afficher la quadrique désirée avec gluSphere(), gluCylinder(), gluDisk(), ou
gluPartialDisk(). Pour une meilleure efficacité, il est recommandé d'utiliser des listes
d'affichage.
5. Enfin, pour détruire l'objet, appeler gluDeleteQuadric().

27/09/03 Page 15/19

Eric Bittard Cours OpenGL

IV. Textures
Introduction
Le placage de texture consiste à placer une image (la texture ) sur un objet. Cette opération se comprend
aisément lorsqu'il s'agit de plaquer une image rectangulaire sur une face rectangulaire, tout au plus
imagine-t-on au premier abord qu'il y a un changement d'échelle à effectuer sur chacune des dimensions.
Mais peut-être au contraire le choix est de répéter l'image un certain nombre de fois sur la face.
Se pose ensuite la question d'objets qui ne sont pas des faces rectangulaires : comment définir la portion
d'image et la manière de la plaquer ?
Comment procéder de manière générale
• Il s'agit d'abord de créer un Objet-Texture et de spécifier la texture que l'on va utiliser.
• Ensuite choisir le mode de placage de la texture avec glTexEnv[f,i,fv,iv]()
• Le mode decal décalque la texture sur l'objet : la couleur de l'objet est remplacée par
celle de la texture.
• Le mode modulate utilise la valeur de la texture en modulant la couleur précédente de
l'objet.
• Le mode blend mélange la couleur de la texture et la couleur précédente de l'objet.
• Puis autoriser le placage de textures avec glEnable(GL_TEXTURE_2D) si la texture a deux
dimensions. (ou GL_TEXTURE_1D si la texture est en 1D).
• Il est nécessaire de spécifier les Les coordonnées de texture en plus des coordonnées
géométriques pour les objets à texturer.

Les coordonnées de texture

Les coordonnées de texture vont

de 0.0 à 1.0 pour chaque
dimension.

On assigne avec glTexCoord*() pour chaque sommet des objets à texturer un couple de valeurs qui
indique les coordonnées de texture de ce sommet.

27/09/03 Page 16/19

Eric Bittard Cours OpenGL

Si l'on désire que toute l'image soit

affichée sur un objet de type
quadrilatère, on assigne les valeurs
de texture
(0.0, 0.0) (1.0, 0.0) (1.0, 1.0) et
(0.0, 1.0) aux coins du
quadrilatère.

Si l'on désire mapper uniquement

la moitié droite de l'image sur cet
objet, on assigne les valeurs de
texture
(0.5, 0.0) (1.0, 0.0) (1.0, 1.0) et
(0.5, 1.0) aux coins du
quadrilatère.

Exercice
• Examinez le programme texture1.c (il utilise l'image [Link]) pour comprendre
l'utilisation des coordonnées de texture.
• Plaquez uniquement la tête de snoopy sur le quadrilatère grâce aux coordonnées de texture.

Répétition de la texture
Il faut indiquer comment doivent être traitées les coordonnées de texture en dehors de l'intervalle
[0.0, 1.0]. Est-ce que la texture est répétée pour recouvrir l'objet ou au contraire "clampée" ?
Pour ce faire, utilisez la commande glTexParameter() pour positionner les paramètres
GL_TEXTURE_WRAP_S pour la dimension horizontale de la texture ou GL_TEXTURE_WRAP_T pour la
dimension verticale à GL_CLAMP ou GL_REPEAT.
Exercice
• Dans la moitié inférieure du quadrilatère, plaquez trois fois l'image du snoopy.

Les Objets-Textures
Depuis la version 1.1 d'OpenGL, il est possible de déclarer, de nommer et de rappeler simplement des
Objets-Textures.
• glGenTextures(GLsizei n, GLuint *textureNames) renvoie n noms (des numéros, en fait) de textures
dans le tableau textureNames[]
• glbindTexture(GL_TEXTURE_2D, GLuint textureNames) a trois effets différents :
• la première fois qu'il est appelé avec une valeur textureNames non nulle, un nouvel Objet-
27/09/03 Page 17/19
Eric Bittard Cours OpenGL

Texture est crée, et le nom textureNames lui est attribué.

• avec une valeur textureNames déjà liée à une objet-Texture, cet objet devient actif
• avec la valeur zéro, OpenGL arrête d'utiliser des objets-textures et retourne à la texture par
défaut, qui elle n'a pas de nom.
• glDeleteTextures(GLsizei n,const GLuint *textureNames)efface n objets-textures nommés par les
éléments du tableau textureNames
Exercice
• Examinez le programme texturebind.c qui utilise les images [Link] et [Link]

Filtrage
Notez que les pixels de l'image de texture s'appellent des texels (au lieu de picture-elements, on a des
texture-elements).
Lorsque la partie de l'image de texture qui est mappée sur un pixel d'un objet est plus petite qu'un texel, il
doit y avoir agrandissement.
Lorsqu'au contraire la partie de l'image de texture qui est mappée sur un pixel d'un objet contient plus
d'un texel, il doit y avoir une réduction.
La commande glTexParameter() permet de spécifier les méthodes d'agrandissement (
GL_TEXTURE_MAG_FILTER ) et de réduction ( GL_TEXTURE_MIN_FILTER ) utilisées :
• GL_NEAREST choisit le texel le plus proche
• GL_LINEAR calcule une moyenne sur les 2x2 texels les plus proches.
L'interpolation produit des images plus lisses, mais prend plus de temps à calculer. Le compromis
valable pour chaque application doit être choisi.

Les niveaux de détail

Les objets texturés sont visualisés comme tous les objets de la scène à différentes distances de la caméra.
Plus les objets sont petits, moins il est nécessaire d'utiliser une taille importante pour l'image de texture
utilisée. En particulier, l'utilisation d'images de tailles adaptées à la taille de l'objet peut accélérer le
rendu de l'image et éviter certains artéfacts visuels lors d'animations.
OpenGL utilise une technique de mipmapping pour utiliser des images de taille appropriée. Les images
du quart, du seizième, du soixante-quatrième, etc de la taille de l'image initiale sont stockées, jusqu'à
l'image d'un pixel de côté, et en fonction de la taille de l'objet dans la scène, la texture de la taille adaptée
est choisie.
Vous pouvez fournir vous-mêmes les images de texture aux différentes tailles avec plusieurs appels à
glTexImage2D() à différentes résolutions, ou bien utiliser une routine de l'OpenGL Utility Library :
gluBuild2DMipmaps(), qui calcule les images réduites.
Filtrage : suite
Lors d'utilisation de mipmaps, il y a quatre autres filtres de réduction :
• GL_NEAREST_MIPMAP_NEAREST et GL_LINEAR_MIPMAP_NEAREST utilisent l'image
mipmap la plus proche, et dans cette image, le premier choisit le texel le plus proche,
et le deuxième réalise une interpolation sur les quatre texels les plus proches.
• GL_NEAREST_MIPMAP_LINEAR et GL_LINEAR_MIPMAP_LINEAR travaillent à partir de
l'interpolation de 2 mipmaps.

27/09/03 Page 18/19

Eric Bittard Cours OpenGL

Lecture d'une image de texture dans un fichier

Le fichier loadppm.c permet de lire une image au format PPM (avec les données en binaire et
éventuellement des lignes de commentaires). glTexImage2D() que vous trouvez dans l'exemple
texture1.c permet de spécifier quelle image vous utilisez comme texture. Sa limitation est de nécessiter
une image dont la hauteur et la largeur sont des puissances (éventuellement différentes) de 2 : votre
image peut avoir comme taille 256x64, mais pas 100x100.
La routine gluBuild2DMipmaps(), par contre accepte les images de toutes tailles.

Exercice
Récupérez deux images de textures (images qui peuvent se répéter) et plaquez l'une sur le bras de votre
robot, l'autre sur l'avant-bras et les doigts.

Enjoy !

27/09/03 Page 19/19