cours 1

Vandromme

Description

OpenGLProgrammation 3D avecOpenGLIUT InformatiqueJohann [e-mail]ée 2005-2006Cours 1• 1 - Introduction rapide à OpenGL et aux outilscomplémentaire• 2 - Syntaxe OpenGL• 3 - Le repère OpenGL• 4 - Création d’un polygone• 5 - Système de couleurs• 6 - La machine à état• 7 - Les buffers– 1 - Color Buffer– 2 - Double buffer– 3 - Z-buffer1 - OpenGL• Librairie graphique 3D• C / C++ (Implémentation pour Java, ADA,Pascal)• OpenGL -> Open Graphical Library• Abstraction de la communication matérielle• Abstraction de la plate-forme logicielle1123OpenGL• Va permettre de faire de l’affichage 3D ens’abstrayant des contraintes de pixel / créationde ligne / remplissage de polygone / profondeur/ perspective / calculs d’éclairement / textures /etc.• 200 commandes distinctes (pour OpenGL 1.2) ;• Référence : www.opengl.orgOpenGL – Outils complémentaires• GLU (GL Utility Library) : surfaces quadratiques,courbes/surfaces NURB• GLUT : va permettre en plus de s’abstraire deslibrairies de création et d’interaction avec unefenêtre, d’évènement clavier / souris (liées àl’OS).• …2 - OpenGL - Syntaxe• Préfixe des commandes : « gl »• Préfixe des constantes : « GL_ »• Les suffixes vont dépendre du type desparamètres :void glVertex3f x, y et z sont 3 réels(x, y, z);void x, y et z sont 3 entiersglVertex3i(x, y,void x et y et z sont 2 réelsz);glVertex2f(x, y)void Tab : tableau (vecteur)glVertex3fv(tab) de 3 réels24563 - ...

Sujets

• informatique

Informations

• Publié par: Udre
• Nombre de lectures: 53
• Langue: Français

Extrait

OpenGL

Programmation 3D avec OpenGL

IUT Informatique Johann Vandromme [e-mail] Année 20052006

Cours 1

1  Introduction rapide à OpenGL et aux outils complémentaire 2  Syntaxe OpenGL 3  Le repère OpenGL 4  Création d’un polygone 5  Système de couleurs 6  La machine à état 7  Les buffers 1  Color Buffer – 2  Double buffer – 3  Zbuffer –

1 - OpenGL

Librairie graphique 3D C / C++ (Implémentation pour Java, ADA, Pascal) OpenGL > Open Graphical Library Abstraction de la communication matérielle Abstraction de la plateforme logicielle

1

OpenGL

Va permettre de faire de l’affichage 3D en s’abstrayant des contraintes de pixel / création de ligne / remplissage de polygone / profondeur / perspective / calculs d’éclairement / textures / etc. 200 commandes distinctes (pour OpenGL 1.2) ; Référence : www.opengl.org

OpenGL – Outils complémentaires

GLU (GL Utility Library) : surfaces quadratiques, courbes/surfaces NURB GLUT : va permettre en plus de s’abstraire des librairies de création et d’interaction avec une fenêtre, d’évènement clavier / souris (liées à l’OS). …

2 - OpenGL - Syntaxe

Préfixe des commandes : «gl» Préfixe des constantes : «GL_» Les suffixes vont dépendre du type des paramètres :

void glVertex3f (x, y, z); void glVertex3i(x, y, void z); glVertex2f(x, y) void glVertex3fv(tab)

x, y et z sont 3 réels x, y et z sont 3 entiers x et y et z sont 2 réels Tab : tableau (vecteur) de 3 réels

2

Repère direct Main droite

4 - C

3 - Le repère OpenGL

z

y

x

éation d’un polygone

En 3D, toutes les formes sont créées à base de polygones. Un polygone = une liste (discrète) de points. La fonction glBegin() détermine comment relier une liste de points.

void glBegin(MODE); … void glEnd();

C éation d’un carré

Création d’un polygone : glBegin (GL_POLYGON) ; … glEnd() ; Création d’un point : void glVertex3f (float x, float y, float z);

glBegin(GL_POLYGON) ; glVertex3f (0, 0, 0) ; glVertex3f (0, 1, 0) ; glVertex3f (0, 1, 1) ; glVertex3f (1, 0, 0) ; glEnd() ;

3

manière d’afficher un polygone

void glPolygonMode (GLenum face, GLenum mode) ; face : défini les faces à considérer : GL_FRONT – GL_BACK – GL_FRONT_AND_BACK – mode : défini le mode d’affichage GL_POINT – GL_LINE – GL_FILL – Comment OpenGL distinguetil les faces avant des faces arrières ? Dépend de l’ordre de définition des points. – Pour être en face avant, les points doivent être définis dans l’ordre – direct (sens inverse des aiguilles d’une montre) Les faces arrières sont définies dans le sens indirect. –

Faces avant / faces arrière

Une optimisation possible : élimination des faces arrières Technique du Culling : déterminer les faces à ne pas afficher – glEnable (GL_CULL_FACE); – glCullFace (face); – Le paramètre face peut prendre les valeurs: – GL_FRONT  GL_BACK  GL_FRONT_AND_BACK (n’affiche rien !) 

B

A

E

C

D

F

5 - Système de couleurs

Les couleurs sont définies par leurs composantes rouge, verte et bleue. Commande : void glColor3f (float red, float green, float blue); (red, green et blue sont les composantes rouges vertes et bleues) Les couleurs sont des flottants compris entre 0.0 et 1.0. Les couleurs sont calculées par synthèse additive (ce sont des pixels qui s’allument).

4

Les couleurs : exemple

glColor3f (0.0, 0.0, 0.0)

glColor3f (1.0, 1.0, 1.0)

glColor3f (0.5, 0.5, 0.5)

glColor3f (1.0, 0.0, 0.0)

glColor3f (0.0, 1.0, 0.0)

glColor3f (0.0, 0.0, 1.0)

glColor3f (1.0, 1.0, 0.0)

glColor3f (1.0, 0.0, 1.0)

glColor3f (0.0, 1.0, 1.0)

Noir Blanc Gris Rouge Vert Bleu Jaune Magenta Cyan

Le cube chromatique

6 - La machine à état

OpenGL repose sur le principe de machine à état : c'estàdire, que si on active une fonctionnalité de la librairie, elle reste active jusqu’à ce qu’elle soit explicitement désactivée.

5

La machine à état : exemple

glBegin(GL_POLYGON) ; glColor3f (0, 0, 0) ; glVertex3f (0, 0, 0) ; glColor3f (1, 1, 1) ; glVertex3f (0, 1, 0) ; glVertex3f (0, 1, 1) ; glColor3f (0, 0, 0) ; glVertex3f (1, 0, 0) ; glEnd() ;

Remarque : on peut remarquer que les couleurs sont automatiquement interpolées.

7 - Les buffers – 7.1 le color Buffer

zone mémoire réservée à l’affichage du contenu de la fenêtre OpenGL. La taille du colorbuffer sera égale à celle de la fenêtre. Chaque appel openGL (glVertex, gl..) ira écrire directement dans ce buffer. Fonction utile : void glFlush(); Va permettre de forcer l’affichage (se place à la fin de la fonction d’affichage) [synchronisation]. Garantit que les appels de dessins antérieurs sont exécutés à la fin de cette fonction. Pour que GLUT crée le tampon RGB : void glutInitDisplayMode(GLUT_RGB); au début de chaque affichage : on vide le tampon avec la couleur de fond (sinon, les différents dessin vont se superposer). void glClear(GL_COLOR_BUFFER_BIT);

7.2 Double tampon - Principe

Le problème du « simple tampon » d’affichage que l’on vient de voir est que le dessin se réalise en temps réel sur la fenêtre. Pour palier au problème lors de l’animation (rafraîchissements fréquents), on peut utiliser le double tampon ; Le dessin se réalise sur un tampon « offscreen », puis, le dessin courant est remplacé par celui qui vient d’être calculé

6

Double tampon : fonctions

Pour que GLUT crée le double tampon (+ tampon d’affichage): void glutInitDisplayMode(GLUT_RGB | GLUT_DOUBLE ); Commande d’échange des tampons : void glutSwapBuffers() ; (à la fin de l’affichage, remplace le glFlush())

7.3 Tampon de profondeur

Le principe d’un moteur 3D est le suivant : Il existe un ensemble de points avec des coordonnées 3D (x, y, z) que l’on souhaite transposer dans un espace 2D (x, y). Transformation de projection.

Z-Buffer - problématique

Soient 2 carrés dessinés à z = 0.5 (carré bleu) et z = 1 (carré rouge). Pour que le carré bleu apparaisse devant le carré rouge, il suffit d’afficher le carré rouge, puis le carré bleu par dessus. Cela signifie que le moteur 3D doit d’abord traiter toutes les faces pour les ordonner, puis doit les afficher.

7

Z-Buffer - principe

Astuce utilisée par OpenGL (et la plupart des librairies graphiques) : le Zbuffer. Principe : le Zbuffer est une zone de la taille du colorbuffer (de l’image) ; A chaque pixel dessiné, on stock sa profondeur ; Si un nouveau pixel tente de se dessiner sur un pixel ayant déjà été initialisé : on teste si le nouveau pixel est plus proche que celui déjà présent. S’il est plus proche, on « écrase » le pixel présent avec le nouveau, sinon, on ne fait rien. Le Zbuffer est initialisé avec les valeurs de profondeur maximale. Remarque : cette manipulation permet d’afficher des polygones dans un ordre quelconque.

Z-Buffer - fonctions

Pour que GLUT crée le tampon de profondeur (+ tampon d’affichage): glutInitDisplayMode(GLUT_RGB | GLUT_DEPTH ); Pour que openGL fasse le teste de profondeur : glEnable(GL_DEPTH_TEST) ; Réinitialisation du tampon de profondeur (initialisation avec la profondeur maximale – au début de la fonction d’affichage) glClear(GL_DEPTH_BUFFER_BIT);

Color Buffer

Le Z-buffer : exemple

Zbuffer

0.5

0.5 1

8