Discussion :

[Jbx 2.0b]

Salut tout le monde, j'ai deux questions.

Voila premiére question :
j'ai la géométrie de mes objets définie par ses vertices, les normales à ces vertices, et idface qui contient les indices des vertices ( par exemple si idface[0] = 1, idface[1] = 5 et idface[2] = 3 donc les vertices 1,5,et 3 forment une face. Jusqu'a la easy.
Ensuite j'ai mes coordonnées de textures, et les indices de textures idfacemap ( par exmple si idfacemap[0] = 2 , idfacemap[1] = 5 et idfacemap[2] = 7, la premiére face aura comme coordonnées de texture celle compris dans texcoord[2] , texcoord[5], texcoord[7].
C'est une structure tout ce qui a de plus classique, comme la présente 3D Studio dans ses fichiers par exemple. Voila le (faux) code qui explique un peu ça:

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
 
float vertex[] = {...}             // les vertex de l'objet
float normal[] = {...}            // les normales correspondantes
unsigned int idface[] = {...}   // les indices vertex des faces
float texcoord[] = {...}          // les coordonnées des textures
float idfacemap[] = {...}        // les indices textures des faces
 
//et j'affiche comme ça
glBegin(GL_TRIANGLES);
for (unsigned int i=0;i<nbface*3;i++)
{
	glNormal3fv(&vnorm[idface[i]*3]);
	glTexCoord2fv(&map[idfacemap[i]*2]);
	glVertex3fv(&vert[idface[i]*3]);
}
glEnd();

Jusqu'a la tout va bien, mais quand je veu mettre tout ça dans un vertex array, qu'es ce que je fais du idfacemap : :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
14
 
float vertex[] = {...}             // les vertex de l'objet
float normal[] = {...}            // les normales correspondantes
unsigned int idface[] = {...}   // les indices vertex des faces
float texcoord[] = {...}          // les coordonnées des textures
float idfacemap[] = {...}        // les indices textures des faces
 
// il faut bien comprendre que idfacemap != idface, d'ou mon probléme
 
//à l'affichage
glVertexPointer (3, GL_FLOAT, 0, vertex );
glNormalPointer ( 3, GL_FLOAT, normal);
glTexCoordPointer(2, GL_FLOAT, 0 ,texcoord);
glDrawElements (GL_TRIANGLES, 3, GL_UNSIGNED_INT, idface );

La mon objet aura sa texture plaquée n'importe comment vu qu'on ne fait pas d'appele à idfacemap .
Peut - être qu'il faut que je réarrange mes données, mais c'est bizard je pense que c'est possible comme ça vu que 3DS me la donne comme ça
HELP

2éme question:
j'allais essayer mais si quelqu'un à la reponse : si je spécifie la géométrie de mes objets avec un vertex array, et que je place tout ça dans une display list, que ce passe t-il quand j'appelle cette liste : Et si ça fonctionne malgrés tout, que se passe t il en fait :
Quelle la différence entre une display list, un vertex array, un vertex array compilé du point de vue de la mémoire / de la mémoire de la carte graphique. Je crois que les vertex array compilés sont stockés en mémoire graphique, mais pour les autres, ça se passe comment ?

[bafman]

le plus simple pour utiliser les vertex array c'est de crée une classe de vertex genre

Code :

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

1
2
3
4
5
6
7
 
class Vertex
{
    float position[3];
    float texCoord[2];
    float normal[3];
}

et apres tu utilise le stride des vertex array pour specifier tout ca avec
pour les vertex

Code :

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

1
2
 
glVertexPointer ( 3, GL_FLOAT, sizeof(Vertex), &vertices.position[0] );

pour la texture

Code :

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

1
2
 
glTexCoordPointer ( 2, GL_FLOAT, sizeof(Vertex), &vertices.texCoord[0] );

et pour les normal

Code :

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

1
2
 
glNormalPointer ( GL_FLOAT, sizeof(Vertex), &vertices.normal[0] );

en gros le sizeof(Vertex) donne au vertex array la distance memoire entre 2 Vertex et donc quand il lis les info, il se decalera pour chaque vertex de la distance memoire voulu...

[Jbx 2.0b]

mieux si tu crée une structure/class comme ça:

Code :

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

1
2
3
4
5
6
7
 
struct Vertex
{
    float texCoord[2]; 
    float normal[3];
    float position[3]; 
};

c'est d'utiliser la fonction glInterleavedArrays(...) avec GL_T2F_N3F_V3F comme premier argument (selon le post de dake, elle serait + rapide encore). En effet les données sont contigues dans la mémoire( 2 texCoord, 3 normales, 3 positions, 2 texCoord, 3 normales, 3 positions .....) , et si on donne le pointeur vertex.texcoord à cette fonction elle va trouver tout ce dont elle a besoin.
Comme ça:

Code :

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

1
2
3
 
Vertex vertex[...];
glInterleavedArrays (GL_T2F_C3F_V3F, 0, vertex.texcoord);

pour rendre ça plus propre & plus lisible on peu utiliser un union :

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
 
struct vertex
{
    union
    {
        struct
        {
            float texCoord[2]; 
            float normal[3];
            float position[3]; 
        };
        float v[8];
    };
};
 
 
...
 
Vertex vertex[...];
glInterleavedArrays (GL_T2F_C3F_V3F, 0, vertex.v);
...

+