Introduction OpenGL

1
Introduction à OpenGL

• Sébastien Kuntz
• Sebastien.kuntz_at_nowan.net

2
OpenGL

• Buts
• De la formation
• De la séance
• Introduction
• Présentation
• Origine
• Composants
• OpenGL
• Bases
• Machine à état
• Transformations

3
Buts

• Buts de la formation
• Comprendre ce quest OpenGL
• Comprendre les mécanismes de rendu 3d
• Savoir écrire un programme 3d
• Acquérir des bases pour être autonome

4
Buts

• Buts de la séance
• Comprendre ce quOpenGL peut faire pour vous
• Connaître les différents composants
• Comprendre comment OpenGL gère la 3d

5
OpenGL Introduction / Présentation

• OpenGL API de programmation 2D et 3D
• Standard dans l'industrie
• Crée par Silicon Graphics
• Developpé par lArchitecture Review Board
• Performance
• Souplesse
• Portabilité
• Evolutivité et Stabilité de lAPI
• Robustesse

6
OpenGL Introduction / Composants

• Primitives géometriques
• Points, lignes et polygones
• Primitives dimage
• Images
• Pixels
• Le rendu de limage dépend de létat
• de la couleur
• des materiaux
• des sources lumineuses
• etc..

7
OpenGL Introduction / Composants

• OpenGL crée les images
• Fenêtres et E/S sont spécifiques à un OS
• GLUT ( GL Utility ) simple et portable
• SDL Genre de DirectX Portable
• Api Windows, Api X
• OpenGL est bas niveau
• Haut niveau construit par dessus
• OpenSceneGraph, GLU, Performer ..

8
OpenGL / Les bases

• Les bases
• Un exemple simple
• Syntaxe des fonctions
• Primitives
• Passons à la 3ème Dimension !

9
OpenGL / Bases / Un exemple simple

• Un exemple simple Afficher un carré

include ltwhateverYouNeed.hgt main()   
OpenAWindowPlease()    glClearColor(0.0, 0.0,
0.0, 0.0)    glClear(GL_COLOR_BUFFER_BIT)   
glColor3f(1.0, 1.0, 1.0)    glOrtho(-1.0, 1.0,
-1.0, 1.0, -1.0, 1.0)     glBegin(GL_POLYGON)   
    glVertex2f(-0.5, -0.5)      
glVertex2f(-0.5, 0.5)       glVertex2f(0.5,
0.5)       glVertex2f(0.5, -0.5)    glEnd()   
KeepTheWindowOnTheScreenForAWhile()
10
OpenGL / Bases / Syntaxe

• Syntaxe des fonctions

Draw() // 3 flottants pour une
couleur glColor3f(1.0, 0.0, 0.0) float
color_array 1.0, 0.0, 0.0 // un vecteur
de 3 flottants glColor3fv(color_array) // 2
entiers glVertex2i( 1, 3 ) // 3 doubles
glVertex3d( 0.3214, 0.4321, 0.0 )
11
OpenGL / Bases / Syntaxe

• OpenGL est une machine à états
• Choisir un état
• glPointSize( size )
• glColor3f( 1.0, 0.0, 0.0 )
• glLight..
• Activer ou désactiver des propriétés
• glEnable( GL_LIGHTING )
• glDisable( GL_TEXTURE_2D )
• L'affichage des primitives dépend de l'état
  courant de l'ensemble des attributs

12
OpenGL / Bases / Axes Repères

• Repérage dans lespace
• OpenGL définit ses axes par rapport à lécran

x
13
OpenGL / Bases / Primitives

• OpenGL fournit des primitives d'affichage
• Lignes
• Polygones
• Doivent etre simples
• Pas convexes
• Sans trous'
• Sur un seul plan

14
OpenGL / Bases / Primitives
15
OpenGL / Bases / Primitives

• Comment utiliser ces primitives ?
• la plus simple glBegin / glEnd

glBegin(GL_POLYGON)    glVertex2f(0.0, 0.0)   
glVertex2f(0.0, 3.0)    glVertex2f(3.0, 3.0)   
glVertex2f(4.0, 1.5)    glVertex2f(3.0,
0.0) glEnd()
16
OpenGL / Bases / Primitives

• Toutes les commandes ne sont pas valides dans
  glBegin/glEnd
• Commandes valides
• glVertex, glColor, glIndex, glSecondaryColor,
  glNormal, glMaterial, glFogCoord, glTexCoord,
  glMultiTexCoord, glEdgeFlag, glArrayElement,
  glEvalCoord, glEvalPoint, glCallList

17
OpenGL / Bases / Couleurs

• glColor( R,G,B ,A )

glBegin(GL_TRIANGLES) glColor3f(1.0f, 0.0f,
0.0f)    glVertex3f(0.0f, 0.0, 0.0) //A
glColor3f(0.0f, 1.0f, 0.0f)    glVertex3f(-1.0f,
-1.0f, 0.0f) //B glColor3f(0.0f, 0.0f,
1.0f) glVertex3f(1.0f, -1.0f, 0.0f)
//C glEnd()
18
OpenGL / Bases / 3D

• Passons à la 3ème dimension !
• Un vertex, des vertices un point en 3D
• Vecteur Normal
• Perpendiculaire à une surface
• Définit son orientation
• Une seule normale pour une surface plane
• Surface quelconque une normale par point

19
OpenGL / Bases / Normales

• Le rendu des lumières a besoin des normales
• Une normale par primitive ou par vertex
  glNormal3f(x,y,z)
• Les normales DOIVENT etre unitaires

20
OpenGL / Bases

• Afficher un cube

glBegin(GL_QUADS) Pour chaque face
glColor3f(r,g,b) glNormal3f( Nx, Ny, Nz )
glVertex3f( x1, y1, z1) glVertex3f( x2, y2,
z2) glVertex3f( x3, y3, z3) glVertex3f( x4, y4,
z4) Fin glEnd()
21
OpenGl / Bases / Display Lists

• les Display Lists (D.L) permettent de stocker
  les commandes OpenGL pour de meilleures
  performances
• GLuint list
• void init( void )
• list glGenLists(1)
• glNewList( list, GL_COMPILE )
• glBegin( .. ) glVertex( .. ) ... glEnd()
• glEndList()
• void display( void )
• glClear( GL_COLOR_BUFFER_BIT )
• glCallList( list )
• Une D.L. ne peut pas etre modifiée
• Possibilité d'encapsuler plusieurs niveaux de D.L.

22
OpenGl / Bases / Display Lists

• Gluint glGenLists( Glsizei n )
• alloue n indices de D.L.
• retourne le nb d'indices crées
• glNewList( Gluint list, Glenum mode )
• précise le début d'une D.L.
• mode GL_COMPILE, GL_COMPILE_AND_EXECUTE
• glEndList()
• glDeleteLists()
• glCallList( Gluint list )

23
OpenGL / Transformations
24
OpenGL / Transformations

• Plan
• Fonctions de transformation
• Exemple
• Piles de matrices
• Corrélation transformation / matrice
• Comment afficher un point 3d sur un écran 2d ?
• Opérations mathématiques
• Opérations en OpenGL

25
OpenGL / Transformations

• Fonctions de transformations
• Déplacer un objet
• glTranslatefd( x, y, z )
• Tourner un objet autour dun axe
• glRotatefd( angle, x, y, z )
• angle en degrés !
• Agrandir, retrécir ou inverser un objet
• glScalefd( x, y, z )

26
OpenGL / Transformations

• Exemple
• glMatrixMode(GL_MODELVIEW)
• glLoadIdentity()
• glTranslate(1.0,0.0,0.0)
• DrawSphere()
• glTranslate(1.0,0.0,0.0)
• DrawCarre()

27
OpenGL / Transformations

• Tout se passe comme si OpenGL change de repère
• On dessine les objets par rapport à ce nouveau
  repère

28
OpenGL / Transformation

• Corrélation transformations / matrices
• Chaque transformation peut être représentée par
  une matrice.

29
OpenGL / Transformations / Pile de matrices

• glPushMatrix, glPopMatrix
• sauvegarde et restitue le repère courant
• glMatrixMode(GL_MODELVIEW)
• glLoadIdentity()
• glTranslatef( 1,0,0 )
• // sauvegarde la position actuelle
• glPushMatrix()
• drawCube()
• glTranslatef( 1,0,0 )
• drawSphere()
• // restitue la dernière
• //position sauvegardée
• glPopMatrix()
• glTranslatef(0,1,0)
• drawTriangle()
• Sauvegarde dans une pile

30
OpenGL / Transformations

• Hiérarchie
• glMatrixMode(GL_MODELVIEW)
• glLoadIdentity()
• glPushMatrix()
• glTranslate( x,y,z )
• drawCorps()
• glMultMatrix( transf_bras )
• drawBras()
• glMultMatrix( transf_avant_bras )
• drawAvantBras()
• glMultMatrix( transf_main )
• drawMain()
• glPopMatrix()

31
OpenGL / Transformations

• Une matrice est associée au repère courant
• la matrice ModelView représente la transformation
  du repère original vers le repère courant
• Appliquer une transformation revient à multiplier
  la matrice courante par la matrice de la
  transformation
• // on va modifier la matrice du repère
• glMatrixMode(GL_MODELVIEW)
• glLoadIdentity()
• glTranslatef(1,0,0)
• glRotatef(90,1,0,0)

32
OpenGL / Transformations

• glTranslate, glRotate et glScale multiplient la
  matrice courante par la matrice associée à la
  transformation
• On peut créer une matrice à la main
• glLoadMatrixf(GLfloat m)
• glMultMatrixf(GLfloat m)
• !! Attention, les matrices sont stockées par
  colonne !!
• GLfloat m16 a0, a1, , a15

33
OpenGL / Transformations

• Comment sont appliquées ces transformations?
• Calculer la position absolue dun vertex

34
OpenGL / Transformations

• Exemple de transformations
• Translater un point
• Translater puis tourner un point
• Ce qui se traduit en OpenGl par
• glMatrixMode(GL_MODELVIEW)
• glLoadIdentity()
• glRotatef(90,1,0,0)
• glTranslatef(1,0,0)
• draw_object()

35
OpenGL / Transformations

• Deux façons de voir les transformations
• Dans lordre indiqué, la multiplication des
  matrices modifie un repère local
• Les objets sont dessinés dans le repère local
• Permet de mieux appréhender la hiérarchisation
• Chaque matrice est une  matrice de changement de
  repère 
• Dans lordre opposé, la multiplication des
  matrices modifie la position, lorientation ou la
  taille dun objet
• Les objets sont dessinés dans un repère global
  fixe
• Le code est le même, il nya que la façon de le
  voir qui change

36
OpenGL / Combiner transformations

• Ordre des transformations
• Ordre critique !
• Multiplication de matrices non commutatif
• glMatrixMode(GL_MODELVIEW)
• glLoadIdentity()
• / translation /
• glTranslatef(1,0,0)
• / rotation /
• glRotatef(45,0,0,1)
• draw_the_object()

37
OpenGL / 3d -gt Ecran

• Comment transformer un point en 3d pour
  lafficher sur un écran 2d?

38
OpenGL / Transformations

• Analogie avec un appareil photo
• Positionner et orienter lappareil
• Viewing transformation
• Placer les objets quon veut photographier
• Modeling transformation
• Choisir une lentille et/ou ajuster le zoom
• Projection transformation
• Choisir la taille de la photo développée
• Viewport transformation

39
OpenGL / Transformations
40
OpenGL / Transformations

• Opérations mathématiques
• Chaque transformation correspond à un changement
  de repère

41
OpenGL / Transformations

• Opérations en OpenGL
• La model matrix et la view matrix sont combinées
• Bouger la camera est équivalent à bouger chaque
  objet dans lautre sens
• ModelView Matrix
• glMatrixMode permet de choisir la matrice
  courante
• GL_PROJECTION, GL_MODELVIEW, GL_TEXTURE

42
OpenGL / Transformations / Projection

• La matrice de projection définit la forme du
  frustum
• Perspective projection
• gluPerspective( FOVy, aspect, zNear, zFar )
• glFrustum( left, right, bottom, top, zNear, zFar
  )
• Orthographic parallel projection
• glOrtho( left, right, bottom, top, zNear, zFar)
• gluOrtho2D( left, right, bottom, top )

43
OpenGL / Transformations

• Préparer la scène
• // On va choisir la matrice de projection
• glMatrixMode( GL_PROJECTION )
• // et on la spécifie
• glOrtho( left, right, bottom, top, near, far )
• ou
• glFrustum( left, right, bottom, top, near, far )
• // On informe OpenGL quon va modifier la
  modelview matrix
• // et on choisit une transformation pour la
  caméra
• glMatrixMode( GL_MODELVIEW )
• // On place la caméra
• gluLookAt()
• // On combine ici les transformations qui placent
  les objets dans le monde 3d
• // Pour combiner des transformations elles sont
  multipliées
• glMultMatrixf( modelMatrix )

44
OpenGL / Transformations

• Placer les objets
• // On va modifier la matrice ModelView
• glMatrixMode( GL_MODELVIEW )
• // On charge la transformation de la caméra
• glLoadMatrixf( viewingMatrix )
• // On fait une itération sur les modèles.
• // Pour chaque modèle on sauve la matrice
  courante
• // et on y applique la matrice du modèle
• // On dessine le modèle et on restaure la matrice
  sauvée
• for( model firstModel model ! NULL model
  nextModel )
• glPushMatrix( )
• // On combine la transformation de lobjet avec
• // la matrice de vue
• glMultMatrixf( model-gtmodelMatrix )
• // On affiche lobjet
• DrawModel( model )
• // On restaure la matrice sauvée

45
OpenGL

• Questions? Commentaires?

46
OpenGL / Links

• Liens utiles
• Site officiel
• www.opengl.org
• Tutoriaux
• Nehe.gamedev.net
• Références
• http//fly.cc.fer.hr/unreal/theredbook/ le Red
  Book
• http//www.eecs.tulane.edu/www/graphics/doc/OpenGL
  -Man-Pages/opengl_index_spec.html le Blue Book