Discussion :

[Elendhil]

Un tableau de 8 sommets:
-0.5 0.5 0.5
0.5 0.5 0.5
-0.5 -0.5 0.5
0.5 -0.5 0.5
-0.5 0.5 -0.5
0.5 0.5 -0.5
-0.5 -0.5 -0.5
0.5 -0.5 -0.5
Un tableau de 6 normals:
1.0 0.0 0.0
-1.0 0.0 0.0
0.0 1.0 0.0
0.0 -1.0 0.0
0.0 0.0 1.0
0.0 0.0 -1.0

un tableau de 6*8 indices donc 6 faces avec offset 0 (vertex) et offset 1 (normals) :

0 4 2 4 3 4 1 4
0 2 1 2 5 2 4 2
6 3 7 3 3 3 2 3
0 1 4 1 6 1 2 1
3 0 7 0 5 0 1 0
5 5 7 5 6 5 4 5


Comment peut-on afficher cela avec openGL svp ? je ne trouve pas la solution , il y a bien glIndexPointer() , mais ici le tableau d'indice est entrelacé .

Si quelqu'un connais la solution je veux bien un petit bout du code.

[ToTo13]

Bonsoir,

voilà un petit bout de code pour afficher une face d'un cube de taille "size" en (x,y,z) dans le plan XY. Il te suffira de l'adapter en considérant qu'une face du cube est un carré qui est lui même composé de deux triangles.

Code :

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

1
2
3
4
5
6
7
8
9
10
11
 
glBegin(GL_TRIANGLES) ; 
glNormal3f(0.f, 0.f, -1.f) ;
glVertex3i(x, y, z) ;
glVertex3i(x+size, y, z) ;
glVertex3i(x+size, y+size, z) ;
glNormal3f(0.f, 0.f, -1.f) ;
glVertex3i(x+size, y+size, z) ;
glVertex3i(x, y+size, z) ;
glVertex3i(x, y, z) ;
glEnd() ;

[Happy]

ToTo13, je ne vois pas en quoi ça réponds à son message?

Sinon il faudrais voir du coté de glInterleavedArrays();

[MatRem]

En fait un Vertex Array, peut être vu comme un tableau d'informations de sommets dans lequel tu peux mettre :

- les coordonnées du sommet;
- les coordonnées de la normale au sommet;
- et bien d'autre choses (cf la reference tout en bas see also, les glXXXPointer).

Spécification des emplacements de données
Le Vertex Array (qui est en fait un tableau de pointeurs vers ces informations) se remplit à l'aide des fonctions glXXXPointer.
Tu dois à chaque fois fournir une zone mémoire qui contient les informations adéquate pour tout tes sommets.

Il est aussi possible de spécifier tous ces pointeurs en une seule fois avec glInterleavedArrays (si tes données sont entrelacées).

(des)Activation de l'utilisation de ces emplacements
Pour qu'OpenGL aille chercher ces informations au moment du rendu, il faut lui dire avec la fonction glEnableClientState(); et les constantes qui vont bien (GL_VERTEX_ARRAY, GL_NORMAL_ARRAY, ...).
Après le rendu de l'objet, il faut penser à desactiver ces états (avec glDisableClientState()).

Rendu
Ensuite pour rendre tes polygones (TRIANGLE, QUAD ou autres) tu as au moins deux moyens :
- rendu en prenant les sommets dans l'ordre avec glDrawArrays();
- rendu en prenant les sommets dans un ordre défini par un tableau d'indice avec glDrawElements();


Voilà comment ça se passe.
Tu comprends donc que ta structure de donnée avec un tableau d'indice de normal n'est pas adaptée à un Vertex Array.

En effet, puisque tu as 8 sommets, il te faut :
- 8 coordonnées de sommets;
- 8 coordonnées de normales.
stockées en mémoire (entrelacée ou pas)
- 1 tableau de N indices de 0 à 7 qui définit tes polygones.

ps: un Vertex Buffer Object est un moyen de stocker les données en mémoire vidéo pour que le Vertex Array travaille directement sur la carte vidéo.

[Elendhil]

Merci pour vos réponses. Effectivement ToTo13 n'avait pas bien saisi mon problème.

Je sais afficher un cube , ou d'autres formes , ce n'est pas vraiment mon problème.
J'utilise aussi les tableaux de vertex , je sais les activer et les appeller pour afficher le rendu.

Ma structure n'est pas de moi . En faite j'essai de restituer la géométrie de l'exemple du fichier collada(un simple cube). Tous les fichiers collada sont basés sur le même principe.

C'est a dire ca :

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
 
<geometry id="box" name="box">
      <mesh>
	<source id="box-Pos">
		<float_array id="box-Pos-array" count="24">
			-0.5 0.5 0.5
			0.5 0.5 0.5
			-0.5 -0.5 0.5
			0.5 -0.5 0.5
			-0.5 0.5 -0.5
			0.5 0.5 -0.5
			-0.5 -0.5 -0.5
			0.5 -0.5 -0.5
		</float_array>
		       <technique_common>
		           <accessor source="#box-Pos-array" count="8" stride="3">
				<param name="X" type="float" />
				<param name="Y" type="float" />
				<param name="Z" type="float" />
			</accessor>
			</technique_common>
		</source>
		<source id="box-0-Normal">
		<float_array id="box-0-Normal-array" count="18">
			1.0 0.0 0.0
			-1.0 0.0 0.0
			0.0 1.0 0.0
			0.0 -1.0 0.0
			0.0 0.0 1.0
			0.0 0.0 -1.0
		</float_array>
		<technique_common>
	<accessor source="#box-0-Normal-array" count="6" stride="3">
				<param name="X" type="float"/>
				<param name="Y" type="float"/>
				<param name="Z" type="float"/>
	</accessor>
	</technique_common>
	</source>
	<vertices id="box-Vtx">
		<input semantic="POSITION" source="#box-Pos"/>
	</vertices>
		<polygons count="6" material="WHITE">
	<input semantic="VERTEX" source="#box-Vtx" offset="0"/>
	<input semantic="NORMAL" source="#box-0-Normal" offset="1"/>
	<p>0 4 2 4 3 4 1 4</p>
	<p>0 2 1 2 5 2 4 2</p>
	<p>6 3 7 3 3 3 2 3</p>
	<p>0 1 4 1 6 1 2 1</p>
	<p>3 0 7 0 5 0 1 0</p>
	<p>5 5 7 5 6 5 4 5</p>
	</polygons>
</mesh>

Mais mon soucis justement c'est que j'ai pas la structure que tu proposes :

En effet, puisque tu as 8 sommets, il te faut :
- 8 coordonnées de sommets;
- 8 coordonnées de normales.
stockées en mémoire (entrelacée ou pas)
- 1 tableau de N indices de 0 à 7 qui définit tes polygones.

Même constat pour un objet plus complexe par exemple:

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
 
<float_array id="F40tire-mesh-positions-array" count="2940">
....
 
<accessor source="#F40tire-mesh-positions-array" count="980" stride="3">
              <param name="X" type="float"/>
              <param name="Y" type="float"/>
              <param name="Z" type="float"/>
...
 
<float_array id="F40tire-mesh-normals-array" count="5040">
...
<accessor source="#F40tire-mesh-normals-array" count="1680" stride="3">
              <param name="X" type="float"/>
              <param name="Y" type="float"/>
              <param name="Z" type="float"/>
 
<float_array id="F40tire-mesh-map-channel1-array" count="5769">
...
<accessor source="#F40tire-mesh-map-channel1-array" count="1923" stride="3">
              <param name="S" type="float"/>
              <param name="T" type="float"/>
              <param name="P" type="float"/>
...
 
<vertices id="F40tire-mesh-vertices">
   <input semantic="POSITION" source="#F40tire-mesh-positions"/>
</vertices>
    <triangles material="F40tire" count="1680">
    <input semantic="VERTEX" source="#F40tire-mesh-vertices" offset="0"/>
    <input semantic="NORMAL" source="#F40tire-mesh-normals" offset="1"/>
    <input semantic="TEXCOORD" source="#F40tire-mesh-map-channel1" offset="2" set="1"/>
<p>0 0 2 1 1 3 8 2 14 0 0 2 8 2 14 7 .....

Et la on vois que le problème est le même :
Un tableau de 980 vertex
un tableau de 1680 normals
un tableau de 1923 coordonnées de textures
un tableau d'indices entrelacés (vertex,normal,coord) de 0 à 1679

Et la c'est toute suite plus difficile pour arranger la géometrie afin de l'afficher correctement.

Si la specification de Collada la choisie de cette manière c'est surement pour une bonne raison . (Group Khronos ceux qui gère aussi openGL)

Pour éviter la redondance des infos afin que les fichiers soit moins gros.

Si les données doivent etre restituées grâce à un tableau d'indices entrelacés, je me dit qu'ils ont surement prévus un mécanisme dans openGL pour traiter les données de cette manière sans que l'on soit obligé de les modifier.

Mais le problème c'est qu'aucun des tableaux n'a la même taille.

[MatRem]

Effectivement c'est sans doute pour la taille du fichier que Khronos à du choisir cette spécification.

Mais a priori le seul moyen de passer par un vertex array, est d'effectuer une "décompression" (au chargement) pour ne garder des indices que pour les sommets, et plus pour les informations des sommets.

Si tu utilises GLSL, peut être que tu pourrais envoyer les indices directement dans le vertex array, et envoyer les tableaux d'informations correspondantes dans des uniforms à ton vertex shader. Cependant je ne crois pas que ce soit terrible niveau performances.


Cependant il y a un truc que je ne comprends pas: comment sur un objet qui possède 980 sommets différents, il peut avoir 1680 normales différentes?
Normalement il ne peut y avoir qu'une normale par sommets...

A moins que ce fichier collada définisse plusieurs objets différents qui partagent certains sommets, mais pas forcément les même normales à ces sommets?

[kremvax]

Regarde un peu ce lien, ça pourrait t'intéresser : http://www.blitzbasic.com/Community/...hp?topic=47065 (c'est pas en C++ mais les fonctions gl seront les mêmes)