Plan du cours

Introduction à OpenGL
Partie I: Rudiments d'OpenGL
1. OGL : Open Graphic Language
2. références
3. Pipeline OpenGL
4. Conventions de l'API
5. Matrices homogènes
6. Buffers OpenGL
Johan Montagnat 7. Primitives géométriques
I3S, CNRS 8. Couleurs et matériaux
9. Sources lumineuses
johan@[Link]
10. Interaction entre OpenGL et X windows
Introduction a OpenGL 2 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 1 SI2 - cours de synthèse d'images, 2006

1. OGL : Open Graphic Language Qu'est-ce qu'OpenGL

• Histoire - OpenGL est un standard récent
1989: GL (Graphic Language) a été développé par Silicon Graphics pour utiliser le
• Qu'est-ce qu'OpenGL ? hardware spécialisé de ses stations graphiques
• Références 1993: OpenGL est une extension de GL portable sur d'autres architectures
• La philosophie GL La version actuelle est 1.2

• Organisation des librairies • OpenGL est devenu un standard de fait en infographie 3D

Existe sur toutes les architectures
• Possibilités et limitations En langage C
Indépendant du système graphique
Performant et souple d'utilisation
• Mesa3D est une implémentation logicielle (libre) d'OpenGL
Sans hardware spécialisé : dépendant du processeur de la machine
Néanmoins bien optimisé
Indépendant du hardware : a contribué à la généralisation d'OpenGL
Introduction a OpenGL 4 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 3 SI2 - cours de synthèse d'images, 2006

 Qu'est-ce qu'OpenGL
Philosophie GL
• Que trouve-t-on dans OpenGL ?
Une API (bas niveau) en C permettant de tirer faisant l’interface entre le logiciel • API: Application Programmer's Interface
et le driver matériel 150 fonctions
Spécialisé pour le rendu réaliste 2D et 3D Librairie logicielle
Des matrices homogènes pour la projection de coordonnées 3D Interface bas niveau entre l'application et le hardware
Des primitives graphiques (points, lignes, triangles...) Pas de structures de données: OpenGL fonctionne comme une machine à états.
Des primitives image
Application
Des buffers (image, Z-buffer, ...)
Des matériaux Interface Interface haut niveau
Des lumières graphique API OpenGL
Des algorithmes de rendu simples à accélérer en hardware (faces cachées, lissage Système d'exploitation Driver graphique
de Gouraud, placage de texture) Matériel Carte graphique
Des fonctions d'optimisation
Des bibliothèques plus haut niveau simplifiant l'utilisation des primitives Introduction a OpenGL 6 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 5 SI2 - cours de synthèse d'images, 2006

Philosophie GL
Organisation de librairies
• Notion de contexte
À chaque fenêtre graphique 3D est associé un contexte OpenGL • Les principales librairies
GL: API de base
Un seul contexte actif à un instant donné
GLU (GL Utility): API haut niveau (primitive graphiques complexes, position de
Toutes les commandes GL ont lieu dans le contexte actif
la caméra, projections, ...)
• Architecture en pipeline GLX: interface avec X windows (sous UNIX)
Deux types de primitives: GLUT (GL Utility Toolkit): API haut niveau (initialisation, boucle d'évènements
- Géométriques (points, lignes...) X windows, ...)
Application
- Pixels (images, textures...) • Organisation
Traitement des primitives en série (pipeline) jusqu'à l'étape de rasterization X GLUT
(discrétisation et écriture dans le buffer d'affichage) GLX GLU GL
Windows
• Superposition de buffers comme autant de couches transparentes Système d'exploitation Driver graphique
Le buffer d'affichage (framebuffer), généralement sur 24 ou 32 bits
Matériel Carte graphique
Mais aussi le Z-buffer, stencil-buffer, double buffer...
- Autant de bits par pixel! Introduction a OpenGL 8 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 7 SI2 - cours de synthèse d'images, 2006

 Possibilités
Limitations
• Les fonctionnalités de base
Transformations géométriques de primitives et pixels • Certains algorithmes se prêtent mal à un câblage en hardware
Calculs de l'éclairement fonction des lumières et matériaux le lancé de rayons
Gestion des faces cachées la radiosité
Rendu surfacique par facette ou de Phong ...
Anti-crénelage
Transparence • OpenGL apporte un compromis en performance et puissance du rendu
Plans de coupe
Placage de textures... • La performance effective dépend de la qualité de la carte graphique
• Les fonctionnalités dérivées Beaucoup de cartes sur PC sont optimisées pour le jeux (placage de texture
Reflets intensif) mais négligent les aspects géométriques (reportés sur le processeur).
Ombres Ordre de grandeur: SGI Onyx2 Infinite Reality ~ 106 triangles rendus / s
Rendu volumique Les cartes sur PCs se rapprochent rapidement de ces performances...
Rendus mixtes surfaciques / volumiques... 10
Introduction a OpenGL SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 9 SI2 - cours de synthèse d'images, 2006

10. Références
Références électroniques
• Le site officiel
[Link]
• Mesa3D
[Link]
• SGI
[Link]
[Link]
[Link]
• Tutorial et exemples
[Link]

Introduction a OpenGL 12 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 11 SI2 - cours de synthèse d'images, 2006

 Livres de référence
3. Conventions de l'API OpenGL
• Le « livre rouge »
The OpenGL programming guide, 3rd edition, the official guide to learning
OpenGL version 1.2
• Conventions de nommage
By Mason Woo et al., ISBM 0-201-60458-2
• Changer l'état courant
• Le « livre bleu »
• Paradigme glBegin() / glEnd()
OpenGL Reference Manual, 3rd edition
ISBN 0-201-65675-1

• The OpenGL Graphic System: A specification

Marc Segal, Kurt Akeley
• The OpenGL Graphics System Utility Library
Norman Chien et al.
[Link] Introduction a OpenGL 14 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 13 SI2 - cours de synthèse d'images, 2006

Conventions de nommage
Changer l'état courant
• Les types • OpenGL fonctionne comme une machine à états
Il n'y a ni types, ni structures définies en OpenGL. Les seuls types manipulés sont
Les commandes ne sont souvent pas suffisantes par elle même, elles s'exécutent
les types primitifs du C ou des tableaux de type primitifs dans un contexte.
• Les constantes Ex: à un sommet est attaché une couleur courant, une normale courante, etc.
GL_... suivi de mots en majuscules séparés par des _ Le changement d'état se fait à travers de très nombreuses fontions de l'API:
GL_PROJECTION, GL_TRIANGLE_FAN gl{Enable,Disable}({GL_LIGHTING, GL_FOG, GL_DEPTH_TEST...})

• Les fonctions de l'API

glColor{34}{ifd}(...)
glNormal{34}{fd}(...)

gl... suivi de mots en minuscule dont la première lettre est majuscule:

glBegin(...), glGetError(...), etc. • Il est possible d'intéroger l'état courant avec glGet/isEnabled:
Les primitives ont 2, 3 ou 4 dimensions mais L'API en C ne permet pas la glGet{Boolean,Integer,Float,Double}v(enum flag, T *)
float matrix[16];
surcharge des noms de fonction glGetFloatv(GL_MODELVIEW_MATRIX, matrix);
glVertex{234}{ifd}[v](...) isEnabled(enum flag)
integer, float, double, vector (tableau) isEnabled(GL_LIGHTING);
2, 3 ou 4 paramètres
ex: glVertex2i(int, int), glVertex4fv(float *)... Introduction a OpenGL 16 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 15 SI2 - cours de synthèse d'images, 2006

 Paradigme glBegin() / glEnd()
4. Matrices Homogènes
• Dessin des object géométrique en regroupant les primitives graphique • Piles de matrices
dans une ''paire'' glBegin/glEnd
• Synthaxe: • Représentation des matrices
glBegin(GL_TRIANGLES) • Calcul matriciel
... glVertex ...
glEnd() • Matrices de projection
Pas d'entrelacement des paires glBegin/glEnd! • Étapes de transformation des primitives
• Utilisation:
glBegin(GL_TRIANGLES);
glVertex3d(...);
glVertex3d(...);
glVertex3d(...);
glEnd();

Introduction a OpenGL 18 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 17 SI2 - cours de synthèse d'images, 2006

Piles de matrices
Piles de matrices
• Toutes les coordonnées (sommet, normales, directions...) sont • Matrices représentées en rangées dominantes
multipliées par des matrices de transformation et de projection. Attention, ce n'est pas la représentation usuelle 0 4 8 12

• OpenGL définit la chaîne de transformations suivante:

1 5 9 13
mais sa transposée! 2 6 10 14
3 7 11 15
Repère de Matrice Repère de Matrice de
objet projection
Repère 2D • Écriture d'une matrice sur une pile
l'objet la caméra
(MODELVIEW) glMatrixMode(GL_{PROJECTION,MODELVIEW}) permet de choisir la pile concernée
(PROJECTION)
charge la matrice identité en tête de pile
• OpenGL utilise deux types de matrices
glLoadIdentity()

glLoadMatrix{fd}v(...) permet de spécifier une nouvelle matrice de tête de pile

GL_MODELVIEW: associée à chaque objet
(16 composantes)
GL_PROJECTION: paramètrant la projection 3D vers 2D
• Les matrices sont stockées sur des piles • Lecture de la valeur d'une matrice
Toutes les primitives géométriques sont multipliées par la tête de pile
glGet{Float,Double}v(GL_{PROJECTION,MODELVIEW}, ...)

Pour obtenir une matrice en lignes dominantes, utiliser

Possibilité de changer de sauver/restaurer des matrices (gl{Push,Pop}Matrix)
glGet{Float,Double}v(GL_TRANSPOSE_{PROJECTION,MODELVIEW}_MATRIX,
glVertex ...)

Introduction a OpenGL 20 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 19 SI2 - cours de synthèse d'images, 2006

 Calcul matriciel
Matrices de projection
• Matrices homogènes (4x4):

Translation
Rotation (r, t, -n)
Echelle
(3x3) (l, b, -n)

projection 1 n f

• Translations:glTranslate 1
0
0
1
0
0
x
y
• Projection orthogonale 2
glTranslate{fd}(T x, T y, T z); 0 0 1 z
glOrtho(double l, double r, double b, double t, r-l 0 0 - r+l
0 0 0 1 r-l
double n, double f) 2
0
t-b 0 - t+b

• Facteur d'échelle: glScale

x 0 0 0 t-b
0 y 0 0 0 0 2 f+n
f-n f-n
glScale{fd}(T x, T y, T z); 0 0 z 0 0 0 0 1
0 0 0 1
(x, y, z)
• Projection perspective 2n 0 r+l 0
• Rotation: glRotate
glFrustum(double l, double r, double b, double t, r-l r-l
0 double n, double f)
0 2n t+b
R 0 t-b t-b 0
glRotate{fd}(T theta, T x, T y, T z); 0 Le rapport n/f influence l'aspect projectif
0 0 0 1 θ 0 0 f+n
f-n
2fn
f-n

• Multiplicaiton à droite: glMultMatrix{fd}(...)

0 0 -1 0
Introduction a OpenGL 22 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 21 SI2 - cours de synthèse d'images, 2006

Étapes de transformation des primitives

5. Buffers OpenGL
Repère de Repère de
Transformation
Matrices Repère 2D Normalization la fenêtre
l'objet écran
graphique • Les différents buffers
• Normalization • Écriture dans les buffers
division par la composante d'homogénéité • Utilisation des buffers
• Un premier programme fonctionnel
• Contrôle de la transformée écran
dimensions w*h, position (x, y)
contrôle des bornes de profondeur (n, f) (pour optimiser la précision du Zbuffer)
glDepthRange(float n, float f)
glViewport(int x, int y, int w, int h)

Introduction a OpenGL 24 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 23 SI2 - cours de synthèse d'images, 2006

 Les différents buffers
Écriture dans les buffers
• Il existe de nombreux buffers utilisés pendant l'étape de rendu. Le
frame buffer se décompose en: • Il existe plusieurs buffers de couleur: deux pour le double buffer (un
Color buffer: couleur (R,G,B,A) des pixels buffer d'affichage et un buffer de travail) chaqun dédoublé en cas de
se divise en double buffer et buffers droit et gauche pour la stéréo mode stéréo (un pour l'oeil droit, un pour l'oeil gauche).
permet de sélectionner le buffer
Depth ou Z-buffer: profondeur de chaque pixel
glBegin(GL_{FRONT,BACK,FRONT_LEFT...})
courant
Accumulation: composition d'opérations (+,*...) sur chaque pixel
glXSwapBuffers() échange les buffers d'affichage et de travail
Stencil: superposition d'un dessin sur le résultat du rendu
• Manipulation des buffers:
• Les buffers ne sont pas utilisés que pour le rendu mais aussi pour la glClear(GL...): réinitialisation d'un buffer
sélection: glClearColor(float r, float g, float b, float a): couleur de
glRenderMode(GL_{RENDER,SELECTION,FEEDBACK})
réinitialisation
GL_RENDER: rendu des primitives glLogicOp(...): composition des valeurs du buffer de rendu et des couleurs des
glSelectBuffer + glClipPlane + GL_SELECTION: identification des primitives primitives qui se supperposent
rendues en un point de la fenêtre. glDrawPixels(...): dessiner une région d'un buffer
GL_FEEDBACK: informations sur les primitives qui seraient rendues en un point de glReadPixels(...): lire une région d'un buffer
la fenêtre. Introduction a OpenGL 26 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 25 SI2 - cours de synthèse d'images, 2006

Un premier programme fonctionnel

6. Primitives géométriques
// vide le color buffer
glClearColor(0.0, 0.0, 0.0, 0.0);
glClear(GL_COLOR_BUFFER_BIT); • Points, lignes, triangles et quadrilatères
// applique une matrice de projection
• Normales
glMatrixMode(GL_PROJECTION); • Polygones
glPushMatrix(); • Rendu des primitives
glOrtho(…);

glMatrixMode(GL_MODELVIEW);
// … réalise le rendu des objets

// restore l’ancienne matrice de projection

glMatrixMode(GL_PROJECTION);
glPopMatrix();
Introduction a OpenGL 28 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 27 SI2 - cours de synthèse d'images, 2006

 Points, lignes, triangles et quadrilatères
Normales
• Toutes les primitivesgéométriques sont construites par une succesion de • Pour le rendu des surfaces, il est nécessaire de connaître leur orientation.
sommets (glVertex). Le paramètre de glBegin indique le type de primitive En OpenGL, une direction normale est associée à chaque sommet.
construite.
glBegin(GL_{POINTS, LINE{S,_STRIP,_LOOP}, TRIANGLE{S,_STRIP,_FAN},
QUAD{S,_STRIP}, POLYGON})
... glVertex, glNormal, glColor, glTexCord ...
glEnd() • La normale est propre aux sommets et pas aux polygônes
• Primitives: Simples Strips Loop Fan
GL_POINTS GL_LINE_STRIP GL_LINE_LOOP GL_TRIANGLE_FAN
GL_LINES GL_TRIANGLE_STRIP 5

• La normale à une sommet est un vecteur normalisé. Il doit être indiquée

GL_TRIANGLES GL_QUAD_STRIP 4
GL_QUADS 0
avant le sommet lui même:
0 3
GL_POLYGON 1
4 glNormal
1 3 glVertex
2 2
• Tous les sommets ont un certain nombre de “paramètres courants”: couleur,
glNormal
glVertex
normale, coordonnées de texture... ...
Introduction a OpenGL 30 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 29 SI2 - cours de synthèse d'images, 2006

Rendu des primitives

7. Couleurs et matériaux
• Rendu "fil de fer" ou "faces pleines:
fil de fer:
• Couleurs
glDisable(GL_LIGHTING)
glBegin(GL_{POINTS,LINES,...})
faces pleines: glEnable(GL_LIGHTING) • Matériaux
glBegin(GL_{TRIANGLES,POLYGON,...}) • Éclairer une scène
• Rendu plat ou lissé:
contrôle par glShadeModel(GL_{FLAT,SMOOTH})
GL_FLAT: éclairage constant par face
GL_SMOOTH: rendu Phong (extrapolation de l'orientation des normales)
• Une ou deux faces?
Dans de nombreuses applications, il n'est pas nécessaire de faire un rendu de la
face interne des objects (objects convexes...). Ceci permet de réduire le temps du
rendu: gl{Enable,Disable}(GL_CULL_FACE);
glCullFace(GL_{FRONT,BACK,FRONT_AND_BACK}); Introduction a OpenGL 32 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 31 SI2 - cours de synthèse d'images, 2006

 Couleurs
Matériaux
• Les couleurs sont définies comme des quadruplets (R,G,B,A) • L'interaction réaliste d'une source lumineuse et d'un matériau fait intervenir
chaque composante réelle entre 0 et 1 (pour les calculs d'éclairage) plusieurs paramètre de couleur
discrétisation de chaque composante sur 8 bits à l'affichage (cartes graphiques • couleur des primitives de type triangle, quadrilatère ou polygone est
La
définie par la fonction glMaterial
truecolor 24 bits = 3 * 8 bits)
• Un surface présente deux faces qui peuvent correspondre à deux matériaux
la composante Alpha peut être utilisée comme une constante d'opacité différents
• La couleur est un état de la machine OpenGL GL_FRONT, GL_BACK ou GL_FRONT_AND_BACK

glColor3f(red, green, blue) ou glColor4f(red, green, blue, alpha) • Définition des composantes d'un matériau
Toutes les primitives affichées par la suite prennent la couleur fixée glMaterialfv(GL_FRONT, GL_SPECULAR, tab_4_float) composante spéculaire

• La couleur est composée en fonction des calculs d'éclairage et de glMaterialfv(GL_FRONT, GL_DIFFUSE, tab_4_float) composante diffuse
transparence glMaterialfv(GL_FRONT, GL_AMBIENT, tab_4_float) composante ambiente
• glColor permet de colorer les primitives points ou lignes glMaterialfv(GL_FRONT, GL_EMISSIVE, tab_4_float) composante émissive
glMaterialf(GL_FRONT, GL_SHININESS, float) coefficient de brillance dans [0, ∞[
Introduction a OpenGL 34 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 33 SI2 - cours de synthèse d'images, 2006

Lien entre Couleur et Matériaux

8. Sources lumineuses
• Pour simplifier la définition d'un matériau • Sources lumineuses
glColorMaterial(GL_{FRONT, BACK, FRONT_AND_BACK},
GL_{AMBIENT,DIFFUSE,EMISSION,SPECULAR,AMBIENT_AND_DIFFUSE}) • Couleur des sources lumineuses
La composante désignée du matériau prend la valeur courante de couleur • Atténuation de la lumière
• Spots
• Ne permet pas de rendre des surface de tous types (platique brillant,
bois mat, verre translucide…)
Pas de réflexions
Pas de transparence
La définition d'un matériau en termes de composante ambiante, diffuse, emissive
et spéculaire est un modéle pour représenter une rélalité plus complexe.

Introduction a OpenGL 36 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 35 SI2 - cours de synthèse d'images, 2006

 Sources lumineuses
Couleur des sources lumineuses
• Activer les calculs d'éclairage
glEnable(GL_LIGHTING) • Couleur définie par composante
• Spécifier une source lumineuse
glLightfv(enum p, T value)

composante diffuse param = GL_DIFFUSE

8 sources prédéfinies: GL_LIGHT{0,7}
composante spéculaire param = GL_SPECULAR
activation individuelle des sources: glEnable(GL_LIGHT0)
composante ambiante param = GL_AMBIENT
• Paramètres des sources value = 4 float
glLightfv(GL_LIGHT0, enum param, Glfloat param)
• La couleur d'une source se compose avec celle du matériau
• La position des sources lumineuses est transformée par la matrice • Après calcul d'éclairement, les valeurs de couleur sont tronquées au
GL_MODELVIEW
besoin dans l'intervalle [0, 1] (saturation de l'intensité), puis arrondie
• Modèle d'éclairage sur l'intervalle entier [0, 255] (discrétisation).
glLightModel{if}[v](enum p, T value)
• couleurs sont estimées aux sommets, puis interpolées sur les
Les
p=LIGHT_MODEL_AMBIENT, value = couleur (4 float) de la lumière résiduelle polygônes en cas de rendu de Phong.
p=LIGHT_MODEL_LOCAL_VIEWER, LIGHT_MODEL_TWO_SIDE,
LIGHT_MODEL_COLOR_CONTROL, value = booléen Introduction a OpenGL 38 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 37 SI2 - cours de synthèse d'images, 2006

Atténuation de la lumière
Spots
• Différentes lois d'atténuation de l'intensité • En plus des paramètres précédents...
glLightf(GL_LIGHT0, GL_CONSTANT_ATTENUATION, value) atténuation
• Une direction Spot
indépendante de la distance à l'objet (lumière directionnelle à l'infini)
glLightfv(GL_LIGHT0, GL_SPOT_DIRECTION, value)
glLightf(GL_LIGHT0, GL_LINEAR_ATTENUATION, value) atténuation linéaire en value = 3 float
la distance à l'objet (lumière ponctuelle) soumise aux transformations géométriques
glLightf(GL_LIGHT0, GL_QUADRATIC_ATTENUATION, value) atténuation Cut-off
quadratique en la distance à l'objet (lumière ponctuelle) • Un angle d'ouverture Direction
glLightf(GL_LIGHT0, GL_SPOT_CUTOFF, value)

en degrés
• Position de la lumière soumise à la matrice de transformation
glLightfv(GL_LIGHT0, GL_POSITION, value) • Un coefficient d'atténuation exponentielle à l'intérieur du cône
value = 4 float glLightf(GL_LIGHT0, GL_SPOT_EXPONENT, value)

La valeur par défaut est 0 (pas d'atténuation = bords nets du cône de lumière).
Introduction a OpenGL 40 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 39 SI2 - cours de synthèse d'images, 2006

 9. Pipeline OpenGL
Primitives géométriques et pixeliques
• Primitives géométriques
Décrites par des ensemble de sommets (Vertex)
• Primitives géométriques et pixeliques Points
• Pipeline OpenGL Segments de droites
• Étapes de traitement des primitives Polygônes
Les courbes et surfaces doivent être approximées par ces primitives
• Primitives pixeliques
Bitmaps (8, 16, 24, 32 bits...)
Textures
• Autres Primitives
Couleurs
Normales
...

Introduction a OpenGL 42 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 41 SI2 - cours de synthèse d'images, 2006

Pipeline OpenGL
2. Interaction entre OpenGL et X windows

Primitives Opérations Projection,

géométriques géométriques Composition buffer d' • Interfaces graphiques: programmation par événements
discrétisation des fragments affichage • Rappels (?) sur X windows
Opérations Mémoire de • Création d'une fenêtre X
Pixels pixéliques texture • Création d'un visual pour OpenGL
• Création d'un contexte OpenGL
glFlush indique que toutes les commandes envoyées dans le pipeline • Example de programme
doivent se terminer en temps fini.
glFinish force la terminaison de toutes les commandes envoyées dans le
pipeline et ne retourne qu'ensuite.
Introduction a OpenGL 44 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 43 SI2 - cours de synthèse d'images, 2006

 Interfaces graphiques: programmation par événements
Rappels (?) sur X windows
• Tout programme graphique est basé sur une architecture
événementielle • X windows est une API très bas niveau pour la gestion de fenêtres
#include <WhateverIsNeeded.h>
graphiques
void main() { Principaux fichiers d'entête: X.h, Xutils.h
CreateWindowsAndOtherGraphicWidgets(); Principale librairie: libX11
While(true) { • Un serveur X windows tourne sur toute machine permettant l'exécution de
event = WaitForAnEvent(); requêtes et l'envoi de messages à distance
ProcessEvent(event);
Ouverture d'une connexion avec un serveur X (un display):
} Display *dpy = XOpenDisplay();
} Gestion des événements:
• ProcessEvent fait appel à des fonctions (callbacks) de gestions des XNextEvent(): attend un événement et retour une structure XEvent
événements: la programmation n'est plus linéaire [Link]: définit le type d'événement reçu
• Java cache la boucle d'événements (elle est non apparente dans main) Xevent est un en-tête de structure commune à tous les types d'événements et se
en l'exécutant dans un nouveau thread décline en XExposeEvent, XKeyEvent, XMotionEvent...

• Le paradigme objet est bien adapté à la gestion événementielle et la Les actions utilisateur (clavier, souris...) génèrent des événements

définition de callbacks. Introduction a OpenGL 46 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 45 SI2 - cours de synthèse d'images, 2006

Création d'une fenêtre X

Création d'un visual adapté à OpenGL
• Création d'une nouvelle fenêtre X en deux étapes:
XCreateWindow: création de la fenêtre (retourne l'identifiant X) • Interface entre X et OpenGL : GLX
XMapWindow: affichage de la fenêtre à l'écran (provoque un l'envoi d'un événement Toutes les fonctions (définies dans glx.h) sont préfixées par glX

de type XExposeEvent au serveur X) • Disponibilité de l'extension GLX du serveur X

Bool glXQueryExtension(Display *dpy, int *errcode1, int *errcode2)
• Les paramètres de la création • Détermination d'un visual adapté
XCreateWindow(Display *dpy, Window parent, int x, int y, int width, XvisualInfo *glXChooseVisual(Display *, Screen, int *parmeters)
int height, int border, int depth, int class, Visual *visual, long
parameters est un tableau de paramètres (terminé par None) qui indique les
mask, XSetWindowAttributes attributes);
capacités demandées parmi lesquels: GLX_USE_GL (visual qui peut être rendu
depth : nombre de bits par pixel avec GL), GLX_RGBA (visual truecolor), GLX_DOUBLEBUFFER (capacité pour un
visual : capacités de la fenêtre double buffer), GLX_DEPTH_SIZE (taille du Z-buffer), etc.
Les valeurs possibles pour ces paramètres sont dépendantes de la carte graphique man glXChooseVisual!

et conditionnent les capacités de rendu. Plusieurs tentatives peuvent être nécessaire pour obtenir un visual supporté par la
carte graphique (si les paramètres transmis ne sont pas supportés, la fonction
• Les capacités du serveur X sont paramétrables mais limitées par la retourne 0).
carte graphique pilotée
Introduction a OpenGL 48 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 47 SI2 - cours de synthèse d'images, 2006

 Création d'un contexte OpenGL Un code typique
// Ouverture de la connexion avec le serveur
• Creation d'un contexte OpenGL avec un visual valide Display *dpy = XOpenDisplay(":0"); if(!dpy) error(…);
if(!glXQueryExtension(dpy, …)) error(…);
GLXContext glXCreateContext(Display *, XVisualInfo *, None, GL_TRUE)
Le contexte OpenGL n'est a priori pas attaché à une fenêtre particulière // Création du context GL
XVisualInfo *vinfo = glXChooseVisual(dpy, …); if(!vinfo) error(…);
Il contrôle simplement à quel buffer doivent être envoyées les instructions GL GLXContext context = glXCreateContext(dpy, vinfo, …);
• Activation d'un contexte particulier // creation de la fenêtre X
glXMakeCurrent(Display *dpy, GLXDrawable window, GLXContext ctx) Window win = XCreateWindow(dpy, …, vinfo->depth, …, vinfo->visual, …);
window est un identificateur X de fenêtre qui crée le lien entre une fenêtre donnée XMapWindow(dpy, win);

et les instruction OpenGL produites // boucle d’événements

• Désactivation de tout contexte do {

Xevent evt; XNextEvent(dpy, &evt);
glXMakeCurrent(dpy, None, NULL) if([Link] == Expose) {

• Destruction d'un contexte glXMakeCurrent(dpy, win, context);

// instructions X et GL
glXDestroyContext(Display *, GLXContext) glXSwapBuffers(dpy, win);

• Affichage final du rendu OpenGL dans la fenêtre (en cas de double }

...
buffering) } while(true);
glXSwapBuffers() Introduction a OpenGL 50 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 49 SI2 - cours de synthèse d'images, 2006

Une vue plus haut niveau avec GLUT

Plan du cours
#include <GL/glut.h>

int main(int argc, char **argv) { Partie II:Aperçu des fonctionnalités

// Ouverture de la connexion avec le serveur
glutInit(&argc, argv);
// Obtention d’un contexte
glutInitDisplayMode(GLUT_SINGLE | GLUT_RGB);
1. La bibliothèque GLU
// Creation d’une fenêtre 2. Tableaux de pixels
glutCreateWindow("title");
// Assignation de la fonction de réaffichage 3. Placage de textures
glutDisplayFunc(display); 4. Rendu avancé
// Boucle de gestion des événements
glutMainLoop(); 5. Optimisation
}

// callback de réaffichage
void display() {
// instructions GL...
}
Introduction a OpenGL 52 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 51 SI2 - cours de synthèse d'images, 2006

 1. La bibliothèque GLU
Présentation
• Présentations • GLU: GL Utility Library
• Projections Partie intégrante d'OpenGL
Fonctionnalités plus haut niveau dans tous les domaines (primitives géométriques,
• Position de la caméra textures, matrices, ...)
• Quadriques
• NURBS (Non-Uniform B-Splines) • Uniquement construite sur la librairie GL

• Fonctionnalités
Manipulations matricielles (→ repose sur glMultMatrix())
Positionnement de la camera (→ glMultMatrix())
Quadriques (→ primitives géométriques)
NURBS (→ primitives géométriques)
Simplification de polygones
Introduction a OpenGL 54 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 53 SI2 - cours de synthèse d'images, 2006

Projections
Projections
• Chaque méthode crée une matrice puis appelle glMultMatrix • Projection perspective 3D: spécification intuitive
gluPerspective(double fovy, double aspect, double near, double far)
gluProject() / gluUnproject()
fovy = angle de vue en y (en degrés)
Projection des coordonnées de l'espace objet à l'espace écran et réciproquement
aspect = rapport de l'angle de vue en x sur l'ange en y (généralement 1)
Paramètres = coordonnées + tous les paramètres de transformation (matrices,
near = distance au plan de coupe proche
viewport)
far = distance au plan de coupe éloigné
Les paramètres de la transformation finale écran (viewport), établis par appel à
fovy
glViewport(), peuvent être relu par glGetDoublev(GL_VIEWPORT, Par simple appel à glFrustum(): y

tableau_4_double). x
ymax = - ymin = near * tan(fovy * PI / 360) fovx

xmax = ymax * aspect

• Projection orthogonale 2D xmin = ymin * aspect

glFrustum(xmin, ymin, xmax, ymax, near, far)
gluOrtho2D(double left, double right, double bottom, double top)
= gluOrtho(left, right, bottom, top, -1, 1)
Introduction a OpenGL 56 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 55 SI2 - cours de synthèse d'images, 2006

 Position de la camera
Sélection
• Position de la caméra
gluLookAt( double eyeX, double eyeY, double eyeZ,
• Sélection à la souris
gluPickMatrix crée une matrice de rendu dans une petite région autour d’un point
double centerX, double centerY, double centerZ,
particulier
double upX, double upY, double upZ)
→ utilisation: faire un rendu de taille réduite autour du curseur
z = (center-eye) / ||center - eye|| réaliser le rendu en mode sélection activé: tous les objets rendus sont listés dans un tableau
de sélection défini par l’utilisateur
(x, up, z) repère orthonormé
= dériver le hardware pour accélérer un calcul géométrique
M = [x1 y1 z1 0] (changement de repère) + translation -eye l'un des (multiples!) détournement des fonctionnalités OpenGL
[x2 y2 z2 0]
up
center • Utilisation
[x3 y3 z3 0] glSelectBuffer(…) allouer un tableau de sélection
[0 0 0 1] glRenderMode(GL_SELECT) passer en mode sélection
z
eye gluPickMatrix(…) créer la matrice de rendu locale, autour du pointeur souris
glInitNames() vider la pile de labels
…glPushName / glPopName… primitives openGL + labels associés
... lire les valeurs écrites dans le tableau de sélection
glRenderMode(GL_RENDER) repasser en rendu standard
Introduction a OpenGL 58 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 57 SI2 - cours de synthèse d'images, 2006

Quadriques
Quadriques
• Primitives géométriques de haut niveau
Quadriques = sphère, cylindres et disques • Exécution des primitives GL
Structure commune GLUquadricObj *quad = gluNewQuadric(); Création de facettes quadrilatérales
Orientation par défaut (selon l'axe Y)
gluSphere(quad, radius, slices, stack): sphère (méridiens et parallèles)
• Paramètres de rendu gluCylinder(quad, r1, r2, height, slices, stack): cylindre conique
gluQuadricDrawStyle: GLU_POINT, GLU_LINE, GLU_FILL, GLU_SILHOUETTE
gluDisk(quad, r1, r2, slices, loops): disque dans le plan z=0
primitives utilisées pour le rendu gluPartialDisk(quad, r1, r2, slices, loops, a1, a2): arc de disque
gluQuadricNormals: GLU_NONE, GLU_FLAT, GLU_SMOOTH
utilisation des normales: aucune, une par face, une par sommet • Callback associé
gluQuadricTexture: GL_TRUE, GL_FALSE gluQuadricCallback() : gestion des erreurs

génération des coordonnées de texture

• Destruction
gluQuadricOrientation: GL_INSIDE, GL_OUTSIDE gluDeleteQuadric(quad)
direction des normales Introduction a OpenGL 60 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 59 SI2 - cours de synthèse d'images, 2006

 NURBS: Non-Uniform B-Splines
B-Splines (cas des surfaces)
• NURBS = Courbes ou surfaces lisses
Les courbes et surfaces sont approximées par des lignes ou des polygones (cf sphères, cylindres et • n+d Noeuds en x et m+d noeuds en y
disques...) 0 < t0 < t1 < ... < tn+d en x
Pour faciliter la définition de formes courbes plus complexes que les quadriques, GLU génère des 0 < t0 < t1 < ... < tm+d en y
B-Splines discrétisées par des primitives OpenGL.
• 2 ensembles de n et m Polynômes de degré d
Définition récursive:
• Implémentation OpenGL A l'orde 0: fonctions escaliers B0i(x) = 1 si ti ≤ x ≤ ti+1 ou 0 sinon
Permet le rendu direct ou la génération d’une triangulation A l'ordre d: Bdi(x) = (x- ti)/(ti+d- ti) Bd-1i(x) + (ti+d+1- x)/(ti+d+1- ti+1) Bd-1i+1(x)
• nm points de contrôle
• B-Splines p0,0 , p0,1 , … , p0m-1
Une B-Spline ou une courbe de Bézier est une courbe/surface continue définie par un nombre fini ...
Pn-1,0 , pn-1,1 , … , pn-1,m-1
de points de contrôle
La courbe/surface est définie comme la composition d’un ensemble de fonctions polynomiales de • Point (x, y) de la surface B-Spline défini comme:
n-1 m-1
base S(x, y) = Σ i=0 Σ p
j=0 B (x)B (y)
nm
x d
i,x
d
j,y

Les polynômes de base sont paramétrés par un ensemble fini de noeuds (suite croissante de réels). Σ
n-1
Σ p
m-1
B (x)B (y) y d d
i=0 j=0 nm i,x j,y

Leur degré peut varier. Introduction a OpenGL 62 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 61 SI2 - cours de synthèse d'images, 2006

NURBS
• Comme pour les quadriques: objet NURBS NURBS
GLUnurbsObj *nurbs = gluNewNurbsRenderer();

• Callbacks (pour connaître la triangulation générée) • Création d'une courbe

gluBeginCurve(nurbs);
gluNurbsCallback(nurbs, GLU_NURBS_{BEGIN_EXT, VERTEX_EXT,
// autant de fois que désiré
NORMAL_EXT, COLOR_EXT, TEXTURE_COORD_EXT, …}, function);
gluNurbsCurve(nurbs, int #nœuds, float *nœuds, int offset, float
permet un contrôle fin des NURBS et de connaître la position des points, *ctlpoints, int order, GL_MAP1_VERTEX{3,4});

normales, points de texture... générés par GLU // où #nœuds = n+d, order = d, nœuds est un tableau de n+d points et

• Paramètres d'affichage // ctlpoints est un tableau de 3*n coordonnées

gluEndCurve(nurbs);
gluNurbsProperty(nurbs, Glenum property, Glfloat value)

property = GLU_{SAMPLING_METHOD, DISPLAY_MODE, …} pour contrôler la • Création d'une surface de manière similaire
discrétisation, l'affichage, ... gluBeginSurface(nurbs);
// autant de fois que désiré
• Création d'une courbe ou d'une surface gluNurbsCurve(nurbs, int #nœudsx, float *nœudsx, int #nœudsy, float
gluNurbsCurve() / gluNurbsSurface() *nœudsy, int offset, float *ctlpoints, int orderx, int ordery

• Destructuion
GL_MAP2_VERTEX{3,4});
gluEndSurface(nurbs);
gluDeleteNurbsRenderer(nurbs); Introduction a OpenGL 64 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 63 SI2 - cours de synthèse d'images, 2006

 2. Tableau de pixels Importation de tableaux de pixels
• Tableaux de pixels utilisé pour la manipulation de textures et des
• Importation de tableau de pixels buffer image
• Transformations
• et glPixelMap contrôlent les paramètres
• Ecriture d'un tableau de pixels glPixelStore, glPixelTransfer
d'importation des tableaux de pixel

• Les fonctions manipulant des tableaux de pixel (glTexture[1-3]D,

glDrawPixels...) sont affectés par glPixelStore

• Importation de tableaux de pixels

glPixelStore{if}(GL_UNPACK_{SWAP_BYTES, LSB_FIRST, ROW_LENGTH,
SKIP_{ROWS, PIXELS, IMAGES}, ALIGNEMENT, IMAGE_HEIGHT}, value)
SWAP_BYTES, LSB_FIRST: inverser les octets, little endian / big endian
ALIGNEMENT: nombre d'octets par pixels
SKIP_{ROWS, PIXELS, IMAGES}: offsets entre rangées/pixels/images si les
données sont discontinues
Introduction a OpenGL 66 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 65 SI2 - cours de synthèse d'images, 2006

Transformations
• Les tableaux de pixels manipulés peuvent être soumis à une série de Ecriture d'un tableau de pixels
transformations
voir pipeline de glDrawPixels, (GLSPEC p 96) • Ecriture dans le buffer d'affichage
glDrawPixels()
• Exemple: augmenter l'intensité du plan rouge • Ecriture dans la mémoire de texture
glPixelTransferf(GL_RED_SCALE, 2.0); glTexImage[1-3]D()

• Exemple: convolution du tableau avec un filtre • Copie d'une région du buffer d'affichage dans une autre
glConvolutionFilter2D(GL_CONVOLUTION_2D, GLenum outputFormat, int width, glCopyPixels()
int height, GLenum inputFormat, GLenum type, void *data) • Lecture d'une région du buffer d'affichage
inputFormat = format du buffer d'entrée (e.g. GL_RGB) glReadPixels()
outputFormat = format du tableau de pixels généré (e.g. GL_RGBA) cf pipeline des transformations en lecture (GLSPEC p 181), inverse des
width, height = taille de l'image transformations en écriture
type = type du buffer de pixels (e.g. GL_UNSIGNED_BYTE)
• Lecture de tout un buffer
data = image composant le filtre de convolution glReadBuffer()
glConvolutionParameter{if}v(GL_CONVOLUTION_2D,
GL_CONVOLUTION_FILTER_{SCALE, BIAS}, 4_float_values): paramètres à appliquer
au filtre de convolution Introduction a OpenGL 68 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 67 SI2 - cours de synthèse d'images, 2006

 3. Placage de textures
Création de textures
• Création de textures • Chargement d'un tableau de pixels dans la mémoire de texture
• Coordonnées texture
glTexImage2D(GL_TEXTURE_2D, int level, int outputFormat, int width,
int height, int border, enum inputFormat, enum type, void *data)

• Textures planes level = 0 Niveau de détail (pour textures hiérarchiques)

• Textures sphériques outputFormat = format interne (e.g. GL_RGBA)

• Textures environnementales inputFormat = format des données (e.g. GL_RGB)

type = type des composantes R,G,B,A (e.g. GL_UNSIGNED_CHAR)
data = buffer de données
width, height = Taille de l’image de texture (toujours puissance de 2)
border = 0 épaisseur du bord

• OpenGL gère des texture 1D, 2D et 3D

glTexImage[1-3]D

Introduction a OpenGL 70 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 69 SI2 - cours de synthèse d'images, 2006

Coordonnées texture
Paramètres de texture
• OpenGL prévoit un espace de texture à 4 dimensions, normalisées
entre 0 et 1, et désignées par GL_T, GL_S, GL_R, GL_Q
• Couleur de base de la texture
glTextEnvfv(GL_TEXTURE_ENV, GL_TEXTURE_ENV_COLOR, 4_floats)
• Paramètres de texture: glTexParameter Par défaut : (0, 0, 0, 0)
glTexParameteri(GL_TEXTURE_{1,2,3}D, GL_TEXTURE_WRAP_{S,T,R},
GL_{CLAMP, REPEAT}): Troncature ou répétition au bord
glTexParameteri(GL_TEXTURE_{1,2,3}D, GL_TEXTURE_{MIN,MAG}_FILTER, • Mode de composition des pixels de la texture avec la couleur de base
GL_{NEAREST,LINEAR,...}): Filtre de sous- ou sur-échantillonnage et le contenu du buffer d'affichage
glTexEnvi(GL_TEXTURE_ENV, GL_TEXTURE_ENV_MODE, GL_{REPLACE,
MODULATE, DECAL, BLEND})
• Association des points de texture avec les sommets géométriques GL_REPLACE = ignorer le buffer d'affichage
glTexCoord2f(float x, float y): x et y dans [0,1]
GL_MODULATE = moduler avec la couleur de base
Alternance coordonnée sommet - coordonnée texture:
GL_DECAL, GL_BLEND = moduler avec la couleur de base et le buffer d'affichage
glTexCoord2f(0.0, 0.0)
glVertex3f(0, 0, 0)
glTexCoordef(1.0, 0.0)
glVertex3f(100.0, 0, 0)
Introduction a OpenGL 72 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 71 SI2 - cours de synthèse d'images, 2006

 Placage de textures
4. Rendu avancé
• Différentes transformations des coordonnées texture:
glTexGen(GL_{S,T,R,Q}, GL_TEXTURE_GEN_MODE, GL_{OBJECT_LINEAR,
EYE_LINEAR, SPHERE_MAP})
• Clipping
• Brouillard
GL_OBJECT_LINEAR GL_SPHERE_MAP • Transparence
(défaut) • Anti-crénelage
GL_EYE_LINEAR
• Rendu volumique
• Stéréo
• GL_OBJECT_LINEAR = défaut
interpolation linéaire dans l'espace de l'objet
• GL_EYE_LINEAR

interpolation linéaire dans l'espace de la caméra

• GL_SPHERE_MAP

placage d'une texture fish-eye sur l'objet (=reflet de l'environnement sur l'objet) Introduction a OpenGL 74 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 73 SI2 - cours de synthèse d'images, 2006

Clipping
Brouillard
• Supprimer du pipeline de rendu toutes les primitives à l'extérieur • Modifier la couleur fonction de la distance pour donner une impression
du/des plan(s) de coupe de profondeur (pour le rendu fil de fer ou les effets de brouillard)
glEnable(GL_FOG)

• Pour éviter les aberrations (projection d'objet derrière la caméra, etc), • Choisir pour couleur de brouillard celle du fond
il existe toujours deux plans parallèles à la caméra (near et far) mis glFogfv(GL_FOG_COLOR, 4_floats)
en place avec glFrustum()
• Fonctions de transformation linéaire, exp ou exp^2
• Activation de plans de coupe glFogi(GL_FOG_MODE, GL_{LINEAR, EXP, EXP2})

glEnable(GL_CLIP_PLANEi)

glClipPlane(GL_CLIP_PLANEi, 4_floats) : équation de plan • Coefficients d'atténuation (cf GLSPEC p 139)

glFogf(GL_FOG_DENSITY, value) en mode EXP ou EXP2
glFogf(GL_FOG_{START,END}, value) en mode LINEAR
Introduction a OpenGL 76 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 75 SI2 - cours de synthèse d'images, 2006

 Transparence
Transparence en OpenGL
• Transparence réaliste
composer la couleurs de n primitives appartenant à des surfaces différentes et se • Test Alpha: ignorer un fragment qui ne passe pas le test
glEnable(GL_ALPHA_TEST)
superposant en un pixel de l'écran
glAlphaFunc(GL_{NEVER,ALWAYS,LESS,LEQUAL,GEQUAL,GREATER,EQUAL,
composition = opacification avec l'ajout de couches transparentes NOTEQUAL}, value)

réalisme = tenir compte de la distance de chaque primitive… spécifier le type de test et la valeur seuil de test
- très coûteux en espace mémoire et en temps
• Compromis: utilisation de la composante Alpha de couleur pour • Moduler la couleur en fonction du coefficient Alpha:
simuler la transparence glEnable(GL_BLEND)

Composer les couleurs (R,G,B,A) 2 à 2 La couleur d'un fragment peut être composée avec une couleur de référence:
glBlendColor(float red, float green, float blue, float alpha)
Garder un seul plan des valeurs A pour chaque pixel de l'écran
et le contenu du buffer d'affichage:
ex: pixel (i,j) de couleur (R1,G1,B1,A1) à composer avec (R2,G2,B2,A2):
glBlendEquation() et glBlendFunc()
(R,G,B,A) = (A1*R1+A2*R2, A1*G1+A2*G2, A1*B1+A2*B2, A1*A2)
éclaircissement progressif par superposition
ou bien une autre forme de composition ? Introduction a OpenGL 78 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 77 SI2 - cours de synthèse d'images, 2006

Transparence en OpenGL
Anti-crénelage (antialiasing)
• glBlendEquation :
• Affectation d'une composante Alpha dans [0,1] proportionnelle à la
glBlendEquation(GL_FUNC_{ADD,SUBSTRACT,MIN,MAX,REVERSE_SUBSTRACT})
surface de pixel couverte par chaque primitive
GL_FUNC_ADD: Couleur = src * CouleurFragment + dst * CouleurBuffer
... • Activation de l'anti-crénelage
glEnable(GL_{POINT,LINE,POLYGON}_SMOOTH)

• glBlendFunc :
• Contrôle qualité / coût
glBlendFunc(enum src, enum dst)
glHint(GL_{POINT,LINE,POLYGON}_SMOOTH_HINT,
src = GL_{ZERO,ONE,DST_COLOR,ONE_MINUS_DST_COLOR,CONSTANT_COLOR…}
GL_{FASTEST,NICEST,DONT_CARE})
dest = GL_{ZERO,ONE,SRC_COLOR,ONE_MINUS_SRC_COLOR,CONSTANT_COLOR…}

exemple de transparence:
glBlendEquation(GL_FUNC_ADD)
glBlendFunc(GL_DST_ALPHA, GL_ONE_MINUS_SRC_ALPHA)

Introduction a OpenGL 80 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 79 SI2 - cours de synthèse d'images, 2006

 Rendu volumique
Stéréo
• Utilisation d'une texture 3D représentant le volume • Nécessite 2 buffers
Un buffer pour dessiner le point de vue de chaque oeil
• Echantillonnage de plans perpendiculaires à la direction du regard dans Dans le cas de double buffering: 4 buffers
la texture 3D
Allocation: dans glXChooseVisual, spécifier le paramètre GLX_STEREO
Orientation
de Plans échantillonnés
• Technique
la caméra dans la texture 3D Réaliser 2 rendus sous 2 points de vu légèrement décalés
Afficher alternativement chaque buffer de rendu
Utiliser des lunettes polarisées synchronisées sur la fréquence d'affichage de
• Superposition transparente de plans l'écran

• Définition d'une fonction de transfert pour contrôler l'opacité de • Sélection du buffer de rendu
chaque pixel traversé glDrawBuffer(GL_BACK_{LEFT,RIGHT})

Introduction a OpenGL 82 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 81 SI2 - cours de synthèse d'images, 2006

5. Optimisation
Double buffers
• Double buffers • Eviter le scintillement en dessinant hors de l'écran puis en
• Listes précompilées rafraîchissant la fenêtre « instantanément »
• Textures hiérarchisées Initialisation: paramètre GLX_DOUBLEBUFFER de glXChooseVisual()

• Simplification de triangulations Forcer à rafraichir: glXSwapBuffers()

Forcer l'écriture dans l'un des buffers
glDrawBuffer(GL_{BACK,FRONT})

Normalement, on travaille toujours dans GL_BACK, GL_FRONT est affiché et

glXSwapBuffers() provoque une inversion des deux

Introduction a OpenGL 84 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 83 SI2 - cours de synthèse d'images, 2006

 Listes précompilées
Textures hiérarchisées
• Précalculer certaines étapes du pipeline et mémoriser le résultat dans une
« liste d'affichage » qui pourra être exécutée à nouveau plus rapidement
• Textures multi-résolution (MipMaps)
• Précalcul certaines étapes du pipeline Affichage de textures adaptées à la distance de visualisation
int list = glGenLists(1); // obtenir un nouvel identifiant de liste
glNewList(list, GL_{COMPILE,COMPILE_AND_EXECUTE}); // débuter la liste
…gl… • Chargement de texture hiérarchisées
glEndList(); // terminer la liste glTexImage[1-3]D(…, int level, …)

• Réexécute les instructions gl en accélérant

glCallList(list);
• Création:
• Exemple d'utilisation: dessiner 2 objets de couleurs et positions différentes gluScaleImage()
glColor4f(…); gluBuild[1-3]DMipMaps()
int list = glGenLists(1); glNewList(list, GL_COMPILE_AND_EXECUTE);
… dessiner un cube…
glEndList();
glColor4f(…); glTranslated(…);
glCallList(list); glDeleteLists(list, 1);

Introduction a OpenGL 86 SI2 - cours de synthèse d'images, 2006

Introduction a OpenGL 85 SI2 - cours de synthèse d'images, 2006

Simplification de triangulations
• Simplification = réduction d'une triangulation (on parle de décimation:
1 sur 10)
Conserver la topologie
Préserver au mieux la géométrie (concentrer les triangles dans les zones de forte
courbure)

• Optimisation des performances

Valable pour les objets complexes
Réduire le nombre de primitives géométriques à afficher en minimisant la perte
de qualité
La simplification peut être pré-calculée...

• Construction de modèles hiérarchiques

Utiliser des modèles de plus en plus grossier lorsque la distance augmente
Introduction a OpenGL 87 SI2 - cours de synthèse d'images, 2006