conception avec multiple tableaux indices

Version imprimable

30/10/2012, 13h09
0_Azerty_0

conception avec multiple tableaux indices

Bonjour,

Je me lance actuellement dans un projet de développement et je tente pour le moment de perfectionner mon loader de .obj.

Comme vous le savez très certainement, un objet peut être découpé plusieurs groupes, associés à différents matérials. J'ai pour le moment un loader qui crée une instance de classe Geometry. Cette classe contient 3 tableaux d'attributs de vertices :

- un pour les positions
- un pour les normales
- un pour les coordonnées de texture

La classe Geometry contient également des instances d'une classe Group. Chaque groupe possède 6 tableaux d'indices. 3 associés à chaque attribut de vertex pour les triangles et 3 autres pour les indices de quad.

J'ai beaucoup de questions :

- Comment dois-je faire pour associer correctement mes indices à chacun de mes tableaux. En effet, avec les VBO (j'ai un petit problème avec, voir mon autre post) et VAO, on peut visiblement associer un indice qui va être partagé pour chaque attribut de vertex, or lorsque l'on charge une face d'un .obj :

Code:

f 1/2/3 4/5/6 7/8/9

On remarque que les indices associés aux positions sont différents de ceux asosciés aux normales ou encore aux coordonnées de texture.
Je fais beaucoup de recherches et jecommence à tout mélanger.

Mon problème est donc plus d'ordre théorique : Comment faire pour avoir un rendu efficace, en évitant de copier les données. (Je ne saurais refuser un peu de code non plus :) )

Voilà, merci d'avance à ceux qui prendront la peine de lire et de répondre à ce post.

Az
30/10/2012, 16h23
gladek

je te conseille de creer un classe vertex qui est consitué
d'un point x,y,z
d'une normale x,y,z
d'une coord texture u,v
d'une couleur r,g,b
un indice unique

ta classe geometry sera constituée d'une liste de vertices(1...n)
l'idéal étant 3 vertices maximum pour dessiner ensuite des triangles.

Ainsi quelque soit le rendu utilisé direct, vao, vbo il sera plus simple de creer les buffer et de dessiner.

Pour reconstituer une face a partir du fichier obj, regarde le format sur google, ya pleins d'exemples. Voila une explication qui explique les faces
f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3
01/11/2012, 10h46
0_Azerty_0

En fait pour le moment je parse déjà un .obj.

Tu n'as pas compris mon problème Quand tu lis une face grace à cette ligne :

Code:

f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3

Tu as trois indices par point...A partir de ce moment, comment veux tu avoir une classe vertex qui contient un indice unique dans la mesure où:

v1 != vt1 != vn1
01/11/2012, 13h34
LittleWhite

Bonjour,

J'imagine que vous n'utilisez pas une bibliothèque du type de Assimp parce que vous voulez vous amuser à refaire un loader.

En théorie (car j'ai du mal à voir votre problème), il faut un tableau de vertex (soit un tableau d'une structure Vertex, soit un tableau pour les position, un pour les normals et un pour les texcoords (et un pour les couleurs mais c'est très rare)). La structure Vertex ne contiendra par les indices. Ensuite il faut un second tableau, pour les indices et hop c'est fini (on passe tout ça à OpenGL). Car grâce aux indices, OpenGL piochera dans les tableaux de données (positions, normals, texcoords). Même si trois indices utilisent le même vertex, ça marche.
01/11/2012, 20h43
0_Azerty_0

Effectivement, je souhaitais développer mon propre loader, mais bon, c'est beaucoup de temps, donc je ne saispas si je vais continuer. Dans tous les cas,une chose m'échappe toujours malgré vos explications :

Un tableau d'indice par défaut contient les indices des positions.
Lorsque l'on charge une face simple "f 1 2 3", il relie les 3 points portant ces indices. Seulement lorsque l'on a une face "f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3" contenant pour chaque point :

- L'incide de la position à utiliser
- L'indice de la normale àutiliser
- L'incice de la coordonnée de texture à utiliser.

Il faut forcément faire savoir à OpenGL à un moment ou à un autre que tel indice est un indice de position, de normal ou de cooronnée de texture, non ?

Donner en gros : v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3
ou : v1/v2/v3 v4/v5/v6 v7/v8/v9
n'aura pas le même effet. Dans le premier cas il sait qu'il a affaire à une face de trois points avec normales et Coord de Tex alors que dans le deuxième cas, on lui passe 9 indices de positions avec lesquels il pourra faire 3 faces...

Pour moi c'est une différence énorme, et je ne comprends pas comment on le spécifie à OpenGL.
01/11/2012, 20h57
LittleWhite

Pour le cas :

Citation:

"f v1/vt1/vn1 v2/vt2/vn2 v3/vt3/vn3"

Je ne sais pas non plus comment dire à OpenGL, trois tableaux d'indices différents pour une seule mesh.
Par contre, une technique possible, c'est de restructurer correctement les données afin qu'elles soient utilisables dans OpenGL. Je veux dire par là, qu'au moment de la lecture du fichier, vous allez faire en sorte d'interprété les données afin qu'elles soient tout comme vous le voulez en mémoire.
01/11/2012, 21h14
0_Azerty_0

Merci,je vais me resneigner à ce propos alors !
Cependant, si quelqu'un a la réponse à cette question, je suis preneur !
02/11/2012, 08h48
dragonjoker59

Pour loader les .obj, je ne me suis pas embêté à stocker les 3 indices différents, j'ai fait comme t'a proposé gladek, c'est à dire créer une classe Vertex avec les informations nécessaires dedans : position, normale, texcoords, index.
Il faut donc procéder différemment de ce que tu souhaiterais faire pour tes multiples tableaux d'indices : on récupère d'abord les "v", "vn" et "vt" dans des tableaux différents puis lorsqu'on lit les "f" on construit les vertex à partir des tableaux récupérés.
Ce n'est pas particulièrement compliqué à mettre en place et ça a l'intérêt de ne pas tourner ton architecture vers un seul format de fichier.
02/11/2012, 11h22
0_Azerty_0

Salut,

Je voulais justement éviter la duplication de données induite par cette méthode, mais il semblerait que ce soit la seule. Je vais donc implémenter ca.

Merci à tous les trois pour vos réponses.

Bonjour,

J'ai essayé de développer cette méthode. Je préfère passer par la méthode d'indices entrecroisés, même si elle est un peu plus compliquée à mettre en place. (Y a t-il un avantage d'ailleurs ?).

Cependant, mon code ne fonctionne pas une nouvelle fois et je ne comprends pas pourquoi : Les données ne semblent pas être correctes dans le buffer alorq que je les envoie a priori juste normalement.

Voyez vous quelque chose suspect ? :

Je déclare une structure Vertex comme suit :

Code:

1
2
3
4
5
struct Vertex {
    double positions[3];
    double normals[3];
    double textcoords[2];
};

Ensuite, j'utilise un tableau de Vertex, nommé Vertices :

Code:

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
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
void  Geometry::createVBO()
{
    // Create and bind a BO for vertex data
    glGenBuffers(1, &vbuffer);
    glBindBuffer(GL_ARRAY_BUFFER, vbuffer);
    glBufferData(GL_ARRAY_BUFFER, (nb_vert)*sizeof(Vertex), Vertices, GL_STREAM_DRAW);
 
    // Create and bind a BO for index data
    glGenBuffers(1, &ibuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuffer);
    glBufferData(GL_ELEMENT_ARRAY_BUFFER, nb_tri*3*sizeof(unsigned int), m_indices3, GL_STREAM_DRAW);
 
    glBindBuffer(GL_ARRAY_BUFFER,0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER,0);
 
    // Méthode 2 : Spécification des indices de tableaux
    glBindAttribLocation (m_shaderCouleur.getProgramID(), 0, "in_Vertex") ;
    glBindAttribLocation (m_shaderCouleur.getProgramID(), 1, "in_Normal") ;
    glBindAttribLocation (m_shaderCouleur.getProgramID(), 2, "in_TextCoord") ;
}
 
void Geometry::draw(Matrix4& projection, Matrix4& modelview) const
{
    // Activation du shader et des tableaux Vertex Attrib
    glUseProgram(m_shaderCouleur.getProgramID());
 
    glUniformMatrix4fv(glGetUniformLocation(m_shaderCouleur.getProgramID(), "projection"), 1, GL_TRUE, projection.getValeurs());
    glUniformMatrix4fv(glGetUniformLocation(m_shaderCouleur.getProgramID(), "modelview"), 1, GL_TRUE, modelview.getValeurs());
 
    // Active les Buffers
    glBindBuffer(GL_ARRAY_BUFFER, vbuffer);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, ibuffer);
 
    // Activation des tableaux génériques
    glEnableVertexAttribArray(0);
    glEnableVertexAttribArray(1);
    glEnableVertexAttribArray(2);
 
    // Envoi des vertices et des matrices
//    glVertexAttribPointer(0, 3, GL_DOUBLE, GL_FALSE, 0, 0);
 
    glVertexAttribPointer(0, 3, GL_DOUBLE, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(offsetof(Vertex, positions)));
    glVertexAttribPointer(1, 3, GL_DOUBLE, GL_FALSE, sizeof(Vertex), BUFFER_OFFSET(offsetof(Vertex, normals)));
    glVertexAttribPointer(2, 2, GL_DOUBLE, GL_TRUE,  sizeof(Vertex), BUFFER_OFFSET(offsetof(Vertex, textcoords)));
 
//    glDrawArrays(GL_TRIANGLES,0,8);
    glDrawElements(GL_TRIANGLES, nb_tri*3, GL_UNSIGNED_INT, 0);
 
    glDisableVertexAttribArray(2);
    glDisableVertexAttribArray(1);
    glDisableVertexAttribArray(0);
 
    glBindBuffer(GL_ARRAY_BUFFER, 0);
    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
 
    glUseProgram(0);
}

Voici ci dessous le contenu de mon tableau Vertices et du tableau indices :

Code:

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
Vertices Sructures: 
 
Vertex 1:  	  Positions (-1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 2:  	  Positions (1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 3:  	  Positions (1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 4:  	  Positions (1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 5:  	  Positions (-1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 6:  	  Positions (-1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 7:  	  Positions (1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 8:  	  Positions (1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 9:  	  Positions (1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 10:  	  Positions (1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 11:  	  Positions (1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 12:  	  Positions (1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 13:  	  Positions (-1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 14:  	  Positions (1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 15:  	  Positions (1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 16:  	  Positions (1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 17:  	  Positions (-1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 18:  	  Positions (-1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 19:  	  Positions (-1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 20:  	  Positions (1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 21:  	  Positions (1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 22:  	  Positions (1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 23:  	  Positions (-1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 24:  	  Positions (-1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 25:  	  Positions (-1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 26:  	  Positions (-1,-1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 27:  	  Positions (-1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 28:  	  Positions (-1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 29:  	  Positions (-1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 30:  	  Positions (-1,-1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 31:  	  Positions (-1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 32:  	  Positions (1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 33:  	  Positions (1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 34:  	  Positions (1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 35:  	  Positions (-1,1,-1) 	  Normals (0,0,0) 	  Textcoords (0,0)
Vertex 36:  	  Positions (-1,1,1) 	  Normals (0,0,0) 	  Textcoords (0,0)
36 Indices triangles: (0,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,)

Voici ici l'image du contenu de mes buffers qui ne semblent pas du tout être correct :

http://img11.hostingpics.net/pics/139698qiUWNCopie.jpg

Bon, l'affichage n'est pas fait pour, je devrais avoir XYZ N1N2N3 ST
Mais il n'empêche que je ne comprendspas cette affichage : Pourquoi OpenGL me créé 72 occurences de Vertex alors que je n'en charge que 36 en faisant (nb_vert est bien égale à 36):

Code:

glBufferData(GL_ARRAY_BUFFER, (nb_vert)*sizeof(Vertex), Vertices, GL_STREAM_DRAW);

De plus pourquoi mes 1 sont-ils transformés en 1.875par gDEBugguer ???

J'ai essayé de mettre des -1 pour les 3 valeurs des normales,rien ne change dans gDEBugguer. Je suis un peu scpétique... Quelqu'un a t-il déjà rencontré ces problèmes ?

09/11/2012, 14h01
gladek

Le format OBJ est ancien et ne respecte pas convenablement les standards actuels. En effet, la notion de vertex façon OBJ correspond a un point alors que de façon répandu en OpenGL il s'agit de la structure decrite plus haut (point, couleur, normale, coordUv...).
De plus, les faces définies en OBJ ne sont pas systematiquement des triangles !

En gérant tes données par vertex, tu te facilites la notion d'indices, un seul tableau d'indices pour tout :) et surtout tu te débarasses des format de fichier comme la précisé dragonjoker59.

Ta variable vData contient quoi ?
px, py, pz, nx, ny, nz, uvu, uvv ?
09/11/2012, 15h57
dragonjoker59

Que te dit glGetError ? Comment stockes-tu tes Vertex ?
10/11/2012, 10h09
0_Azerty_0

Citation:

Envoyé par gladek

Le format OBJ est ancien et ne respecte pas convenablement les standards actuels. En effet, la notion de vertex façon OBJ correspond a un point alors que de façon répandu en OpenGL il s'agit de la structure decrite plus haut (point, couleur, normale, coordUv...).
De plus, les faces définies en OBJ ne sont pas systematiquement des triangles !

En gérant tes données par vertex, tu te facilites la notion d'indices, un seul tableau d'indices pour tout :) et surtout tu te débarasses des format de fichier comme la précisé dragonjoker59.

Ta variable vData contient quoi ?
px, py, pz, nx, ny, nz, uvu, uvv ?

Oui, j'ai bien compris et j'ai suivi vos conseils en créant une structure Vertex rassemblant les informations relatives à un sommet. J'ai du coup 36 points (6 faces * 2 triangles * 3 points). Effectivement dans mon .OBJ, lorsque je rencontre une face, je créé X nouveaux Vertices avec les normals, coordonnées et textcoords relatives afin de n'avoir qu'un tableau d'indices.

Citation:

Envoyé par gladek

Ta variable vData contient quoi ?
px, py, pz, nx, ny, nz, uvu, uvv ?

Tout à fait !

Citation:

Envoyé par dragonjoker59

Que te dit glGetError ? Comment stockes-tu tes Vertex ?

glGetError() renvoie 1281 après l'envoi des matrices avec glUniformMatrix4fv(...), ensuite, il repasse à 0.
Pour ce qui est du stockage des Vertex,je les stocke dans un tableau dynamique très simplement :

Code:

Vertex* Vertices;
12/11/2012, 09h33
dragonjoker59

Déjà si tu as une erreur lors de l'appel de glUniformMatrix4v (ici "invalid value"), ta matrice ne sera pas appliquée.
Ensuite, tu utilises GL_STREAM_DRAW, moi je les passe en GL_STATIC_DRAW. Ca donne quoi si tu les passes ainsi ?
14/11/2012, 10h43
gladek

tu peux jeter un oeil sur mon ancien thread :
http://www.developpez.net/forums/d10...engl/jogl-vbo/

j'ai rencontré des problemes similaires lors de la mise en place de VBO. J'avais mal parametrer les fonctions :oops:
25/11/2012, 19h57
0_Azerty_0

Salut et désolé pour le manque de réponse.
Je suis litéralement débordé et n'ai plus le temps pour le moment de travailler sur ce projet. Je reviendrai dessus plus tard