Introduction to OpenGL

1. Introduction to OpenGL

2. OpenGL: Open Graphics Library • API graphique ( Application Programming Interface) • Couche entre le programmeur et le matériel (ou d’autres programmes) • Environ 250 procédures et fonctions • Définition des objets • Opérations pour applications interacives

3. Vue du programmeur Application Application Graphics Package OpenGL API Matériel et programmes Périphérique de sortie Périphérique d’entrée Périphérique d’entrée

4. Qu’est-ce que OpenGL ? • Machine à états reconfigurable • En entrée, données 2D ou 3D • En sortie un tampon image • On modifie l’état pour changer les fonctionnalités

5. Qu’est-ce que OpenGL ? • Largement utilisé et maintenu • Très bien documenté : www.opengl.org • Facile à utiliser • Traitement de la géométrie et des pixels

6. Histoire d’OpenGL • Développé par SGI au début des années 90 • SGI n’est plus propriétaire • License gratuite

7. Histoire OpenGL • Evolution controlée par OpenGL ARB (architecture review board) • Une voix par société • Microsoft (parti en mars 2003), Dell, IBM, Intel, Matrox, 3Dlabs, Apple, Sun Microsystems, HP, SGI, nVidia, ATI, Evans & Sutherland

8. OpenGL est utilisé pour • Applications temps réel (3D Studio Max, Maya, Blender, …) • Environnements virtuels interactifs • Jeux videos (Quake, Warcraft 3, Medal of Honor, Doom 3, …)

9. Fonctionnement de OpenGL • Interprétation client / serveur • Le programme (client) invoque des commandes • Eg.activation des lumières, rendu de triangles, etc. • Les commandes sont interprétées et traités par le serveur • “GL”

10. OpenGL • Ne fournit pas le moyen de construire des scènes complexes • Utiliser pour cela une API plus haut-niveau (OpenInventor, Java3D) • Ne gère pas les périphériques • Souris, son... • Ne gère pas l’interface-homme-machine • Pour cela nous utiliserons la GLUT • (Graphics Library Utility Toolkit)

11. Bibliothèques • #include <GL/gl.h> • #include <GL/glu.h> • #include <GL/glut.h>

12. Interaction avec le système de fenêtrage • OpenGL est indépendant des plateformes • Un système de fenêtrage est nécessaire pour • Interaction • Ouverture / fermeture fenêtres • Gestion des événements • Options: • GLX (*nix) • WGL (windows) • GLUT (indépendant du système de fenêtrage)

13. Création d’une fenêtre avec GLUT • glutInitWindowSize • glutInitDisplayMode • glutCreateWindow

14. Rendu d’une primitive géométrique • Dans un tampon d’images • Primitives OpenGL • Un ensemble de sommets • Un sommet définit: • Un point • L’extrémité d’un segment • Le sommet d’un polygone

15. Rendu OpenGL • Données associées à un sommet • coordonnées • couleur • normale • coordonnées de texture

16. Primitives OpenGL Ligne Points Polygone Triangle Quad Quad strip Triangle strip Triangle Fan

17. Modes de rendu • Fil de fer (Wireframe) • Plat (Flat Shading) • Une seule couleur par polygone • Interpolé (Smooth, Gouraud) • Interpolation des couleurs des sommets sur le polygone • Plaquage de textures • La couleur de chaque pixel est récupérée dans une image

18. Configuration de ces options • glEnable, glDisable, • glCullFace, glPolygonMode, glLightModel, etc.

19. Pipeline OpenGL Operations sur primitives Géométriques Conversion en mode Point Operations sur les fragments Sommets Mémoire tampon Images ou Pixels Opérations Sur pixels Mémoire texture

20. Opérations sur les pixels • Manipulation de rectangles de pixels • glDrawPixels, glReadPixels, glCopyPixels déplacent des rectangles de pixels de et vers le tampon image • glBitmap prend en entrée une image binaire dont les pixels à 1 sont dessinés dans la mémoire image (utile pour dessiner du texte)

21. Elimination des parties cachées • A chaque fois qu’un fragment i est dessiné, le zi (distance au point de vue) est comparé et peut-être stocké dans le tampon de profondeur (Z-buffer) • Soit zj la valeur présente dans le z-buffer • Si zj > zi le fragment est dessiné • Sinon rien n’est fait

22. Elimination des parties cachées • Spécifier l’utilisation d’un tampon de profondeur: • glutInitDisplayMode(GLUT_DEPTH); • A la mise à jour s’assurer que : • glClear(GL_DEPTH_BUFFER_BIT); • glEnable(GL_DEPTH_TEST);

23. Dessiner avec OpenGL • glBegin() • glEnd() termine une liste de sommets et de ses attributs • Les coordonnées d’une primitive sont données dans le sens inverse des aiguilles d’un montre

24. Exemple ; dessin d’un point glBegin(GL_POINTS); glVertex3f(0.0f, 0.0f, 0.0f); glEnd();

25. Un triangle glBegin(GL_TRIANGLES); glVertex3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 0.0f); glVertex3f(1.0f, -1.0f, 0.0f); glEnd();

26. Un triangle avec des sommets de couleurs différentes glBegin(GL_TRIANGLES); glColor3f(1.0f, 0.0f, 0.0f); //pure red glVertex3f(0.0f, 1.0f, 0.0f); glColor3f(0.0f, 1.0f, 0.0f); //pure green glVertex3f(-1.0f, -1.0f, 0.0f); glColor3f(0.0f, 0.0f, 1.0f); //pure blue glVertex3f(1.0f, -1.0f, 0.0f); glEnd();

27. Modèles de couleurs avec OpenGL • RGBA • Red, Green, Blue, Alpha • Un canal pour chaque couleur • 8 bits/canal = 16 million de couleurs • Couleur indexée (Indexed Color) • Un petit nombre de couleur accédées grâce à un indice dans une table de couleurs • 8 bits = 256 colors

28. Transparence avec OpenGL • Utilisation d’un modèle RGBA, ma 4ème composante (alpha) spécifie la transparence • Alpha = 0 ; polygone complètement transparent • Alpha = 1 ; polygone opaque • Deux objets de couleurs (Cs, Cf) sont composés au moment du rendu • C = alpha*Cs + (1 - alpha) Cf • Cs est la couleur du nouveau fragment transparent • Cf est la couleur déjà présente dans la mémoire tampon

29. Visualisation avec OpenGL • La visualisation est réalisée en 2 étapes • Positionnement des objets • Matrice de transformation : model view • Projection dans la vue • matrice de transformation projection • OpenGL fournit des matices de projection perspectives et parallèles (orthographic) • La caméra par défaut est toujours située à l’origine et pointe vers la direction des z négatifs

30. Matrice ModelView • Positionne les objets dans la scène • Formée par la concaténation de transformations simples • glRotate(theta, x,y,z) • glTranslate(x,y,z) • glScale(x,y,z) • L’ordre est important

31. Transformations de modélisation glTranslatef(0.0f, 0.0f, -10.0f); glRotatef(45.0f, 0.0f, 1.0f, 0.0f); glBegin(GL_TRIANGLES); glColor3f(1.0f, 0.0f, 0.0f); glVertex3f(0.0f, 1.0f, 0.0f); glColor3f(0.0f, 1.0f, 0.0f); glVertex3f(-1.0f, -1.0f, 0.0f); glColor3f(0.0f, 0.0f, 1.0f); glVertex3f(1.0f, -1.0f, 0.0f); glEnd();

32. Visualisation • Projection orthographique • Projection parallèle, le volume de vue est un cube • glOrtho(left, right, bottom, top, front, back)

33. Visualisation • Projection perspective • glFrustum, gluPerspective • Le volume de vue et de découpage est une pyramide

34. Positionnement de la camera • gluLookAt spécifie • La position de la caméra (position de l’oeil) • Le point visé (look at) • L’orientation de la caméra (vecteur vertical, up) • gluLookAt(10,10,10,1,2,3,0,0,1); • Oeil en (10,10,10) • Point visé (1,2,3) • Up (0,0,1)

35. Exemple de visualisation complet //Projection glMatrixMode(GL_PROJECTION); glLoadIdentity(); gluPerspective(60, 1, 1, 100); gluLookAt(10,10,10,1,2,3,0,0,1) //Transformations sur les objets glMatrixMode(GL_MODELVIEW) glLoad Identity(); glTranslate(1,1,1); glRotatef(90, 1,0,0); DrawObject();

36. Piles de matrices • glPushMatrix retourne une copie du sommet de la matrice • glPopMatrix détruit le sommet de la matrice

37. Attention !! Les matrices de transformation sous OpenGL sont des matrices colones • En C, si l’on déclare la matrice m[4][4], l’élément m[I][j] est sur la ième ligne et la jème colonne. • Avec OpenGL, l’élément m[I][j] correspond à la ième colonne et à la jème ligne de la matrice de transformation. Pour éviter les erreurs une méthode consiste à déclarer les matrices sous la forme m[16]

38. Matrice OpenGL m0 m4 m8 m12 m1 m5 m9 m13 m2 m6 m10 m14 m3 m7 m11 m15