conception avec multiple tableaux indices

**0_Azerty_0** · 30/10/2012, 14h09

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 :

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

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

**gladek** · 30/10/2012, 17h23

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

**0_Azerty_0** · 01/11/2012, 11h46

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 :

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

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

**LittleWhite** · 01/11/2012, 14h34

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.

**0_Azerty_0** · 01/11/2012, 21h43

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.

**LittleWhite** · 01/11/2012, 21h57

Pour le cas :

"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.

**0_Azerty_0** · 01/11/2012, 22h14

Merci,je vais me resneigner à ce propos alors !
Cependant, si quelqu'un a la réponse à cette question, je suis preneur !

**dragonjoker59** · 02/11/2012, 09h48

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.

**0_Azerty_0** · 02/11/2012, 12h22

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.

**0_Azerty_0** · 08/11/2012, 15h52

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 :

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

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 :

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
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 :

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
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 :

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 :

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

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 ?

**gladek** · 09/11/2012, 15h01

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 ?

**dragonjoker59** · 09/11/2012, 16h57

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

**0_Azerty_0** · 10/11/2012, 11h09

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.

Envoyé par gladek

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

Tout à fait !

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 :

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

Vertex* Vertices;

**dragonjoker59** · 12/11/2012, 10h33

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 ?

**gladek** · 14/11/2012, 11h43

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

**0_Azerty_0** · 25/11/2012, 20h57

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

conception avec multiple tableaux indices

OpenGL

Discussions similaires

Partager

Partager