Jeux Libres
       
           

» Les Tutoriels » OpenGL : Les listes d'affichage

OpenGL : Les listes d'affichage


Ce cours a pour but de vous initier aux listes d'affichage.




Qu'est ce que c'est ?


Une liste d'affichage, c'est quoi ?



Une liste d'affichage et une suite d'instructions OpenGL directement stockée dans la carte graphique. Par exemple, une liste d'affichage peut contenir la suite d'instructions qui permet de dessiner un cube.

Une liste d'affichage, à quoi ça sert ?



Les listes d'affichage servent principalement à optimiser de façon considérable le rendu d'un objet. Plutôt que d'envoyer à la carte graphique TOUTES les instructions pour dessiner l'objet, on va simplement envoyer UNE SEULE instruction demandant le dessin de l'objet. Cela se traduit par un gain de temps qui n'est pas négligeable.

Une liste d'affichage, comment ça marche ?



L'utilisation d'une liste d'affichage s'effectue en deux temps : création, puis utilisation.
La création d'une liste d'affichage consiste à donner à la carte graphique les instructions qu'elle devra effectuer.
L'utilisation, consiste à donner l'ordre à la carte graphique d'effectuer la suite d'instruction précédemment créée.

- Une liste d'affichage doit être créée avant d'être utilisée.
- Une liste créée doit être libérée, sinon il y a une fuite de mémoire.


Le fonctionnement des listes d'affichage est à peu près similaire à celui des textures : elles sont créées, utilisées autant de fois que l'on veut, puis doivent être libérées ensuite. Les fonctions sont similaires.


Utilisation d'une liste d'affichage


Pour ne pas alourdir le cours, je ne vais pas créer de programme d'illustration. Je vous laisse vous adapter à votre situation.


Affichage classique



Actuellement, lorsque vous voulez afficher un objet, par exemple un cube, vous le dessinez face par face, comme ceci :
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
    glBegin(GL_QUADS);
 
   glColor3ub(255,0,0); //face rouge
   glVertex3d(1,1,1);
   glVertex3d(1,1,-1);
   glVertex3d(-1,1,-1);
   glVertex3d(-1,1,1);
 
   glColor3ub(0,255,0); //face verte
   glVertex3d(1,-1,1);
   glVertex3d(1,-1,-1);
   glVertex3d(1,1,-1);
   glVertex3d(1,1,1);
 
   glColor3ub(0,0,255); //face bleue
   glVertex3d(-1,-1,1);
   glVertex3d(-1,-1,-1);
   glVertex3d(1,-1,-1);
   glVertex3d(1,-1,1);
 
   glColor3ub(255,255,0); //face jaune
   glVertex3d(-1,1,1);
   glVertex3d(-1,1,-1);
   glVertex3d(-1,-1,-1);
   glVertex3d(-1,-1,1);
 
   glColor3ub(0,255,255); //face cyan
   glVertex3d(1,1,-1);
   glVertex3d(1,-1,-1);
   glVertex3d(-1,-1,-1);
   glVertex3d(-1,1,-1);
 
   glColor3ub(255,0,255); //face magenta
   glVertex3d(1,-1,1);
   glVertex3d(1,1,1);
   glVertex3d(-1,1,1);
   glVertex3d(-1,-1,1);
 
   glEnd();

En temps que bon développeur, vous avez placé cette suite d'instruction dans une fonction que vous avez appelé dessinerCube().
1
2
3
4
5
6
7
8
9
10
11
void dessinerCube(void)
{
   glBegin(GL_QUADS);
 
   glColor3ub(255,0,0); //face rouge
   glVertex3d(1,1,1);
   glVertex3d(1,1,-1);
 
   // . . .
 
}

Et pour dessiner des cubes, vous faites des appels successifs à votre fonction dessinerCube().
1
2
3
4
5
6
7
dessinerCube(); // Affichage d'un cube
 
glTranslatef(3.0, 0.0, 0.0); // Dplacement de 3 units vers les X positifs
dessinerCube(); // Affichage d'un second cube
 
glTranslatef(3.0, 0.0, 0.0); // Dplacement de 3 units vers les X positifs
dessinerCube(); // Affichage d'un troisime cube

La fonction dessinerCube() contient 32 instruction OpenGL, vous pouvez les compter. Votre carte graphique reçois donc 96 ordres pour ne dessiner que 3 cubes ! Ces ordres doivent être interprétés par la carte graphique pour qu'ils soient ensuite exécutés. Ça prend du temps !

Pour optimiser tout ça, nous allons créer une liste d'affichage permettant de dessiner un cube.

Création d'une liste d'affichage



Pour créer une liste d'affichage, il suffit de faire appel à la fonction suivante :
1
GLuint listeAffichage = glGenLists(1);

La fonction glGenLists() prend en paramètre le nombre de liste à créer et retourne le numéro d'identification de la première liste. Dans notre cas, nous ne créerons qu'une seule liste.


Pour l'instant, la liste d'affichage existe dans la carte graphique mais n'est pas définie.
Pour définir le contenu de la liste d'affichage, on entoure la liste d'instruction à effectuer entre deux appels aux fonctions glNewList() et glEndList(). La première prend en paramètre le numéro d'identification de la liste à définir ainsi qu'un second paramètre que nous initialiserons toujours à GL_COMPILE. La seconde fonction ne prend pas de paramètre.


Voici donc le code de création de la liste d'affichage de cube :
1
2
3
4
5
6
7
// Cration d'une liste d'affichage
GLuint listeAffichageCube = glGenLists(1);
 
// Dfinition de la liste d'affichage
glNewList(listeAffichageCube, GL_COMPILE);
dessinerCube();
glEndList();

La liste d'affichage du cube est maintenant chargée en carte graphique.

Pendant la définition de la liste d'affichage, l'objet n'est pas dessiné.


Utilisation de la liste d'affichage



Maintenant que la liste d'affichage du cube est créé en carte graphique, un seul ordre n'a besoin d'être transmis pour effectuer l'affichage.
1
2
        // Dessin du cube
       glCallList(listeAffichageCube);

Pour dessiner 3 cubes, seulement 3 ordres n'ont besoin d'être transmis à la carte graphique.
1
2
3
4
5
6
7
glCallList(listeAffichageCube); // Affichage d'un cube
 
glTranslatef(3.0, 0.0, 0.0); // Dplacement de 3 units vers les X positifs
glCallList(listeAffichageCube); // Affichage d'un second cube
 
glTranslatef(3.0, 0.0, 0.0); // Dplacement de 3 units vers les X positifs
glCallList(listeAffichageCube);; // Affichage d'un troisime cube

La carte graphique ayant beaucoup moins d'ordre à interpréter, le rendu du cube est accéléré.

Libération de la liste d'affichage



Comme pour les textures, les listes d'affichage doivent être libérées, sinon il y a une fuite de mémoire. Pour libérer la liste d'affichage, vous devrez utiliser la fonction glDeleteLists(). Celle-ci prend en paramètre le numéro d'identification de la première texture à libérer, ainsi que le nombre de textures à libérer.

Dans notre cas, une seule texture n'a besoin d'être libérée :
1
glDeleteLists(listeAffichageCube, 1);




Ce cours est terminé. J'espère que mes explications ont été claire et vous inciterons à utiliser les listes d'affichage autant que possible.



Rédigé par David
Consulté 7841 fois



Hébergeur du site : David
Version PHP : 5.4.45-0+deb7u2
Uptime : 16 jours 6 heures 7 minutes
Espace libre : 1599 Mo
Dernière sauvegarde : 09/12/2018
Taille de la sauvegarde : 1109 Mo


4957927 pages ont été consultées sur le site !
Dont 2275 pages pendant les 24 dernières heures.

Page générée en 0.985 secondes


Nos sites préférés
- Création d'un jeu de plateforme de A à Z avec SDL
- Zelda ROTH : Jeux amateurs sur le thème de Zelda
- Zeste de Savoir : la connaissance pour tous et sans pépins
- YunoHost : s'héberger soi-même en toute simplicité
- Site de Fvirtman : recueil de projets et de codes en C et C++
- Par ici la sortie : le site des idées de sorties


  © 2005-2018 linor.fr - Toute reproduction totale ou partielle du contenu de ce site est strictement interdite.