Discussion :

[benicourt]

Bonjour à tous,
Je démarre sous OpenGL 4 et j'éprouve quelques difficultés aujourd'hui à mettre à niveau mon chargeur d'Obj (Wavefront).

Avant j'utilisais 3 tableaux séparés (position, texcoord et normals) + 1 tableau de Poly (face) correspondant aux indices des points à tracer.

Le problème est que l'index est différent entre points, texcoord et normals puisqu'une face s'exprime sous la forme:

f pos1/tex1/norm1 pos2/tex2/norm2 pos3/tex3/norm3 et que pos1!=tex1!=norm1

J'ai galéré pas mal de temps jusqu'à comprendre qu'on ne peut pas avoir un buffer d'index différent pour 2 attributs. Soit...

Après un gros travail, j'ai reconstruit un type de vertex du style :
struct cVertex
{
cVector3f position;
cVector2f texCoord;
cVector3f normal;
}

Quand je créé mes buffers, je fais un :

Code :

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

1
2
3
4
5
6
7
glGenBuffers(1, &mesh->VB);
        glBindBuffer(GL_ARRAY_BUFFER, mesh->VB);
        glBufferData(GL_ARRAY_BUFFER, sizeof(cVertex) * mesh->nbVertex, &mesh->vVertexList[0], GL_STATIC_DRAW);
 
        glGenBuffers(1, &mesh->IB);
        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->IB);
        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(unsigned int) * mesh->nbIndx, &mesh->vIndxList[0], GL_STATIC_DRAW);

Mais à l'affichage, j'ai besoin de changer de texture de temps en temps, à divers endroits du buffer.
Pourquoi ne pas découper le buffer en plusieurs morceaux ? Si je change 15 fois de texture et que je balance 15 sous-buffer, même si je peux envoyer qu'une partie de mes indexes, je devrais envoyer complètement les vertex !
Enfin, je dis ça... je ne sais pas - j'ai un peu de mal à comprendre ce que fait chaque fonction en dehors des classiques tutoriaux où je n'ai pas trouvé de secours.

En gros, si je fais cela :

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
glEnableVertexAttribArray(0); // Position
        glEnableVertexAttribArray(1); // texCoord
        glEnableVertexAttribArray(2); // Normals
 
        for (unsigned int i = 0 ; i < mesh->nbElem ; i++) {
            glBindBuffer(GL_ARRAY_BUFFER, mesh->VB);
            glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, sizeof(cVertex), 0);
            glVertexAttribPointer(1, 2, GL_FLOAT, GL_FALSE, sizeof(cVertex), (const GLvoid*)12);
            glVertexAttribPointer(2, 3, GL_FLOAT, GL_FALSE, sizeof(cVertex), (const GLvoid*)20);
 
            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mesh->IB);
 
            // Changement de texture ICI
 
            glDrawElements(GL_TRIANGLES, mesh->vElemList[i].indxE-mesh->vElemList[i].indxB, GL_UNSIGNED_INT, 0);
        }
        glDisableVertexAttribArray(0);
        glDisableVertexAttribArray(1);
        glDisableVertexAttribArray(2);

Si oui, peut-on limiter le glDrawElements et le lancer plusieurs fois avec plus textures sans refaire un glVertexAttribPointer?
A moins que le glVertexAttribPointer soit indolore et ne renvoi qu'un pointeur comme son nom l'indique et pas l'ensemble des vertex...

Je suis un peu perdu, please aider me
Greg

[Kannagi]

Oui tu ouvre un .obj et t'as remarqué que index pour les vertex et les textures sont pas les mêmes , c'est vrai que avec glbegin et glend y a pas ce souci.
J'avais le meme plem quand j'utilisais les vertex array , bon le conseil c'est juste de faire en sorte que l'index soit les mêmes pour vertex et textures par contre faudra refaire index =P

[benicourt]

Je viens de trouver la solution : glDrawElements() prend comme dernier paramètre un (void *)nb avec nb un nombre d'octets de déplacement dans le buffer.

Ainsi, je peux ne charger qu'une seule fois le buffer complet de l'objet et traitement chaque sous-element en l'affichant et en prenant la bonne texture.
Ça fonctionne !