Programmation graphique

Présentation au sujet: "Programmation graphique"— Transcription de la présentation:

1 Programmation graphique
Sylvia Chalençon Licence informatique

2 Généralités La programmation graphique fait appel à de nombreuses techniques dont la finalité est de permettre de visualiser des scènes 3D et/ou 2D. Les deux principales bibliothèques (OpenGL et Direct3D) réunissent plusieurs phases essentielles : Transformations géométriques (vecteurs & matrices) Rasterization Textures, shaders OpenGL est une interface de programmation développée, à l’origine, par Silicon Graphics. Direct3D, sous-ensemble de DirectX, est l’interface développée par Microsoft.

3 Un peu de vocabulaire API : Application Programming Interface
ARB : Architecture Review Board Edge : Arête FPS : Frames Per Second (images par seconde) Frame Rate : Rafraîchissement de l’image (cf. FPS) OpenGL : Open Graphic Library GLU : OpenGL Utility Library GLUT GL utility toolkit Vertex : Sommet Vertices : Sommets (pluriel de Vertex) VA : Vertex Array VBO : Vertex Buffer Object

4 Convention de nommage OpenGL adopte une convention de nommage proche de celle utilisée en langage Java. L’ensemble des éléments provenant de l’API OpenGL sont préfixés des deux lettres gl. Ces lettres se présentent en minuscule pour les fonctions En majuscule pour les macros et types de données Ainsi une fonction OpenGL peut prendre la forme suivante : glNomCourt{u}{bsifd}{v}(type1 v1, type2 v2, …); où le nom court étant le nom de la fonctionnalité. Il peut être suffixé d’éléments informant sur la nature et le type de données d’un sous-ensemble ou de l’intégralité des arguments de la fonction : La présence de la lettre u indique que le type de données du ou des argument(s) ciblé(s) est non signé. Ce suffixe n’est valable que dans les cas où il serait suivi de b, s ou i; La présence d’une des lettres {b, s, i, f, d} indique le type de données du ou des argument(s) ciblé(s). La présence de la lettre v indique que le ou les arguments ciblés sont des vecteurs (des tableaux de données).

5 Pipeline OpenGL fournit un Pipeline fixe permettant de calculer un rendu en fonction du flux de données fourni en entrée. Ces données sont composées d’une part d’un enchevêtrement de commandes OpenGL et de données géométriques décrivant les objets et leur placement dans la scène d’autre part de données bitmaps généralement utilisées pour décrire les textures des objets. La diapo suivante reprend les étapes principales de ce Pipeline.

6 Pipeline A partir de la version 3.0 d’OpenGL® , une partie du Pipeline fixe tend à devenir obsolète au bénéfice d’une utilisation de plus en plus systématique des shaders et ceci même pour les exemples les plus basiques. Les fonctionnalités obsolètes sont maintenues mais deviennent dépréciées (depcrecated).

7 Liste d’affichage Permet de rassembler des données de modélisation (aussi bien les données vectorielles que bitmap) sous une même étiquette. Peut être vue comme un sous-ensemble packagé et prêt à l’emploi des données d’entrée. Ce sous-ensemble représente un objet ou une partie d’objet pouvant être exécuté une ou plusieurs fois dans la scène. Ici, le terme exécuté signifie l’envoi, dans le Pipeline OpenGL, des données contenues dans la liste d’affichage. Une analogie facile pourrait être faite avec les langages de programmation où l’utilisation des listes d’affichage se rapporterait aux langages compilés et où la description narrative de la scène (dite mode immédiat) se rapporterait aux langages interprétés.

8 L’évaluateur Moteur permettant de produire des approximations de courbes ou de surfaces à l’aide d’arêtes ou de facettes. Pour cela il utilise des courbes paramétriques (la courbe de Bézier par exemple) discrétisées à un pas donné pour en faire un ensemble de primitives géométriques utilisables par le la suite du Pipeline OpenGL . Ces courbes permettent aussi de calculer simplement et en chaque sommet les vecteurs normaux pour le calcul de l’éclairage et les coordonnées de textures.

9 Traitement des sommets
Calcul de l’ensemble des transformations géométriques telles que rotations, translations, changement de repère / d’échelle, projection, etc… Principalement appliquées aux sommets mais aussi aux coordonnées de textures et aux normales aux faces.

10 Rasterization Cette étape consiste à transformer des données encore vectorielles, représentées dans un pseudo-espace bidimensionnel prenant en compte la profondeur (un cube dans le quel les objets sont projetés orthogonalement sur l’une des faces du cube), en fragments. Un fragment est l’élément qui, in fine, sera le pixel, à un détail près : un pixel peut être composé (calculé à partir) de plusieurs fragments.

11 Analogies avec la photographie
1 Arranger les éléments
de la scène à capturer Composer
une scène virtuelle Transformation de modélisation 2 Positionner
l'appareil photo Positionner
la caméra virtuelle Transformation de vision 3 Régler la focale
de l'appareil photo Configurer
une projection Transformation de projection 4 Choisir la taille des
tirages photographiques Choisir les dimensions
de l’image video Transformation de cadrage

12 Transformation de modélisation
glMatrixMode (GL_MODELVIEW) Active la matrice de modélisation. glTranslate (GLdouble tx, GLdouble ty, GLdouble tz) Effectue une translation de vecteur [tx ty tz] glRotate (GLdouble a, GLdouble rx, GLdouble ry, GLdouble rz) Rotation d’angle a autour du vecteur [rx ry rz]. glScale (GLdouble sx, GLdouble sy, GLdouble sz) Échelle de facteurs sx, sy et sz. Y X Y X Y X

13 Transformation de modélisation
La multiplication n’est pas commutative ! Convention : T × R × S × v glTranslated (T.x, T.y, T.z); glRotated (R.a, R.x, R.y, R.z); glScaled (S.x, S.y, S.z); glVertex3d (v.x, v.y, v.z);

14 Transformation de vision
glMatrixMode (GL_MODELVIEW) Il s’agit de la même matrice ! Aucune différence entre vision et modélisation. Position relative de la caméra. gluLookAt (px,py,pz, cx,cy,cz, ux,uy,uz) Positionne la caméra au point [px py pz], oriente les Z vers la cible [cx cy cz] et les Y selon le vecteur [ux uy uz].

15 Transformation de projection
glMatrixMode (GL_PROJECTION) Active la matrice de projection. glFrustum (left,right, bottom,top, near,far) gluPerspective (fovy, aspect, near,far) Définit le volume de projection perspective. glOrtho (left,right, bottom,top, near,far) Définit le volume de projection orthogonale.

16 Transformation de cadrage
glViewport (GLint x, GLint y, GLsizei w, GLsizei h) Cadre la fenêtre de visualisation OpenGL. Coordonnées du framebuffer dans le repère de l’environnement graphique (KDE, Gnome, Windows, etc.)

17 Pile de transformations
Graphe de scène Répétition d’un même objet Modélisation hiérarchique glPushMatrix () Enregistre la matrice actuelle (du mode actuel) et prépare un nouveau contexte (avec la même matrice). glPopMatrix () Restaure le contexte précédent. glLoadIdentity () glLoadMatrix (const GLdouble [16]) glMultMatrix (const GLdouble [16]) glTranslate / glRotate / glScale

18 Tableaux de sommets mode direct
1. // Tableau de sommets. 2. GLfloat sommets [6*4*3] = {0,0,0, 0,0,1, …}; 3. 4. // Activation du tableau de sommets. 5. glEnableClientState (GL_VERTEX_ARRAY); 6. glVertexPointer (3, GL_FLOAT, 0, sommets); 7. 8. glDrawArrays (GL_QUADS, 0, 6*4); 9. 10. // Désactivation du tableau de sommets. 11. glDisableClientState (GL_VERTEX_ARRAY);

19 Tableaux de sommets mode indirect
1. // Tableau de sommets. 2. GLfloat sommets [8*3] = {0,0,0, 0,0,1, …}; 3. // Tableau d’indices. 4. Gluint indices [6*4] = {0,1,2,3, 0,3,4,5, …}; 5. 6. // Activation du tableau de sommets. 7. glEnableClientState (GL_VERTEX_ARRAY); 8. glVertexPointer (3, GL_FLOAT, 0, sommets); 9. 10. glDrawElements (GL_QUADS, 6*4, GL_UNSIGNED_BYTE, indices); 11. 12. // Désactivation du tableau de sommets. 13. glDisableClientState (GL_VERTEX_ARRAY);

20 Vertex buffers objects (VBOs)
Tableaux d'octets dans la mémoire graphique Sources potentielles d'attributs de sommets Structures et types connus du seul développeur 1. // Création du VBO. 2. glGenBuffers(1, &_buffer); 3. // Activation du VBO 4. glBindBuffer(GL_ARRAY_BUFFER, _buffer); 5. // Initialisation des données 6. GLfloat data[] = { -0.97f, -0.97f, 0.97f,… }; 7. glBufferData(GL_ARRAY_BUFFER,sizeof data,data,GL_STATIC_DRAW); 8. // Désactivation du VBO 9. glBindBuffer(GL_ARRAY_BUFFER, 0);

21 Attributs des sommets glEnableVertexAttribArray (index); Activation d'un attribut identifié par son indice glVertexAttribPointer (index, size, type, normalized, stride, pointer); index Indice de l’attribut size Nombre de composantes par attribut (1, 2, 3 ou 4) type GL_FLOAT / GL_UNSIGNED_BYTE / … normalized Normalisation des valeurs ? true / false stride Distance en octets entre deux attributs consécutifs pointer Pointeur sur le premier élément du premier attribut dans le VBO

22 Attributs des sommets 1. // Activation du VBO.
2. glBindBuffer(GL_ARRAY_BUFFER, _buffer); 3. // Activation de l'attribut nº 0. 4. glEnableVertexAttribArray (0); 5. //Déclaration de la structure du tableau. 6. glVertexAttribPointer (0, 2, GL_FLOAT, GL_FALSE, 0, (const void *)0); 7. // Activation de l'attribut nº1 8. glEnableVertexAttribArray (1); 9. //Déclaration de la structure du tableau. 10. glVertexAttribPointer (1, 3, GL_FLOAT, GL_FALSE, 0, (const void *)(4 * 2 * sizeof *data)); 11. // Désactivation du VBO 12. glBindBuffer(GL_ARRAY_BUFFER, 0);

23 Vertex array objects (VAOs)
Un vertex array object peut stocker plusieurs VBOs. Permet stocker les données des sommets et des couleurs dans des VBOs différents, mais dans le même VAO. Même principe pour tous les types de données généralement transmis comme VBO, dont les données des normales ou n'importe quelle donnée requise au niveau des sommets. Un VAO est une manière de stocker des informations sur les objets dans la carte graphique, au lieu de lui envoyer des sommets au fur et à mesure des besoins.

24 Vertex array objects (VAOs)
1. // Activation du VAO. 2. glBindVertexArray(_vao); 3. // Activation du VBO. 4. glBindBuffer(GL_ARRAY_BUFFER, _buffer); 5. // Dessin. 6. glDrawArrays(GL_TRIANGLE_STRIP, 0, 4); 7. // Désactivation du VBO 8. glBindBuffer(GL_ARRAY_BUFFER, 0); 9. // Désactivation du VAO 10. glBindVertexArray(0); 11. // Désactivation du VBO 12. glBindBuffer(GL_ARRAY_BUFFER, 0);

25 Primitives d’affichage
GL_POINTS GL_LINES GL_LINE_STRIP S3 S3 S2 S3 S2 S2 S4 S4 S4 S5 S5 S5 S1 S1 S1 S6 S6 S6 GL_LINE_LOOP GL_TRIANGLES GL_TRIANGLE_STRIP S3 S1 S3 S5 S3 S2 S2 S4 S4 S5 S5 S1 S1 S6 S6 S2 S4 S6 GL_TRIANGLE_FAN GL_QUADS GL_QUAD_STRIP S3 S3 S1 S3 S5 S2 S4 S2 S1 S5 S5 S1 S4 S6 S2 S4 S6 S6