Tous droits réservés. Reproduction intégrale ou partielle interdite sans autorisation écrite de la partdu titulaire des droits dauteur. Institut de Formation

Tous droits réservés. R

eproduction intégrale ou partielle interdite sans autorisation écrite de la part du titulaire des droits d’auteur.

Institut de Formation

Introduction à OpenGL

Sébastien [email protected]





OpenGL

1. Buts1. De la formation

2. De la séance

2. Introduction1. Présentation

2. Origine

3. Composants

3. OpenGL

1. Bases

2. Machine à état

3. Transformations




Buts

Buts de la formation

– Comprendre ce qu’est OpenGL– Comprendre les mécanismes de rendu 3d– Savoir écrire un programme 3d– Acquérir des bases pour être autonome




Buts

Buts de la séance

– Comprendre ce qu’OpenGL peut faire pour vous– Connaître les différents composants– Comprendre comment OpenGL gère la 3d




OpenGL : Introduction / Présentation OpenGL : API de programmation 2D et 3D

Standard dans l'industrieCrée par Silicon GraphicsDeveloppé par l’Architecture Review Board

PerformanceSouplessePortabilitéEvolutivité et Stabilité de l’APIRobustesse




OpenGL : Introduction / Composants

• Primitives géometriques – Points, lignes et polygones

• Primitives d’image – Images

– Pixels

• Le rendu de l’image dépend de l’état :– de la couleur

– des materiaux

– des sources lumineuses

– etc..




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




OpenGL / Les bases

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




OpenGL / Bases / Un exemple simple

1. Un exemple simple : Afficher un carré :

#include <whateverYouNeed.h>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();}

(OpenG

L R

ed Book)




OpenGL / Bases / Syntaxe

Syntaxe des fonctions

Draw() {// 3 flottants pour une couleurglColor3f(1.0, 0.0, 0.0);

float color_array[] = {1.0, 0.0, 0.0};

// un vecteur de 3 flottantsglColor3fv(color_array);

// 2 entiersglVertex2i( 1, 3 )

// 3 doubles glVertex3d( 0.3214,

0.4321, 0.0 );

}

Exemple :




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




OpenGL / Bases / Axes & Repères

• Repérage dans l’espace– OpenGL définit ses axes par rapport à l’écran

y

xz




OpenGL / Bases / Primitives

OpenGL fournit des primitives d'affichageLignes :

PolygonesDoivent etre simples :

✗ Pas convexes✗ ‘Sans trous'✗ Sur un seul plan









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();





• 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*




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); //CglEnd();




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




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

- Sans normales - - Avec normales -




OpenGL / Bases

• Afficher un cubeglBegin(GL_QUADS);

Pour chaque face :

glColor3f(r,g,b);

glNormal3f( Nx, Ny, Nz );

glVertex3f( x1, y1, z1);




Fin :

glEnd();




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.




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 )




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





• Fonctions de transformations• Déplacer un objet :

– glTranslate{fd}( x, y, z )

• Tourner un objet autour d’un axe– glRotate{fd}( angle, x, y, z )

• angle en degrés !

• Agrandir, retrécir ou inverser un objet:– glScale{fd}( x, y, z )





• Exemple

glMatrixMode(GL_MODELVIEW);

glLoadIdentity();

glTranslate(1.0,0.0,0.0);

DrawSphere();

glTranslate(1.0,0.0,0.0);

DrawCarre();

(0,0)(1,0) (2,0)





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

- effet d’une translation - - effet d’une rotation - - effet d’un redimensionnement -




OpenGL / Transformation

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

matrice.

M translation

1 0 0 T x

0 1 0 Ty

0 0 1 T z

0 0 0 1

M rotation axe x

1 0 0 0

0 cos sin 0

0 sin cos 0

0 0 0 1




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 actuelleglPushMatrix();drawCube();glTranslatef( 1,0,0 );drawSphere();// restitue la dernière//position sauvegardéeglPopMatrix();glTranslatef(0,1,0);drawTriangle();

• Sauvegarde dans une pile(0,0)

(1,0) (2,0)

(0,1)





• HiérarchieglMatrixMode(GL_MODELVIEW);glLoadIdentity();glPushMatrix();glTranslate( x,y,z );drawCorps();

glMultMatrix( transf_bras );drawBras();

glMultMatrix( transf_avant_bras );

drawAvantBras();

glMultMatrix( transf_main );drawMain();glPopMatrix();





• 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èreglMatrixMode(GL_MODELVIEW);glLoadIdentity();glTranslatef(1,0,0);glRotatef(90,1,0,0);

M ModelView=M Translation M Rotation





• 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 m[16] = { a0, a1, … , a15 };





• Comment sont appliquées ces transformations?

• Calculer la position absolue d’un vertex :

P Absolu =M ModelView P Local

PTransformé =MTransformation P Local





• 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();

P'=M Translation P

P'= M Rotation M Translation P

M Rotation M Translation P




OpenGL / Transformations• Deux façons de voir les transformations :

– Dans l’ordre 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 l’ordre opposé, la multiplication des matrices modifie la position, l’orientation ou la taille d’un objet

• Les objets sont dessinés dans un repère global fixe

• Le code est le même, il n’y’a que la façon de le voir

qui change




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();

glMatrixMode(GL_MODELVIEW);glLoadIdentity();/* rotation */glRotatef(45,0,0,1);/* translation */glTranslatef(1,0,0);draw_the_object();




OpenGL / 3d -> Ecran

Comment transformer un point en 3d pour l’afficher sur un écran 2d?





• Analogie avec un appareil photo– Positionner et orienter l’appareil

• Viewing transformation

– Placer les objets qu’on 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





•Analogie avec un appareil photo





• Opérations mathématiques :

Chaque transformation correspond à un changement de repère

Repère de l’objet

Matrice de l’objet( model matrix )

Repère du monde

Matrice œil( View matrix )

Repère de l’oeil( caméra )

Matrice de Projection( projection matrix )

Repère de l’écran 2D





• Opérations en OpenGL :– La model matrix et la view matrix sont combinées:

• Bouger la camera est équivalent à bouger chaque objet dans l’autre sens

ModelView Matrix

– glMatrixMode permet de choisir la matrice courante• GL_PROJECTION, GL_MODELVIEW, GL_TEXTURE




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 )




OpenGL / Transformations• Préparer la scène :// On va choisir la matrice de projectionglMatrixMode( GL_PROJECTION ); // et on la spécifieglOrtho( left, right, bottom, top, near, far ); ouglFrustum( left, right, bottom, top, near, far );

// On informe OpenGL qu’on va modifier la modelview matrix// et on choisit une transformation pour la caméraglMatrixMode( GL_MODELVIEW );// On place la caméragluLookAt()

// On combine ici les transformations qui placent les objets dans le monde 3d// Pour combiner des transformations elles sont multipliéesglMultMatrixf( modelMatrix );

// Les points içi sont dans le repère de l’objet (état original)// (model space)

© Tim Hall





• Placer les objets// On va modifier la matrice ModelViewglMatrixMode( GL_MODELVIEW );

// On charge la transformation de la caméraglLoadMatrixf( 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éefor( model = firstModel; model != NULL; model = nextModel ) {

glPushMatrix( );// On combine la transformation de l’objet avec// la matrice de vueglMultMatrixf( model->modelMatrix );// On affiche l’objetDrawModel( model );// On restaure la matrice sauvéeglPopMatrix( );

}




OpenGL

Questions? Commentaires?




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/OpenG

L-Man-Pages/opengl_index_spec.html : le Blue Book

Documents

Tous droits réservés. Reproduction intégrale ou partielle interdite sans autorisation écrite de la partdu titulaire des droits dauteur. Institut de Formation