Discussion :

[Lung]

J'essai toujours de comprendre le fonctionnement des VBO (mais j'ai du mal).
Je vois bien que glBufferData(GL_ARRAY_BUFFER ... est pour transmettre la liste des vertex.

Mais, je ne comprend pas comment fonctionne GL_ELEMENT_ARRAY_BUFFER.
J'ai lu que ca servait à transmettre des indices, mais des indices de quoi ?

Si c'est des indices de vertex, alors dans ce cas, GL_ARRAY_BUFFER ne sert plus à rien.

Si quelqu'un pouvait me donner une explication complète et détaillée ...
Merci d'avance.

[Ceejay]

GL_ELEMENT_ARRAY_BUUFER est pour les indices de points qui forment les facettes. C'est pour transmettre la topologie du maillage.

Par exemple dans un fichier .OFF, après l'entête tu as la liste des coordonnées des points, suivie d'une liste de lignes d'entiers. Le premier est le nombre de sommets composant la facette, les autres les numéros (indices) des sommets la composant. Ce sont ces entiers qui vont dans un GL_ELEMENT_ARRAY_BUFFER.

Pour dessiner le maillage, après avoir rempli les buffers avec glBufferData, il faut dire à OpenGL dans quel buffers sont tes sommets avec les 2 appels suivants :
glBindBuffer(GL_ARRAY_BUFFER, maillage->idBufferSommets);
glVertexPointer(3, GL_FLOAT, sizeof(float)*3, NULL);

puis dessiner selon un index :
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, maillage->idBufferIndex);
glDrawElements(GL_TRIANGLES, 3*(maillage->nbIndex), GL_UNSIGNED_INT, NULL);

Ces lignes fonctionnent pour un maillage triangulaire, il faut adapter en conséquence bien sûr.

Je débute en OpenGL donc je ne peux guère en dire plus mais je peux te donner un document qui m'a bien aidé.
http://www.g-truc.net/article/vbo.pdf

[Lung]

Merci pour ta réponse.


Je vais potasser le pdf ...

[Lung]

J'ai regardé le pdf, mais il évoque seulement que ça existe, sans expliquer comment il faut s'en servir.

Le premier est le nombre de sommets composant la facette, les autres les numéros (indices) des sommets la composant. Ce sont ces entiers qui vont dans un GL_ELEMENT_ARRAY_BUFFER.

Je ne comprend toujours pas à quoi correspond ces indices.
Comment OpenGL peut deviner à quoi correspond ces nombres ?

[plegat]

Je ne comprend toujours pas à quoi correspond ces indices.
Comment OpenGL peut deviner à quoi correspond ces nombres ?

Le premier buffer (le GL_ARRAY_BUFFER) va répertorier tes vertex. Vois ça comme une grande armoire à case, où dans chaque case, numérotée, on va mettre les coordonnées des points.

Le second buffer (le GL_ELEMENT_ARRAY_BUFFER) va lui répertorier les numéros des cases du premier buffer à utiliser pour dessiner chaque élément (vu que ça serait idiot de lui fournir directement les coordonnées des points, ils sont déjà dans l'autre buffer).
Quand OpenGL va le parcourir, il sait déjà quel type d'élément il doit dessiner (par exemple des GL_TRIANGLES), il sait donc combien d'index il doit récupérer (3), il va donc aller récupérer les 3 valeurs (ou index) dans la case en cours (par exemple 1234, 2275 et 3741), et il va aller chercher dans le premier buffer le contenu des cases n° 1234, 2275 et 3741 (donc trois jeux de coordonnées), et dessiner son triangle avec ses trois sommets.

C'est plus clair?

[kremvax]

Pour info complémentaire, tu peux très bien passer directement les vertice sans utiliser de tableau d'indice, donc tu peux te passer de GL_ELEMENT_ARRAY_BUFFER.

L'utilité des indices, c'est de limiter les redondances de coordonnées de vertex. Par exemple pour deux triangles qui ont un coté adjacent, tu enverrais à la carte graphique [6 * (vertexsize)] octets sans indice, contre [4 * (vertexsize) + 6 * (indexsize)] octets avec indices sachant que "indexsize" est très petit par rapport à "vertexsize". Plus le nombre de redondances augmente, plus ça devient intéressant.

[Lung]

C'est plus clair?

Ca commence.
Et ça correspond à l'idée que je m'en étais fait, au début.

Ce qui me perturbe, c'est l'exemple à la fin de ce tutoriel : http://raptor.developpez.com/tutorial/opengl/vbo/
Je n'arrive pas à appliquer cette logique à cet exemple.
Si les indices correspondent à des paquets des 3 (x, y, z) dans le premier tableau, alors vu le nombre d'indices, il n'y a que la moitié du premier tableau qui est utilisé, non ?
Comme je suppose que l'autre moitié n'est pas là pour faire joli , c'est qu'il y a encore quelque chose qui m'échappe ...

Pour info complémentaire, tu peux très bien passer directement les vertice sans utiliser de tableau d'indice, donc tu peux te passer de GL_ELEMENT_ARRAY_BUFFER.

Je suis d'accord.

L'utilité des indices, c'est de limiter les redondances de coordonnées de vertex.

Actuellement, j'utilise du rendu immédiat avec des listes, et j'ai un fps qui ne dépasse pas 75 pour quelques quadrilataires. J'ai cru comprendre qu'avec une GeForce 8800 GT, c'était très peu. Donc, tant qu'à optimiser, autant le faire complètement, non ?

[plegat]

Ce qui me perturbe, c'est l'exemple à la fin de ce tutoriel : http://raptor.developpez.com/tutorial/opengl/vbo/
Je n'arrive pas à appliquer cette logique à cet exemple.
Si les indices correspondent à des paquets des 3 (x, y, z) dans le premier tableau, alors vu le nombre d'indices, il n'y a que la moitié du premier tableau qui est utilisé, non ?
Comme je suppose que l'autre moitié n'est pas là pour faire joli , c'est qu'il y a encore quelque chose qui m'échappe ...

Vi, mais c'était subtil!
En fait, le premier tableau contient les infos de couleur (3 float) et de position des sommets (3 float), ceci pour les 8 sommets, donc (3+3)*8=48 float (valeurs à comparer avec les chapitre III-C dans le tuto).
Si tu regardes les appels à glVertexPointer et glColorPointer, le même buffer est utilisé, mais l'index de base est décalé de 3 entre les deux.

[Lung]

Arg !
J'avais oublié la couleur.

Par contre, rien ne m'empêche, de séparer les vertex, les couleurs, les normales, les textures, ... dans des tableaux séparés ?
Ca ne me donnera pas des performences moindres ?