Discussion :

[Bakura]

Voilà, je suis en train de m'initier à quelques techniques simples d'optimisation. Les display lists, c'est vu, c'est très facile. Mais là je suis en train d'essayer de comprendre le fonctionnement des vertex arrays, mais là j'ai plus de mal et je me pose pas mal de questions sur leur fonctionnement...

Si je comprends bien, il faut, dans un premier temps, déterminer dans des tableaux toutes les valeurs que l'on souhaitent (vertices, couleurs, coordonnées de texture, couleurs secondaires...) dans des tableaux de valeurs identiques à ce qu'on ferait avec glBegin.

Par exemple, si je veux dessiner un carré texturé avec deux couleurs de fond pour le GL_MODULATE :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
glBegin (GL_TRIANGLES_STRIP);
   glColor3ub (255, 0, 255);
   glTexCoord2f (1.0f, 0.0f); glVertex3f (1.0f, -1.0f, 0.0f);
   glTexCoord2f (0.0f, 0.0f); glVertex3f (-1.0f, -1.0f, 0.0f);
   glColor3ub (0, 0, 255);
   glTexCoord2f (1.0f, 1.0f); glVertex3f (1.0f, 1.0f, 0.0f);
   glTexCoord2f (0.0f, 1.0f); glVertex3f (-1.0f, 1.0f, 0.0f);
glEnd ();

Ceci nous donnera en vertex arrays :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
 
struct sVertices
{
    GLfloat x, y, z;
}
 
struct sTexCoords
{
    GLfloat s, t;
}
 
struct sCouleurs
{
    GLubyte r, g, b;
}
 
sVertices verticesTab [4] = { {1.0f, -1.0f, 0.0f}, {-1.0f, -1.0f, 0.0f},
                                        {1.0f, 1.0f, 0.0f}, {-1.0f, 1.0f, 0.0f} };
 
sTexCoords [4] = { {1.0f, 0.0f}, {0.0f, 0.0f}, {1.0f, 1.0f}, {0.0f, 1.0f} };
 
sCouleurs [2] = { {255, 0, 255}, {0, 0, 255} };

Après on active les vertex arrays avec glEnableClientState pour tex, couleur, vertices.

Et ensuite on charge le tout :

glVertexPointer(3, GL_FLOAT, 0, verticesTab);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, sCouleurs);
glTexCoordPointer(2, GL_FLOAT, 0, sTexCoords);

Puis enfin on dessine avec :

glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

Bon alors pour commencer je sais pas trop comment cet appel fonctionne...

Comment fait-il pour savoir si je veux spécifier la deuxième couleur que pour les deux dernières vertices comme dans mon premier exemple ? En gros je voudrais savoir quels appels cette fonction effectue, en équivalent glBegin/glEnd. En quoi ceci améliorerait les performances étant donné qu'il doit quand même dessiner les vertices comme le ferait glBegin/glEnd ? En quoi sa conception diffère de ce dernier ?

D'autre part, si on veut changer les coordonnées du carré, par exemple si on veut le décaler d'une unité ? Euuuh... On fait un glTranslate, c'est bien ça ?

Enfin, mon livre parle de pleins d'autres techniques qu'il dit plus efficace : glMultiDrawArrays (pareil que le premier sauf qu'on peut créer plusieurs éléments d'un coup, facile), glDrawElements : alors là c'est plus compliqué : un argument, GLvoid * indices, me gêne. J'ai un peu de mal à comprendre ce qu'ils veulent dire par : "indices is an array containing indexes for the vertices you want to render". A quoi sert cette fonction ?

il y a aussi le glDrawRangeElements et glInterleavedArrays (pour ce dernier je pense avoir compris)...

Sinon le livre parle aussi des vertex buffer objects introduit avec OGL 1.5 en disant qu'ils sont bien plus performants, mais ne les traîte pas. Sont-ils vraiment plus performants, et plus durs à utiliser ? Et quelle est la différence dans leur fonctionnement par rapport à des vertex arrays. Voilà ^^

[Laurent Gomila]

Comment fait-il pour savoir si je veux spécifier la deuxième couleur que pour les deux dernières vertices comme dans mon premier exemple ?

Il ne peut pas. Chaque position doit avoir sa propre couleur correspondante.

En quoi ceci améliorerait les performances étant donné qu'il doit quand même dessiner les vertices comme le ferait glBegin/glEnd ? En quoi sa conception diffère de ce dernier ?

avec glBegin/glEnd, le driver ne peut pas voir plus loin que le sommet que tu es en train de dessiner, aucune optimisation n'est possible. Avec les vertex arrays tu envoies toute ta géometrie d'un coup ; le driver a beaucoup plus de liberté pour optimiser (nombre d'appels driver réduits à 1, transfert AGP effectué en un morceau, ...).

D'autre part, si on veut changer les coordonnées du carré, par exemple si on veut le décaler d'une unité ? Euuuh... On fait un glTranslate, c'est bien ça ?

Par exemple. Rien ne t'empêche aussi de changer ton tableau de positions ; profites-en tant que tu n'as pas encore abordé les techniques suivantes, où tes sommets seront cette fois en mémoire vidéo et donc beaucoup moins facilement accessibles

Enfin, mon livre parle de pleins d'autres techniques qu'il dit plus efficace : glMultiDrawArrays (pareil que le premier sauf qu'on peut créer plusieurs éléments d'un coup, facile), glDrawElements : alors là c'est plus compliqué : un argument, GLvoid * indices, me gêne. J'ai un peu de mal à comprendre ce qu'ils veulent dire par : "indices is an array containing indexes for the vertices you want to render". A quoi sert cette fonction ?

Imagine un cube : tu as 8 sommets, mais comme il faut 12 triangles pour le dessiner,tu vas en fait en créer 36 chaque sommet sera inutilement dupliqué 8 fois. Avec les indices tu crées tes 8 sommets uniques, et tout ce que tu dupliques cette fois ce ne sera que les indices.

Exemple simplissime pour un carré :

Code :

Sélectionner tout - Visualiser dans une fenêtre à part

1
2
3
4
5
6
7
8
9
10
sommets =
{
    A, B, C, D
}
 
indices =
{
    0, 1, 2, // triangle 1
    2, 1, 3  // triangle 2
}

Les sommets numéro 1 et 2 sont répétés, mais en mémoire ils n'existent tout de même qu'en un exemplaire.

il y a aussi le glDrawRangeElements et glInterleavedArrays (pour ce dernier je pense avoir compris)...

glDrawRangeElements est utile si les primitives que tu rends ne concernent qu'une sous-plage précise de tes tableaux de géometrie ; ça permet d'optimiser encore un poil en ne traitant pas inutilement la totalité des tableaux.

glInterleavedArrays, en toute logique (jamais vraiment utilisé, j'ai commencé OpenGL avec les VBOs), sert à dessiner des primitives dont les données se trouvent toutes entrelacées dans le même tableau ; comme ce qu'on fait avec DirectX.

Sinon le livre parle aussi des vertex buffer objects introduit avec OGL 1.5 en disant qu'ils sont bien plus performants, mais ne les traîte pas. Sont-ils vraiment plus performants, et plus durs à utiliser ? Et quelle est la différence dans leur fonctionnement par rapport à des vertex arrays. Voilà ^^

Oui, les VBO c'est le truc ultime. Plus durs non, enfin un peu du fait qu'ils se trouvent en mémoire vidéo et requierent donc de passer par des fonctions spécifiques pour accéder à leur contenu. Après, le fonctionnement est le même que pour les vertex arrays (glxxxPointer, glDrawArrays/glDrawElements, ...).

[Bakura]

Je te remercie de ta réponse, ça m'aide bien ^^...

J'étudierais ça ce soir et je reviens si j'ai pas tout compris.

Par contre pour les VBOs, tu pourrais me montrer un petit exemple de code ou un tuto qui montre ça ? Si c'est pas spécialement plus dur à utiliser que les vertex arrays, autant essayer d'apprendre les deux en combo (d'ailleurs, dans quel cas un vertex arrays seriat plus intéressant qu'un vbo, si il l'est à certaines conditions ?).

Enfin, t'as pas trop répondu à ça : je voudrais savoir comment cet appel :

glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

avec

glVertexPointer(3, GL_FLOAT, 0, verticesTab);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, sCouleurs);
glTexCoordPointer(2, GL_FLOAT, 0, sTexCoords);

se répercute ?

fait-il : 1 vertex, 1 texture, 1 couleur, la 2ème vertex, la 2ème couleur, la 2ème texture,... Dans quel ordre effectue t'il ça ?

[Laurent Gomila]

Par contre pour les VBOs, tu pourrais me montrer un petit exemple de code ou un tuto qui montre ça ?

Tout ce que je pourrais te donner en lien ne viendrait que d'un "vertex buffer object tutorial" sous Google. Donc je te laisse deviner la suite...

d'ailleurs, dans quel cas un vertex arrays seriat plus intéressant qu'un vbo, si il l'est à certaines conditions ?

Je ne pense pas qu'il existe des cas où un vertex array soit plus intéressant, mais peut-être qu'un expert d'OpenGL va nous trouver un exemple de derrière les fagots.

Enfin, t'as pas trop répondu à ça : je voudrais savoir comment cet appel :

glDrawArrays(GL_TRIANGLE_STRIP, 0, 4);

avec

glVertexPointer(3, GL_FLOAT, 0, verticesTab);
glColorPointer(3, GL_UNSIGNED_BYTE, 0, sCouleurs);
glTexCoordPointer(2, GL_FLOAT, 0, sTexCoords);

se répercute ?

fait-il : 1 vertex, 1 texture, 1 couleur, la 2ème vertex, la 2ème couleur, la 2ème texture,... Dans quel ordre effectue t'il ça ?

Rien de défini, il fait juste appel aux fonctionnalités correspondantes du driver.

[bafman]

Je ne pense pas qu'il existe des cas où un vertex array soit plus intéressant, mais peut-être qu'un expert d'OpenGL va nous trouver un exemple de derrière les fagots.

je soulève un fagot et... ha bah non en fait
les VBO sont l'extension des vertex array. en gros ca permet d'avoir plusieurs vertex array en parallel. c'est un peu comme ce qui a été fait pour les textures. au debut d'openGL, on ne pouvais avoir qu'une seule texture, si on voulais en utiliser plusieurs, il fallais les charger au moment de l'utilisation... ensuit, ils ont mis au point les objet de textures qui permettent d'avoir plusieurs textures qu'on peut binder... bah pour les VBO c'est la meme chose. donc les VBO et les vertex array on strictement la meme utilisation

[Bakura]

D'accord merci ^^... Donc c'est juste le nom des fonctions à appeler qui changent ? Oh ça va alors ^^...

au debut d'openGL, on ne pouvais avoir qu'une seule texture, si on voulais en utiliser plusieurs, il fallais les charger au moment de l'utilisation... ensuit, ils ont mis au point les objet de textures qui permettent d'avoir plusieurs textures qu'on peut binder...

C'est vraiq ue c'est vachement pratique le multitexturing ! Si on devait à chaque fois binder chaque texture différente, oulalala