Introduction à OpenGL

Introduction à OpenGL
Pascal BOYER
[email protected]
lb
@ dh
f
O
OpenGL
GL
Introduction Generale OpenGL
Primitives
Modes de rendu
Éclairage
Mapping et Textures
OpenGL avancé
P
Presentation
t ti d
de O
OpenGL
GL
- Ce que OpenGL n’est pas
- Discussion autour d’OpenGL et de DirectX
- Frameworks 3D du marché
OpenGL et GLUT
O
OpenGL
GL and
d GLUT O
Overview
i
Qu’est-ce que OpenGL peut faire
Qu’estOpenGL et “windows managers”
Pourquoi Glut
Exemple de programme GLUT
Q ’ t
Qu’est-ce
O
OpenGL?
GL?
API de Rendu graphique
• Images composées à partir de formes dites
“primitives”
• Indépendant du système de fenêtrage
• Indépendant
I dé
d
d
de l’OS
A hit t
Architecture
O
OpenGL
GL
Polynomial
Evaluator
CPU
Display
Li t
List
Per Vertex
Operations &
Primitive
Assembly
Rasterization
Texture
Memory
Pixel
Operations
Per Fragment
O
Operations
Frame
Buffer
ff
O
OpenGL
GL comme moteur
t
d
de rendu
d
Primitives de géometrie
• points, lignes et polygones
Primitives d
d’image
image
• images et bitmaps
• pipeline
i li séparée
é é pour lles iimages ett lla géometrie
é
ti
•
Liées grâce au plaquage de texture
Le “Rendering” depend du contexte
• couleurs,, materiaux,, sources lumineuses,, etc.
API lié
APIs
liées
AGL, GLX, WGL
• Liaison entre OpenGL et le système
è
de fenêtrage
ê
GLU ((OpenGL
p
Utility
y Library)
y)
• partie de OpenGL
• NURBS,
NURBS tessellators
tessellators, quadric shapes
shapes, etc
etc.
GLUT (OpenGL Utility Toolkit)
• API de fenêtrage
ê
portable
• N’est pas officièlement une partie d’OpenGL
O
OpenGL
GL lles diffé
différentes
t APIs
API
application program
OpenGL Motif
widget or similar
GLX, AGL
or WGL
X, Win32, Mac O/S
GLUT
GLU
GL
software and/or hardware
E Amont
En
A
t
Fichiers d’en tête
• #include <GL/gl.h>
• #include <GL/glu.h>
• #include <GL/glut.h>
Libraries
Types Enumérés
• OpenGL
O
GL plusieurs
l i
types pour lla compatibilité
ibili é
– GLfloat, GLint, GLenum, etc.
GLUT Basics
B i
Structure d’une application de base
• Configurer and ouvrir une fenêtre
Initialisation de OpenGL state
• Enregistrement des méthodes Callback
• rendu
d
• redimensionnement
• entrées: Clavier,
Clavier souris,
souris etc.
etc
• Entrée dans la boucle de traitement
E
Example
l
void main(
( int argc
argc,
g , char** argv
g )
{
int mode = GLUT_RGB|GLUT_DOUBLE;
glutInit(&
glutInit
(&argc
(&argc,argv
argc
argc,argv);
argv);
argv);
glutInitDisplayMode(
glutInitDisplayMode
( mode );
glutInitWindowPosition(100,100);
glutInitWindowPosition
g
(100,100);
(
,
);
glutInitWindowSize(350,350);
glutInitWindowSize
(350,350);
glutCreateWindow(
glutCreateWindow
( « Test Open Gl » );
init();
init
();
glutDisplayFunc(
glutDisplayFunc
( display );
glutReshapeFunc(
glutReshapeFunc
( resize );
glutKeyboardFunc(
glutKeyboardFunc
( key );
( idle );
glutIdleFunc(
glutIdleFunc
glutMainLoop();
glutMainLoop
();
}
I iti li ti
Initialization
O
OpenGL
GL
Définition des paramêtres d’initialisation d’OpenGL
void init( void )
{
glClearColor( 0.0, 0.0, 0.0, 1.0 );
glClearDepth( 1.0 );
glEnable( GL_LIGHT0 );
glEnable( GL_LIGHTING );
g
glEnable( GL_DEPTH_TEST );
}
Méth d C
Méthodes
Callback
llb k GLUT
Code à appeler lors d’un déclenchement
evenementiel
ti l envoyé
é par l’API graphique
hi
• redimensionnement ou dessin de la fenêtre
• Entrée utilisateur
• Animation (idle)
(
)
Comment “Register” les méthodes callback
glutDisplayFunc( display );
glutDisplayFunc(
glutIdleFunc(
glutIdleFunc
( idle );
( keyboard );
glutKeyboardFunc(
glutKeyboardFunc
R d i Callback
Rendering
C llb k
Effectue les opérations de dessin vers le device
glutDisplayFunc(
glutDisplayFunc
l tDi l F
( display
di l
)
);
void display( void )
{
glClear(
glClear
( GL_COLOR_BUFFER_BIT );
glBegin(
glBegin
( GL_TRIANGLE_STRIP );
glVertex3fv( v[0] );
glVertex3fv(
lV t 3f ( v[1]
[1] )
);
glVertex3fv( v[2] );
glVertex3fv( v[3] );
glEnd();
glEnd
();
glutSwapBuffers();
glutSwapBuffers
();
}
Idl Callbacks
Idle
C llb k
Utilisation pour l’animation ou les mises à jour
glutIdleFunc( idle );
void idle( void )
{
t += dt;
; //
//angle
g
de rotation
glutPostRedisplay();
}
C llb k de
Callbacks
d d’entrée
d’ t é utilisateur
tili t
Gestion des saisies utilisateur
glutKeyboardFunc( keyboard );
void keyboard( unsigned char key, int x, int y )
{
switch( key ) {
case ‘q’ : case ‘Q’ :
exit( EXIT_SUCCESS
_
);
b
break;
k
case ‘r’ : case ‘R’ :
rotate = GL_TRUE;
glutPostRedisplay();
break;
}
}
Rendu Elementaire
R d Elementaire
Rendu
El
t i
“Primitives”
Gestion des “State” OpenGL
Buffers OpenGL
P i iti
Primitives
géometriques
é
t i
O
OpenGL
GL
Toutes les primitives sont définies par des
vertices
GL LINES
GL_LINES
GL_POINTS
GL_POLYGON
GL_LINE_STRIP
GL_LINE_LOOP
GL_TRIANGLES
GL_TRIANGLE_STRIP
GL_QUADS GL_QUAD_STRIP
GL TRIANGLE FAN
GL_TRIANGLE_FAN
E
Example
l
void drawRhombus( GLfloat color[] )
{
glBegin( GL_QUADS );
glColor3fv( color );
glVertex2f( 0.0, 0.0 );
glVertex2f( 1
1.0,
0 0
0.0
0 );
glVertex2f( 1.5, 1.118 );
glVertex2f( 0.5, 1.118 );
glEnd();
}
F
Formats
t d
des commandes
d O
OpenGL
GL
glVertex3fv( args
args…
… )
Nombre de
paramêtres
2 - (x,y)
3 - (x,y,z)
4 - (x,y,z,w)
(
)
Type de données
b
ub
s
us
i
ui
f
d
-
b t
byte
unsigned byte
short
unsigned
g
short
int
unsigned int
float
d bl
double
Vector
omettre “v” pour la
forme scalaire
glVertex2f( x, y )
S é ifi des
Spécifier
d P
Primitives
i iti
Une Primitive est définie par
glBegin( primType );
glEnd();
• primType determine comment les vertices sont agencés
GLfloat red
red, green
green, blue;
Glfloat coords[3];
glBegin( primType );
for ( i = 0; i < nVerts; ++i ) {
glColor3f( red, green, blue );
glVertex3fv( coords );
}
glEnd();
OpenGL
p
Modèles
de Couleur
Polynomial
Rasterization
DL
CPU
Vertex
Per Fragment
Texture
RGBA ou Color Index
Pixel
color index mode
Red Green
Blue
0
1
2
3

24
25
26
Display
123

219
74

RGBA mode
frame
Controle de l’apparence
pp
de
rendu
Du maillage
Wireframe
Au placage
De Texture
Et t de
Etat
d Machine
M hi O
OpenGL
GL
Tous les attributs de rendu sont encapsulés
d
dans
lles “Et
“Etats”
t ”O
OpenGL
GL
• Etat du rendu
• lissage
• eclairage
l i
• Placage de Texture
M i l ti d
Manipulation
des Et
Etats
t O
OpenGL
GL
L’apparence est contrôlée par l’état courant
for each ( primitive à rendre ) {
mise à jour du “state” OpenGL
render primitive
}
La manipulation des attributs de vertices est la
solution la plus courante pour gérer les états
glColor*() / glIndex
glColor*()
glIndex*()
*()
glNormal*()
glNormal
*()
glTexCoord*()
glTexCoord
g
*()
C t l de
Controle
d l’Et
l’Etatt courantt
Definition de l’Etat
glPointSize( size ); //taille du point en
mode GL_POINTS
glLineStipple( repeat
repeat,
, pattern ); //pattern
de la ligne
glShadeModel(
lSh d M d l( GL
GL_
_SMOOTH );
) //”fi
//”fini”
i” d
du rendu
d
Activation des fonctionalités
glEnable( GL_LIGHTING );
glDisable( GL_TEXTURE_2D
_
_
);
Transformations
T
Transformations
f
ti
dans
d
OpenGL
O
GL
Modèle
Vue
• Orientation de camera
• projection
Animation
Conversion à l’écran
l écran
C
Comparaison
i
à une C
Camera
La 3D c’est comme prendre une photo (des
tas de photos)
Volume de
visualisation
i
li ti
appareil
trépied
modèle
Parallèle avec les caméras et
les Transformations
Transformations de projection
• Ajustement
Aj t
t de
d lla llentille
till
Transformations de visualisation
• Le trepied définit le volume de visualisation et l’angle de
vue
Transformations
T
f
ti
d
de Modeling
M d li g
• Déplacement du modèle
Transformations de “Viewport“
• Élargissement ou réduction de l’angle de prise de vue
Système
y
de coordonnées et
Transformations
Etapes de la conrtruction d’une image
• Spécifier
S é ifi lla géometrie
é
i ((coordonnées
d
é “
“world”)
ld”)
• Spécifier la camera (coordonnées camera)
• projet (coordonnées de la fenêtre)
• CConversion viewport
p
((coordonnées écran))
Chaque étape utilise les transformations
Chaque transformation Equivaut à un changement
de coordonnées (frames)
T
Transformations
f
ti
Affine
Affi
Utilisation de transformations qui preservent
la géometrie
• lignes,
g ,p
polygones,
yg
,q
quadrilatères….
Affine = preservation des lignes
• Rotation, translation, “scaling”
• Projection
j
• Concatenation (composition)
C
Coordonnées
d
é Homogènes
H
è
chaque vertex est représenté comme un vecteur
x 
y
  
v
z 
 
w
w est généralement 1.0
Toutes les opérations sont des multiplications de matrices
Les Directions (segments orientés) peuvent être représentés avec w
= 0.0
T
Transformations
f
ti
3D
Un vertex est transformé via une matrice 4 x 4
• toute operation
p
affine est une multiplication
p
de matrice
• Toutes les matrices sont stockées avec une priorité sur la
colonne
• Les matrices sont toujours post-multipliées
• Le produit d’une matrice et un vecteur est M v
m 0 m 4 m8
m12
m1 m5
M=
m 2 m6
m9
m10
m13
m14
m3
m11
m15
m7
Défi i une T
Définir
Transformation
f
ti
Il existe deux moyens pour spécifier les
t
transformations
f
ti
• Définir une matrice (glLoadMatrix,
glMultMatrix
lM ltM t i )
• Définir une opération (glRotate,
glRotate, glOrtho)
glOrtho
Le développeur n’a pas à se souvenir des
matrices exactes
• Vérifier l’appendice du “Red Book” (Programming
Guide)
Programmation
g
des
Transformations
Définition de la vue, emplacement et
orientation
• Positionnement de l'oeil (caméra)
(
)
• Positionnement de la géométrie 3D
Gestion des matrices
• Les ppiles de matrices ((matrice stack))
Tansformations combinées (composites)
Pipeline
p
de
transformation
CPU
Polynomial
Vertex
Rasterization
DL
Per Fragment
Texture
Pixel
object
v
e
r
t
e
x
œil
clip
Device
fenêtre
Viewport
Transform
Modelview
Matrix
Projection
Matrix
Perspective
Division
M d l i
Modelview
P j ti
Projection
A
Autres
calculs
l l à ce niveau
i
• materiau  couleur
• Mode de lissage(flat)
• Mode de rendu polygone
• « culling » des faces
• clipping
Modelview



frame
O é ti
Opérations
d
de matrices
t i
Définition de la « Matrix stack » courante
glMatrixMode( GL_MODELVIEW
GL MODELVIEW or GL_PROJECTION
GL PROJECTION )
Opérations sur la « Matrix Stack »
glLoadIdentity()//raz
glPushMatrix() //empile
glPopMatrix()//dépile
Le Viewport indique la zone de dessin à utiliser dans la
fenêtre
• Généralement le même que la taille de la fenêtre
• L' « aspect ratio » doit être le même que celui de la
transformation de projection ou l'image sera déformée
glViewport( x, y, width, height )
Transformation de Projection
Zone de visualisation “frustum »
Projection Perspective (oeil => fovy =45)
gluPerspective( fovy, aspect, zNear, zFar )
glFrustum( left, right, bottom, top, zNear, zFar )
Projection Orthogonale (//)
glOrtho( left, right, bottom, top, zNear, zFar )
gluOrtho2D(
l O h 2 ( left,
l f
right,
i h
b
bottom,
top )
• Effectue un appel à glOrtho avec arguments “z”
proche de 0
Application des transforamtions de
projection
Utilisation habituelle (pour une projection
orthogonale)
th
l )
glMatrixMode(
glMatrixMode
( GL_PROJECTION );
glLoadIdentity();
glLoadIdentity
();
glOrtho(
glOrtho
( left
left,
, right, bottom
bottom,
, top, zNear
zNear,
, zFar );
T
Transformations
f
ti
de
d point
i td
de vue
Position de la camera sur la scene
• Positioner le trepied
Pour « survoler » une scene
• Changer le point de vue et redessiner
gluLookAt(
gluLookAt
( eyex, eyey, eyez,
aimx, aimy, aimz,
upx, upy, upz )
• Le « up vector » definit le “tilt” de la caméra
• Attention aux positionnements incorrects (caméra
renversée….)
tripod
T
Transformations
f
ti
d
de « Modeling
M d li »
Déplacer l'objet
glTranslate{fd}( x,
x y,
y z )
Pivoter autour d'un axe
glRotate{fd}( angle, x, y, z )
• angle
l estt exprimé
i é en d
degrés
é
Alterer les p
proportions
p
(stretch
(
or shrink)) ou
retourner l'objet
glScale{fd}( x, y, z )
Connection: visualisation et
« Modeling »
Déplacer la caméra équivaut à déplacer tous
les objets et garder une caméra
stationnaire
Une transformation de visualisation équivaut
à plusieurs de « modeling »
gluLookAt() appelle des commandes de
transformation OpenGL en interne
Le p
projections
j
sont « left
handed »
transformations de Projection
(gluPerspective, glOrtho) sont « left
handled »
• Penser aux zones de clipping de la vue
T t le
Tout
l reste
t estt « right
i ht handed
h d d»
y
y
z+
+
left handed
right handed
x
z+
x
Utili ti courantes
Utilisation
t
3 examples de méthodes resize()
• Modifie la projection et la vue
• Géneralement appelée sur un redimensionnement
de la fenêtre
La méthode callback est définie par
glutReshapeFunc()
resize():
() Perspective
p
&
LookAt
void resize( int w, int h )
{
glViewport(
glViewport
( 0, 0, (
(GLsizei
GLsizei)
) w, (
(GLsizei
GLsizei)
) h );
glMatrixMode(
glMatrixMode
( GL_PROJECTION );
glLoadIdentity();
glLoadIdentity
();
gluPerspective(
gluPerspective
( 65.0, ((
((GLdouble
GLdouble)
) w) /
((GLdouble
((
GLdouble)
) h), 1.0, 100.0 );
glMatrixMode(
glMatrixMode
( GL
GL_MODELVIEW
MODELVIEW );
glLoadIdentity();
glLoadIdentity
();
gluLookAt(
gluLookAt
( 0.0, 0.0, 5.0,
0 0 0
0.0,
0.0,
0 0
0.0,
0
0.0, 1.0, 0.0 );
}
resize():
() Perspective
p
&
Translation
Même effet que le LookAt
void
id resize(
i ( i
int w, i
int h )
{
glViewport( 0, 0, (GLsizei) w, (GLsizei) h );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
gluPerspective( 65.0, (GLdouble) w/h,
1.0, 100.0 );
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
glTranslatef( 0.0, 0.0, -5.0 );
}
resize():
i () Ortho
O th ((partt 1)
void resize( int width, int height )
{
GLd bl aspect
GLdouble
t = (GLdouble)
(GLd bl ) width
idth / h
height;
i ht
GLdouble left = -2.5, right = 2.5;
GLdouble bottom = -2.5,
, top
p = 2.5;
;
glViewport( 0, 0, (GLsizei) w, (GLsizei) h );
glMatrixMode( GL_PROJECTION );
glLoadIdentity();
… suite sur le slide suivant …
resize():
i (): Ortho (part 2)
if ( aspect < 1.0 ) {
left /= aspect;
right /=
/ aspect;
} else {
bottom *= aspect;
top *= aspect;
}
glOrtho(
l
h ( l
left,
f
right,
i h
b
bottom, top, near, f
far )
);
glMatrixMode( GL_MODELVIEW );
glLoadIdentity();
}
Gerer les transformations
cumulées
Problème 1: object hierarchiques
• La position de l'objet courant dépend du précédent
• La main et le bras sont dépendants l'un
l un de l'autre
l autre
Solution 1: déplacer le système de
coordonnées local
Les transformation « modeling
g » déplacent
p
le système
y
de coordonnées
• OpenGL post-multiplie
post multiplie les matrices
Gerer les transformations
cumulées
Problème 2: les objets se déplacent par rapport au
« World »
• Mes object tournent autour d'un axe faussé donc on veut les
fixer autour de leur centre propre
Solution 2: fixer le système de coordonnées
• les transformations agissent sur l’objet
l objet autour d’un
d un système
de coordonnées fixes
• pre-multiplie les matrices matrices
• OpenGL post-multiplie les matrices
• On doit pprendre les coordonnées dans l’ordre inverse ppour
obtenir l’effet désiré
Récuperer
p
une coordonnée
écran depuis la projection
De l’écran vers le world
glGetIntegerv( GL_VIEWPORT, GLint viewport[4] )
glGetDoublev( GL_MODELVIEW_MATRIX, GLdouble
mvmatrix[16] )
glGetDoublev( GL_PROJECTION_MATRIX,
GLdouble projmatrix[16] )
gluUnProject( GLdouble winx
winx, winy
winy, winz
winz,
mvmatrix[16], projmatrix[16],
GLint viewport[4],
GLdouble *objx
*objx, *objy
*objy, *objz )
gluProject va du world vers l’écran
Animation et Depth Buffering
A i ti and
Animation
dD
Depth
th B
Buffering
ff i
Gestion du double buffering
Masquage de zone est test de profondeur
Double
Buffering
Polynomial
CPU
Vertex
Rasterization
DL
Texture
Pixel
Front
Buffer
Back
Buffer
Swap
Buffer
Display
Per Fragment
frame
Utili ti du
Utilisation
d d
double
bl b
buffering
ff i
Activation à la création du device
glutInitDisplayMode
glutInitDisplayMode(
l
i i l
d ( G
GLUT_RGB
G | G
GLUT_DOUBLE
O
)
);
Nettoyage du « color buffer »
glClear(
glClear
( GL_COLOR_BUFFER_BIT );
Rendu de la scene
Récupération du back buffer
glutSwapBuffers();
Répeter les points 2 et 4 pour l’animation
Depth
p Buffering
g et supression
p
de
géométrie cachée
Color
Buffer
Depth
Buffer
Di l
Display
D th Buffer
Depth
B ff ett Open
O
GL
créer le Depth Buffering
glutInitDisplayMode
glutInitDisplayMode(
l tI itDi l M d ( GLUT_RGB
GLUT RGB |
GLUT_DOUBLE | GLUT_DEPTH );
A ti ti d
Activation
du ttestt d
de profondeur
f d
glEnable(
glEnable
( GL_DEPTH_TEST );
Nettoyage des 2 buffers
glClear(
glClear
g
( GL_COLOR_BUFFER_BIT
_
_
_
|
GL_DEPTH_BUFFER_BIT );
Rendu de la scene
Swap du back buffer vers le front
Et on ét
étoffe
ff
void main( int argc, char** argv )
{
glutInit( &argc, argv );
glutInitDisplayMode( GLUT_RGB |
GLUT_DOUBLE
GLUT DOUBLE | GLUT
GLUT_DEPTH
DEPTH );
glutCreateWindow( “Tetrahedron” );
init();
glutIdleFunc( idle );
glutDisplayFunc(
g
p y
display
p y );
glutMainLoop();
}
Et on etoffe
t ff ((encore.))
void init( void )
{
glClearColor( 0.0, 0.0, 1.0, 1.0 );
}
void
id idl
idle(
( void
id )
{
glutPostRedisplay();
g
p y();
}
Et on etoffe
t ff (t
(toujours…)
j
)
void drawScene( void )
{
GLfloat vertices[] = { … };
GLfloat colors[] = { … };
glClear( GL
GL_COLOR_BUFFER_BIT
COLOR BUFFER BIT |
GL_DEPTH_BUFFER_BIT );
glBegin( GL_TRIANGLE_STRIP );
/* calls to glColor*() and glVertex*() */
glEnd();
glutSwapBuffers();
}
Eclairage
P i i de
Principe
d l’é
l’éclairage
l i
L ’éclairage simule le comportement des objets vis
vis-à-vis
i d’une
d’
source lumineuse
l i
en ffonction
ti
• Du materiau de l’objet
• De la position et couleur de la source
• Des pparamêtres « ambient »
• Lumière ambiante
• Éclairage
g « two sided »
• Disponible pour les 2 modes de couleur
C
Comment
t Opengl
O
l gère
è la
l llumière
iè
Eclairage phong
• Géré par vertex
La lumière dépend de :
• Les propriétés du matériau
• La lumière
• Le « Lightning model »
Polynomial
L normales
Les
l
CPU
Vertex
Rasterization
DL
Per Fragment
Texture
Pixel
Une normale définit comment la surface
reflète la lumière
glNormal3f( x, y, z )
• La normale est utilisée pour définir la couleur du vertice
• Utilisation de vecteurs normés
• Le Scale agit sur la taille de la normale
glEnable( GL_NORMALIZE
GL NORMALIZE )
ou
glEnable( GL_RESCALE_NORMAL )
frame
P
Propriétés
iété d
du materiau
t i
Définit les propriétés de surface de la primitive
glMaterialfv( face, property, value );
GL_DIFFUSE
Base color
GL_SPECULAR
Highlight Color
GL_AMBIENT
Low-light
g Color
GL_EMISSION
Glow Color
GL SHININESS
GL_SHININESS
Surface Smoothness
• On peut définir un matériau par côté de la face
P
Propriétés
iété d
de lla llumière
iè
glLightfv( light, property, value );
• light spécifie
é ifi quelle
ll est lla lumière
l iè défi
définie
i
• Gestion de plusieurs sources, la première étant
GL_LIGHT0
glGetIntegerv( GL_MAX_LIGHTS, &n );
• propriétés
• couleur
couleu
• position et type
• atténuation
T
Type
de
d propriétés
iété
• GL_AMBIENT
• GL_DIFFUSE
GL DIFFUSE
• GL_SPECULAR
T
Types
de
d lumières
l iè
OpenGL supporte 2 types de sources
• Locales (Point)
• Infinies (Directionnelles)
Controlées par les coordonnées w
x
w= 0
lumière infinie dirigée selon
w0
lumière locale positionné e à  xw
y
yw
z
zw s
A ti ti d’
Activation
d’une source
On branche la source
glEnable( GL_LIGHT
GL_LIGHTn
n );
Et on allume
ll
glEnable( GL_LIGHTING
g
_
);
G ti de
Gestion
d lla source d
de llumière
iè
La matrice ModelView affecte la position de
la lumière
• Plusieurs effets sont basés dessus
• Coordonnées de camera
• Coordonnées World
• Coordonnées du modèle
• Utilisation du « pushing » et « poping » de matrices
pour affecter la position de lumière seulement
F
Fonction
ti d
de lluminaires
i i
avancées
é
Spotlights
•GL_SPOT_DIRECTION
•GL_SPOT_CUTOFF
•GL_SPOT_EXPONENT
F
Fonctions
ti
avancées
é suite
it
Attenuation de la source
• Diminue l’intensité avec la distance
•GL_CONSTANT_ATTENUATION
GL CONSTANT ATTENUATION
•GL_LINEAR_ATTENUATION
•GL_QUADRATIC_ATTENUATION
GL QUADRATIC ATTENUATION
Propriétés
p
du gestionnaire
g
de
lumières
glLightModelfv( property, value );
Activation du mode de lumière sur les 2 faces
GL_LIGHT_MODEL_TWO_SIDE
Couleur
C l
globale
l b l de
d l’ambient
l’ bi t
GL_LIGHT_MODEL_AMBIENT
Local viewer mode
GL_LIGHT_MODEL_LOCAL_VIEWER
Couleur specular séparée
GL_LIGHT_MODEL_COLOR_CONTROL
Ti sur lles llumières
Tips
iè
L’éclairage est calculé par vertex
• La tesselation augmente la qualité de rendu
• Meilleur résultat mais moins bonne performances
Une lumière infinie est plus rapide pour le
rendu
• La determination de la luminosité par vertex est
plus simple
Les images et la rasterisation
Pi l b
Pixel-based
d primitives
i iti
Bitmaps
• Tableau 2D de bit de masquage pour les pixels
• La couleur du pixel mis à jour dépend de la couleur courante
( lC l )
(glColor)
Images
• Tableau 2D de l’ensemble des informations de couleur
• Information complète pour chaque pixel
OpenGL ne gère pas le chargement des images
Polynomial
Pi l Pi
Pixel
Pipeline
li
Vertex
Rasterization
DL
CPU
Per Fragment
frame
Texture
Pixel
Stockage de pixel programmable et
operations de transfert
glBitmap(), glDrawPixels()
CPU
Pixell
Pi
Storage
Modes
Pixel-Transfer
Pi
lT
f
Operations
(and Pixel Map)
Rasterization
R
t i ti
(including
Pixel Zoom)
Texture
Memory
Per Fragment
Operations
glCopyTex*Image();
glReadPixels(), glCopyPixels()
Frame
Buffer
Positionnement de primitives
p
image
glRasterPos3f( x, y, z )
• Les positions de « rasterisation » sont affectées par
les transformations comme les vertices
• N’est pas effectuée quand
la Raster position est hors
de la zone de clipping
Raster Position
R d i Bitmaps
Rendering
Bit
glBitmap( width, height, xorig, yorig, xmove,
ymove, bitmap )
height
• Rend le bitmap dans la couleur
courante à x  xorig   y  yorig 
Avance la position de
yorig
après
le
rendu
xmove ymove
width
xorig
xmove
Rendu des Polices avec les
Bitmaps
OpenGL utilise les bitmaps pour le rendu des
polices
• Chaque
q caractère est contenu dans une « display
p y
list » qui contient un bitmap
• Méthodes spécifiques du « window manager » pour
acceder aux polices système
• glXUseXFont()
• wglUseFontBitmaps()
• glutBitmapCharacter() / glutBitmapString()
F
Format
td
des iimages
glDrawPixels( width, height, format, type,
pixels )
• Rendu de l’image par le bord
bas droit à la « raster position »
• Nombreux formats types de
données pour spécifier le stockage
en mémoire
• On
O améliore
éli
les
l performances
f
en utilisant
tili t d
des ttypes
et formats en corrélation avec le matériel
L t
Lecture
d
des pixels
i l
glReadPixels( x,
x y
y, width
width, height
height, format
format,
type, pixels )
• lit les pixels contenus dans le framebuffer à la
position spécifiée par (x,y)
• Les pixels contenus dans le framebuffer sont
automatiquement convertis dans le type demandé
Copie
C i de
d pixels
i l dans
d
le
l fframebuffer
b ff
glCopyPixels( x, y, width, height, type )
• Les pixels sont copiés du framebuffer directement
vers la « raster position »
Pi l Z
Pixel
Zoom
glPixelZoom( x, y )
• Étend, réduit ou « reflète » les pixels
autour de la « raster position » courante
Raster
Position
glPixelZoom(1.0,
g
(
, -1.0);
)
Texture Mapping
Texture
Mapping
Poly.
CPU
Per
Vertex
Raster
DL
Frag
FB
Texture
Pixel
Applique une image 1D
1D, 2D ou 3D à une
primitive de géométrie
Utilisations
U ili i
d
des textures
• Simulation de structure du matériau
• Reduction de la complexité des objets
• Reflections
R fl i
(
(avec
lle stencil
il b
buffer)
ff )
Texture Mapping
geometrie
y
z
x
image
écran
Texture Mapping
pp g et le Pipeline
p
OpenGL
Les images et la géometrie sont gérés indépendament et
sont assemblées par la « rasterisation »
• Les textures « complexes » n’affectent pas la
complexité du modèle
vertices
geometry pipeline
rasterizer
image
pixel pipeline
Pl
Placage
d
de ttexture
t
I
Trois étapes
Spécifier une texture
•
•
•
Lire ou génerer une image
Assigner la texture
Activer la texture
Attribuer des coordonnées de textures aux vertices
Spécifier les paramètres de la texture
•
wrapping,
pp g, filtering
g
Pl
Placage
de
d ttexture
t
II
• Specifier les images aux objets texture
• Définir le filtre
• Définir la fonction de texture
• Définir le « wrap mode »
• « bind » de l’objet
l objet texture
• Activation du texturing
• Fournir les coordonnées de textures par vertex
Elles peuvent également être générées
Obj t texture
Objet
t t
Les « emplacements » des textures sont générés
par la
l carte
t
• Un identifiant par objet texture
• Peut
P
être
ê
partagé
é par plusieurs
l i
d i
devices
Generation de la texture
glGenTextures(
glGenTextures
(
n, *texIds
L Ids
Les
Id générés
é é é ne sontt pas contigus
ti
=> on p
passe par
p un tableau
);
Obj t ttexture
Objet
t
((suite.)
it )
Alimentation de l’objet avec des données et des
paramêtre
êt
glBindTexture(
target, id
);
Ou la même avant d’afficher une primitive
glBindTexture(
t
target,
t id
);
Specifier
p
une image
Poly.
CPU
Per
Vertex
Raster
DL
Frag
FB
Texture
Pixel
Definit une image pour la
l texture à partir
d’un tableau de Textels en mémoire
glTexImage2D( target
target,
, level
level,
, components,
w, h, border, format, type, *texels
*texels );
• Les dimensions de l’image doivent être
puissance de 2
La couleur de Texels sont gérées pas le
Pipeline
l
Pixell
C
Convertir
ti une iimage d
de ttexture
t
Si les dimensions ne sont pas multiples de 2
gluScaleImage(
gluScaleImage
( format, w_in
w_in,
, h_in
h_in,
,
type_in, *
type_in,
*data_in
data_in,
, w_out
w_out,
, h_out
h_out,
,
t
type_out,
type_out
t, *data_out
*data_out
d t
t );
)
• *_in pour l’image source
• *_out pour l’image destination
L’image est interpolée et filtrée lors du Scaling
Definir une texture :
autre méthodes
Utliser le frame buffer comme source pour la texture
• Utilise
Utili lle b
buffer
ff courantt pour source
glCopyTexImage1D(...)
glCopyTexImage2D(...)
l
2 (
)
Modification d’une partie de l’image existante
glTexSubImage1D(...)
glTexSubImage2D(...)
glTexSubImage3D(...)
Et faire les 2 avec glCopyTexSubImage2D(...), etc.
Placage
g de
texture
Poly.
CPU
Per
Vertex
Raster
DL
Frag
FB
Texture
Pixel
Basé sur les coordonnées paramétriques passées à
chaque
h
vertex
t par glTexCoord*()
lT C
d*()
t
0, 1
Espace texture
1, 1
(s, t) = (0.2, 0.8)
A
a
b
0, 0
Object Space
(0 4 00.2)
(0.4,
2)
c
B
1, 0
s
C
(0 8 00.4)
(0.8,
4)
Génération des coordonnées de
texture
Génération automatique des coordonnées de
glTexGen{ifd}[v]()
lT G {ifd}[ ]()
Définition de la surface
• Génère les coordonnées de texture de la surface en fonction
de la distance par rapport à un plan
Mode
d de
d génération
• GL_OBJECT_LINEAR
• GL_EYE_LINEAR
• GL_SPHERE_MAP
_
_
Ax + By + Cz + D = 0
M d d’application
Modes
d’
li ti de
d lla ttexture
t
Modes de filtrage
• minification ou magnification
• mipmaping
Modes Wrap
• clamping ou repeating
Texture Functions
• Mode de mélange des couleurs de texture et de l’objet
• blend, modulate ou emplacement de texels
M d de
Mode
d filtrage
filt
Example:
glTexParameteri(
lT P
t i( target,
t
t t
type, mode
d );
)
Texture
Polygone
Magnification
Texture
Polygone
Minification
T t
Textures
ett Mi
MipMapping
M
i
Le mipmap est utilisé afin de donner une liste de
résolutions différentes en fonction du point de vue
(effet bouillie de pixels lié à la perspective)
Déclaration du niveau de mipmapping lors de la création
de la texture (jouer sur le level)
glTexImage*D( GL_TEXTURE_*D, level, … )
Géneration mipmap par le GLU builder
gluBuild*DMipmaps( … )
W
Wrapping
i M
Mode
d
Exemple:
glTexParameteri( GL_TEXTURE_2D,
glTexParameteri(
GL_TEXTURE_WRAP_S, GL_CLAMP )
glTexParameteri( GL_TEXTURE_2D,
glTexParameteri(
GL_TEXTURE_WRAP_T, GL_REPEAT )
t
s
t t
texture
GL_REPEAT
wrapping
GL_CLAMP
wrapping
F
Fonction
ti d
de ttextures
t
Contrôle comment les textures sont appliquées
glTexEnv{fi}[v]( GL_TEXTURE_ENV, prop, param )
GL_TEXTURE_ENV_MODE modes
• GL_MODULATE
• GL_BLEND
• GL_REPLACE
Définition
Défi iti d
de lla couleur
l
d
de Bl
Blend
d avec
GL_TEXTURE_ENV_COLOR
C
Correction
ti d
de perspective
ti
Les coordonnées de texture et l’interpolation de
couleur est faite soit par
• Système linéraire en fonction de la vue
• Soit en utilisant la perspective
Utile pour les polygones “on edge”
glHint( GL_PERSPECTIVE_CORRECTION_HINT, hint )
hint peut être
• GL_DONT_CARE
• GL_NICEST
• GL_FASTEST
OpenGL Avancé
Mode Immédiat versus Mode
« Display List »
Mode « Immédiat »
• Les données sont envoyées au vertex pipeline et rendues au fur et
à mesure
• Le Pipeline nn’aa aucune mémoire des entités déssinées
Mode « Display List »
• Les primitives sont placées dans des liste dd’affichage
affichage
• Une display list est compilée et stockée sur le serveur graphique
• Peuvent être redessinées en utilisant un mode OpenGL différent
• Peuvent être partagées par plusieurs « contextes graphiques
OpenGL
p
»
Mode Immédiat versus Mode
« Display List »
Immediate Mode
Polynomial
Evaluator
CPU
Display
List
Per Vertex
Operations &
Primitive
Assembly
Rasterization
Display
p y Listed
Pixel
Operations
Texture
Memor
y
Per Fragment
Operations
Frame
Buffer
Display List
Poly.
CPU
Per
Vertex
Raster
DL
Frag
FB
Texture
Pixel
Création d’une Liste
GLuint
i
id
id;
void init
init(
( void )
{
id = glGenLists
glGenLists(
( 1 ); //indices générés contigus
glNewList(
glNewList
( id, GL_COMPILE );
/* other OpenGL routines */
glEndList
g
glEndList();
d st();
st();
}
Appel de la Liste ainsi créée
void display( void )
{
glCallList(
glCallList
( id );
}
Di l Lists
Display
Li t
Il n’est pas possible de stocker toutes les
fonctions OpenGl dans la display List
Les changements d’état persistent même après la
fin d
d’une
une Display List
Une Display List peut en cacher une autre
Les
L Di
Display
l liste,
li t bi
bien que non édit
éditables
bl peuventt
être « trompées »
• Créer
C é une li
liste
t (A) quii appelle
ll d’
d’autre
t li
listes
t (B
(B, C
C, and
d D)
• Supprimer et remplacer B, C, and D, selon le besoin
Di l Li t ett lla hié
DisplayList
hiérarchie
hi
Sur la base d’un modèle voiture
• Créer une display list pour le chassis
• Créer une display list pour une roue
glNewList( CAR, GL_COMPILE );
glCallList( CHASSIS );
glTranslatef( … );
glCallList( WHEEL );
glTranslatef( … );
glCallList(
lC llLi t( WHEEL )
);
…
glEndList();
Bl di
Blending
Permet de simuler des effets en cumulant
des
d informations
i f
ti
déjà présentes
é
t dans
d
le
l «
Color Buffer » avec des information à
afficher
Souvent utilisé avec la composante Alpha et
en particulier dans le cadre de la
transparence des primitives
glEnable( GL_BLEND )
D fi iti du
Definition
d Bl
Blending
di
Le Blending permet d’ecrire dans le « Color
Buffer » sans remplacer la donnée existante
• La source est la donnée à afficher
• La destination est la donnée déjà présente dans le buffer.
Le Blending de fait se lon une formule précise
• srcColor*srcFactor + destColor*destFactor
F t
Facteurs
d
de Bl
Blending
di
glBlendFunc( srcFactor, destFactor)
destFactor)
Permet de définir les facteurs agissant sur la source
et la destination lors du blending
• Certains paramètres ne sont applicables qu’à la source ou à la
destination
Les 2 : GL_ZERO, GL_ONE, GL_SRC_ALPHA,
GL_ONE_MINUS_SRC_ALPHA…
Source
S
: GL
GL_DST_COLOR,
DST COLOR GL_ONE_MINUS_DST_COLOR,
GL ONE MINUS DST COLOR
GL_SRC_ALPHA_SATURATE
Destination : GL
GL_SRC_COLOR,
SRC COLOR, GL
GL_ONE_MINUS_SRC_COLOR
ONE MINUS SRC COLOR
Blending et Transparence
Le blending
bl d
est utilisé
l é fréquemment
f é
pour simuler
l des
d objets
b
transparents. glBlendFunc( GL_SRC_ALPHA,
GL_ONE_MINUS_SRC_ALPHA)
GL_ONE_MINUS_SRC_ALPHA
)
En cas de présence de plusieurs objets transparents dans
peuvent se cacher mutuellement à cause du
une scène, il p
t td
test
de D
Depth
th Buffering.
B ff i
La technique
q consiste à :
• Activer le Depth test
• Dessiner les objets opaque
• Passer le Depth buffer en lecture seule
- glDepthMask(false); //evite la modification du zbuffer
• Dessiner les objets « transparents »
• Restaurer l’état du Depth Buffer glDepthMask(true);
C t ôl du
Contrôle
d St
Stencil
il B
Buffer
ff
glStencilFunc( func, ref, mask )
• Compare les valeurs du buffer avec ref en fonction de
func
• Appliquéé uniquement aux valeurs mask qui sont sur 1
• func est une des fonction de comparaison standard
glStencilOp( fail, zfail, zpass )
• Autorise les modifications du Stencil Buffer en
fonction du résultat : GL_KEEP, GL_INCR
C é ti d
Création
du masque
glInitDisplayMode( …|GLUT_STENCIL|… );
glEnable( GL
GL_STENCIL_TEST
STENCIL TEST )
);
glClearStencil( 0x0 );
glStencilFunc( GL_ALWAYS, 0x1, 0x1 );
glStencilOp( GL_REPLACE,
GL REPLACE GL
GL_REPLACE,
REPLACE
GL_REPLACE );
(dessin du masque)
Utili ti d
Utilisation
du stencil
t
il b
buffer
ff
Affiche les objets dont le stencil = 1
glStencilFunc( GL_EQUAL, 0x1, 0x1 )
Affiche les objets dont le stencil != 1
glStencilFunc( GL_NOTEQUAL, 0x1, 0x1 );
glStencilOp(
l
il ( GL_KEEP, GL_KEEP, GL_KEEP );
)
M d Selection
Mode
S l ti
• Methode pour determiner quelles
primitives
i iti
sontt à l’i
l’intérieur
té i
d
du volume
l
d
de
visualisation
• Nécessité de définir un buffer en vue de
récuperer les résultats du picking
• glSelectBuffer( size, buffer )
• Changer
Ch g le
l mode
d de
d Rendu
R d en « Select
S l t»
• glRenderMode( GL_SELECT )
M d Selection
Mode
S l ti
• Pour pouvoir identifier une primitive il faut la
nommer
• Les “noms” sont des entiers, pas des chaines
Les noms sont basés sur un système de pile
• Définition de hiérarchies de nom ppar empilement
p
Méthodes de nommage
glInitNames()
glInitNames
() //activation de la pile de noms
glPushName(
glPushName
( name ) / glPopName
glPopName(
( name )
glLoadName(
glLoadName
g
( name )//
)//remplace
p
le nom en haut de la p
pile
Pi ki
Picking
Le Picking est une type particulier de sélection
Etapes de programmations
• Réduire « l’affichage » à une zone réduite autour de la zone
de click
Utilisation de gluPickMatrix() sur la matrice de
projections
• Renseigner le mode de sélection, re-rendre la scene
• Les primitives dessinées près dur curseurs déclenchent le
« hit
h »
• Sortir de la sélection et analyser les résultats
Example de Picking
• glutMouseFunc( pickMe );
• void pickMe( int button, int state, int x, int y
)
{
•
GL i t selectBuffer[256];
GLuint
l tB ff [256]
•
GLint hits;
•
GLint myViewport[4];
•
if (button != GLUT_LEFT_BUTTON
GLUT LEFT BUTTON ||
•
state != GLUT_DOWN) return;
•
glGetIntegerv( GL_VIEWPORT, myViewport );
glSelectBuffer( 256
256, selectBuffer );
•
(void) glRenderMode( GL_SELECT );
•
GlInitNames();
E
Example
l de
d Picking
Pi ki ((suite…)
it )
•
•
•
•
•
glMatrixMode(
lM t i M d ( GL_PROJECTION
GL PROJECTION )
);
glPushMatrix();
glLoadIdentity();
g
y();
gluPickMatrix( (GLdouble) x, (GLdouble)
(myViewport[3](myViewport[3]
-y), 5.0, 5.0, myViewport
);
• /*
*/
gluPerspective or glOrtho or other projection
•
glPushName( 1 );
• /*
draw something */
•
glLoadName( 2 );
g
• /*
draw something else … continue …
*/
E ample de Picking (fin!)
Example
•
glMatrixMode( GL_PROJECTION );
•
glPopMatrix();
g op at
();
•
hits = glRenderMode( GL_RENDER );
• /*
process selectBuffer */
• }
O ti i ti d
Optimisation
du Pi
Picking
ki
• Pour un Picking plus efficace
•N
N’effectuer
effectuer le rendu que de ce qu’on
qu on peut « Picker »
• Utilisation de primitives simples (boundbox, boundsheres,
rectangles pour du texte)
• Si plusieurs primitives sont dessinées dans la zone de
picking, il est difficile de trier sur le z-order
http://www.developpez.net/forums/d666331/applications/developpementhttp://www.developpez.net/forums/d666331/applications/developpement2d2d
-3d
3d-jeux/contribuez/source
jeux/contribuez/source-opengl
opengl-picking/