Discussion :

[Bakura]

Voilà je rencontre un petit problème en utilisant les VBO. Actuellement je dessine avec glBegin et ya pas de problème. Toutefois en utilisant les VBO les formes sont mal dessinés. Voici ce que je fais à l'initialisation :

glGenBuffers (1, &vbo);
glBindBuffer (GL_ARRAY_BUFFER, vbo);
glBufferData (GL_ARRAY_BUFFER, sizeof (float) * m_iNumVertices * 3, NULL, GL_STATIC_DRAW);

ET dans la fonction de dessin :

glBindBuffer (GL_ARRAY_BUFFER, vbo);
glEnableClientState (GL_VERTEX_ARRAY);
glVertexPointer (3, GL_FLOAT, 0, tabVertices);

glDrawElements (GL_TRIANGLES, m_iNumVertices, GL_UNSIGNED_BYTE, tabIndices);

glDisableClientState (GL_VERTEX_ARRAY);

Ca m'a l'air bon, mais le problème se situe je pense aux niveaux des tableaux. En fait j'utilise des vector de structures pour stocker mes indices et mes vertices. Tout d'abord ya t'il une solution qui m'éviterait de recréer en plus de mes vector des tableaux pour les vertices, les indices, les normales,...

Enfin bref, pour l'instant je fais ç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
17
18
 
tabVertices = new float [m_iNumVertices * m_iNumPoints];
 
   for (int i = 0 ; i < m_iNumVertices ; ++i)
   {
      tabVertices [3 * i] = m_vVertices [i].x;
      tabVertices [3 * i + 1] = m_vVertices [i].y;
      tabVertices [3 * i + 2] = m_vVertices [i].z;
   }
 
   tabIndices = new GLubyte [m_iNumFaces * m_iNumPoints];
 
   for (int i = 0 ; i < m_iNumFaces ; ++i)
   {
      tabIndices [3 * i] = m_vFaces [i].indexVertices [0];
      tabIndices [3 * i + 1] = m_vFaces [i].indexVertices [1];
      tabIndices [3 * i + 2] = m_vFaces [i].indexVertices [2];
   }

Mais ça ne marche pas ... Une fois pour tester avec un cube tout simple la seule solution c'était de les faire à la main, en mettant les virgules et tout,...

EDIT : je précise que j'ai vérifié les valeurs, ce sont bien les bonnes, à part qu'il n'y a pas de virgules entre elles bien sur.

[Bakura]

J'ai toujours le problème... J'ai tout essayé... Le problème c'est bien que les normales ne partagent pas le même indicage que les vertices. Il y a bien un autre topic qui parlait de ça, mais malheureusement il ne met pas de code pour illustrer comment il a réussi :/...

Donc ça ne marche pas.

[Bakura]

Rhaaa ça m'énèrve !!!

Voilà ce que j'ai essayé dernièrement. J'ai donc mon fichier ASE comme ça :

*MESH_VERTEX_LIST {
*MESH_VERTEX 0 -10.0 -10.0 -10.0
*MESH_VERTEX 1 10.0 -10.0 -10.0
*MESH_VERTEX 2 -10.0 10.0 -10.0
*MESH_VERTEX 3 10.0 10.0 -10.0
*MESH_VERTEX 4 -10.0 -10.0 10.0
*MESH_VERTEX 5 10.0 -10.0 10.0
*MESH_VERTEX 6 -10.0 10.0 10.0
*MESH_VERTEX 7 10.0 10.0 10.0
}
*MESH_FACE_LIST {
*MESH_FACE 0: A: 0 B: 2 C: 3 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2

*MESH_MTLID 1
*MESH_FACE 1: A: 3 B: 1 C: 0 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 2

*MESH_MTLID 1
*MESH_FACE 2: A: 4 B: 5 C: 7 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 3

*MESH_MTLID 0
*MESH_FACE 3: A: 7 B: 6 C: 4 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 3

*MESH_MTLID 0
*MESH_FACE 4: A: 0 B: 1 C: 5 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 4

*MESH_MTLID 4
*MESH_FACE 5: A: 5 B: 4 C: 0 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 4

*MESH_MTLID 4
*MESH_FACE 6: A: 1 B: 3 C: 7 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 5

*MESH_MTLID 3
*MESH_FACE 7: A: 7 B: 5 C: 1 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 5

*MESH_MTLID 3
*MESH_FACE 8: A: 3 B: 2 C: 6 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 6

*MESH_MTLID 5
*MESH_FACE 9: A: 6 B: 7 C: 3 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 6

*MESH_MTLID 5
*MESH_FACE 10: A: 2 B: 0 C: 4 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 7

*MESH_MTLID 2
*MESH_FACE 11: A: 4 B: 6 C: 2 AB: 1 BC: 1 CA: 0 *MESH_SMOOTHING 7

*MESH_MTLID 2
}
*MESH_NORMALS {
*MESH_FACENORMAL 0 0.0 0.0 -1.0
*MESH_VERTEXNORMAL 0 0.0 0.0 -1.0
*MESH_VERTEXNORMAL 2 0.0 0.0 -1.0
*MESH_VERTEXNORMAL 3 0.0 0.0 -1.0
*MESH_FACENORMAL 1 0.0 0.0 -1.0
*MESH_VERTEXNORMAL 3 0.0 0.0 -1.0
*MESH_VERTEXNORMAL 1 0.0 0.0 -1.0
*MESH_VERTEXNORMAL 0 0.0 0.0 -1.0
*MESH_FACENORMAL 2 0.0 0.0 1.0
*MESH_VERTEXNORMAL 4 0.0 0.0 1.0
*MESH_VERTEXNORMAL 5 0.0 0.0 1.0
*MESH_VERTEXNORMAL 7 0.0 0.0 1.0
*MESH_FACENORMAL 3 0.0 0.0 1.0
*MESH_VERTEXNORMAL 7 0.0 0.0 1.0
*MESH_VERTEXNORMAL 6 0.0 0.0 1.0
*MESH_VERTEXNORMAL 4 0.0 0.0 1.0
*MESH_FACENORMAL 4 0.0 -1.0 0.0
*MESH_VERTEXNORMAL 0 0.0 -1.0 0.0
*MESH_VERTEXNORMAL 1 0.0 -1.0 0.0
*MESH_VERTEXNORMAL 5 0.0 -1.0 0.0
*MESH_FACENORMAL 5 0.0 -1.0 0.0
*MESH_VERTEXNORMAL 5 0.0 -1.0 0.0
*MESH_VERTEXNORMAL 4 0.0 -1.0 0.0
*MESH_VERTEXNORMAL 0 0.0 -1.0 0.0
*MESH_FACENORMAL 6 1.0 0.0 0.0
*MESH_VERTEXNORMAL 1 1.0 0.0 0.0
*MESH_VERTEXNORMAL 3 1.0 0.0 0.0
*MESH_VERTEXNORMAL 7 1.0 0.0 0.0
*MESH_FACENORMAL 7 1.0 0.0 0.0
*MESH_VERTEXNORMAL 7 1.0 0.0 0.0
*MESH_VERTEXNORMAL 5 1.0 0.0 0.0
*MESH_VERTEXNORMAL 1 1.0 0.0 0.0
*MESH_FACENORMAL 8 0.0 1.0 0.0
*MESH_VERTEXNORMAL 3 0.0 1.0 0.0
*MESH_VERTEXNORMAL 2 0.0 1.0 0.0
*MESH_VERTEXNORMAL 6 0.0 1.0 0.0
*MESH_FACENORMAL 9 0.0 1.0 0.0
*MESH_VERTEXNORMAL 6 0.0 1.0 0.0
*MESH_VERTEXNORMAL 7 0.0 1.0 0.0
*MESH_VERTEXNORMAL 3 0.0 1.0 0.0
*MESH_FACENORMAL 10 -1.0 0.0 0.0
*MESH_VERTEXNORMAL 2 -1.0 0.0 0.0
*MESH_VERTEXNORMAL 0 -1.0 0.0 0.0
*MESH_VERTEXNORMAL 4 -1.0 0.0 0.0
*MESH_FACENORMAL 11 -1.0 0.0 0.0
*MESH_VERTEXNORMAL 4 -1.0 0.0 0.0
*MESH_VERTEXNORMAL 6 -1.0 0.0 0.0
*MESH_VERTEXNORMAL 2 -1.0 0.0 0.0
}

J'ai déjà tout récupéré et stocké dans des vectors. Avec glbeign/glend pas de problème, totu s'affiche bien.

Pour utiliser les vertex arrays, je les stocke dans des tableaux :

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
tabVertices = new float [m_iNumVertices * m_iNumPoints];
   tabNormales = new float [m_iNumFaces * m_iNumPoints * 3];
 
   for (int i = 0 ; i < m_iNumVertices ; ++i)
   {
      tabVertices [3 * i] = m_vVertices [i].x;
      tabVertices [3 * i + 1] = m_vVertices [i].y;
      tabVertices [3 * i + 2] = m_vVertices [i].z;
 
      cout << tabVertices [3 * i] << ' ' << tabVertices [3 * i + 1] << ' ' << tabVertices [3 * i + 2] << endl;
   }
 
   for (int i = 0 ; i < m_iNumFaces ; ++i)
   {
      tabNormales [9 * i] = m_vNormales [m_vFaces [i].indexVertices [0]].x;
      tabNormales [9 * i + 1] = m_vNormales [m_vFaces [i].indexVertices [0]].y;
      tabNormales [9 * i + 2] = m_vNormales [m_vFaces [i].indexVertices [0]].z;
 
      tabNormales [9 * i + 3] = m_vNormales [m_vFaces [i].indexVertices [1]].x;
      tabNormales [9 * i + 4] = m_vNormales [m_vFaces [i].indexVertices [1]].y;
      tabNormales [9 * i + 5] = m_vNormales [m_vFaces [i].indexVertices [1]].z;
 
      tabNormales [9 * i + 6] = m_vNormales [m_vFaces [i].indexVertices [2]].x;
      tabNormales [9 * i + 7] = m_vNormales [m_vFaces [i].indexVertices [2]].y;
      tabNormales [9 * i + 8] = m_vNormales [m_vFaces [i].indexVertices [2]].z;
   }
 
   tabIndices = new GLint [m_iNumFaces * m_iNumPoints];
 
   for (int i = 0 ; i < m_iNumFaces ; ++i)
   {
      tabIndices [3 * i] = m_vFaces [i].indexVertices [0];
      tabIndices [3 * i + 1] = m_vFaces [i].indexVertices [1];
      tabIndices [3 * i + 2] = m_vFaces [i].indexVertices [2];
 
      cout << (int)tabIndices [3 * i] << ' ' << (int)tabIndices [3 * i + 1] << ' ' << (int)tabIndices [3 * i + 2] << endl << endl;
   }

Puis :

Code :

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

1
2
3
4
5
6
7
8
9
10
glEnableClientState (GL_VERTEX_ARRAY);
   glEnableClientState (GL_NORMAL_ARRAY);
 
   glNormalPointer (GL_FLOAT, 0, tabNormales);
   glVertexPointer (3, GL_FLOAT, 0, tabVertices);
 
   glDrawElements (GL_TRIANGLES, 36, GL_UNSIGNED_INT, tabIndices);
 
   glDisableClientState (GL_NORMAL_ARRAY);
   glDisableClientState (GL_VERTEX_ARRAY);

Mais les normales s'affichent mal grrrr !!!

EDIT : pff, avec un mesh plus complexe ça me l'affiche même pas bien, fait chier,...

[Bakura]

En fait, j'aimerais une confirmation de comment marche les vertex arrays...

Code :

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

1
2
3
4
5
6
7
8
9
10
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_NORMAL_ARRAY);
 
glNormalPointer (GL_FLOAT, 0, tabNormales);
glVertexPointer (3, GL_FLOAT, 0, tabVertices);
 
glDrawElements (GL_TRIANGLES, 36, GL_UNSIGNED_INT, tabIndices);
 
glDisableClientState (GL_NORMAL_ARRAY);
glDisableClientState (GL_VERTEX_ARRAY);

Quand je tape ça, il est censé plus ou moins de faire un équivalent à :

glBegin (GL_TRIANGLES);
glNormal3f (3 premières valeurs du tableau tabNormales);
glVertex3f (3 premières valeurs du tableau tabVertices);
glNormal3f (3 suivantes de tabNormales);
glVertex3f (3 suivantes de tabVertices);
glNormal3f (encore 3 suivantes de tabNormales);
glVertex3f (encore 3 suivantes de tabVertices);
glEnd ();

Et ceci 36 / 3 fois,...

Si c'est le cas, je ne pige pas pourquoi ça marche, parceque on se retrouve avec :

glBegin (GL_TRIANGLES);
glNormal3f (m_vNormales [m_vFaces [i].indexVertices [0]].x, m_vNormales [m_vFaces [i].indexVertices [0]].y, m_vNormales [m_vFaces [i].indexVertices [0]].z;
glVertex3f (mes tableaux de vertices,...)
glEnd ();

Et ceci en respectant à chaque fois l'ordre donné dans indices, ici la normale 0 avec la vertice 0, la normale 2 avec la vertice 2, la normale 3 avec la vertice 3...

Je pige pas pourquoi ça marche passss, aidez moi je pète un cable là :hungry:

EDIT : ah oui, contrairement au titre, pour l'instant je préfère faire marcher les vertex array et après je verrai pour les VBO ^^.

[fearyourself]

J'ai l'impression que tu récupéres mal les normales. Essaies de lire le fichier ASE et après avec ta structure de données de le recréer en sortie.

Tu verras bien si tu arrives à remettre tout en place ou si tu as perdu ou mal géré certains point,

Jc

[Bakura]

Ben non puisque quand je fais en mode immédiat ça marche bien,... .

EDIT : bon voilà j'ai corrigé un petit bug, donc maintenant que les vertices sans les normales, ça marche bien pour toutes les formes, reste les normales, mais ça j'en sais rien ...

[Bakura]

Bon. J'ai réussi en utilisant glDrawArrays. Donc sans utiliser d'indices, puisque j'ai compris que pour utiliser glDrawElements avec les normales et les coords de texture, il fallait obligatoirement dupliquer toutes les 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
tabVertices = new float [m_iNumFaces * m_iNumPoints * 3];
   tabNormales = new float [m_iNumFaces * m_iNumPoints * 3];
 
   for (int i = 0 ; i < m_iNumFaces ; ++i)
   {
      tabVertices [9 * i] = m_vVertices [m_vFaces [i].indexVertices [0]].x;
      tabVertices [9 * i + 1] = m_vVertices [m_vFaces [i].indexVertices [0]].y;
      tabVertices [9 * i + 2] = m_vVertices [m_vFaces [i].indexVertices [0]].z;
 
      tabVertices [9 * i + 3] = m_vVertices [m_vFaces [i].indexVertices [1]].x;
      tabVertices [9 * i + 4] = m_vVertices [m_vFaces [i].indexVertices [1]].y;
      tabVertices [9 * i + 5] = m_vVertices [m_vFaces [i].indexVertices [1]].z;
 
      tabVertices [9 * i + 6] = m_vVertices [m_vFaces [i].indexVertices [2]].x;
      tabVertices [9 * i + 7] = m_vVertices [m_vFaces [i].indexVertices [2]].y;
      tabVertices [9 * i + 8] = m_vVertices [m_vFaces [i].indexVertices [2]].z;
 
      cout << tabVertices [9 * i] << ' ' << tabVertices [9 * i + 1] << ' ' << tabVertices [9 * i + 2] << endl << tabVertices [9 * i + 3] << ' ' << tabVertices [9 * i + 4] << ' ' << tabVertices [9 * i + 5] << endl << tabVertices [9 * i + 6] << ' ' << tabVertices [9 * i + 7] << ' ' << tabVertices [9 * i + 8] << endl << endl;
   }
 
   for (int i = 0 ; i < m_iNumFaces ; ++i)
   {
      tabNormales [9 * i] = m_vNormales [3 * i + 0].x;
      tabNormales [9 * i + 1] = m_vNormales [3 * i + 0].y;
      tabNormales [9 * i + 2] = m_vNormales [3 * i + 0].z;
 
      tabNormales [9 * i + 3] = m_vNormales [3 * i + 1].x;
      tabNormales [9 * i + 4] = m_vNormales [3 * i + 1].y;
      tabNormales [9 * i + 5] = m_vNormales [3 * i + 1].z;
 
      tabNormales [9 * i + 6] = m_vNormales [3 * i + 1].x;
      tabNormales [9 * i + 7] = m_vNormales [3 * i + 1].y;
      tabNormales [9 * i + 8] = m_vNormales [3 * i + 1].z;
 
      //cout << tabNormales [9 * i] << ' ' << tabNormales [9 * i + 1] << ' ' << tabNormales [9 * i + 2] << endl << tabNormales [9 * i + 3] << ' ' << tabNormales [9 * i + 4] << ' ' << tabNormales [9 * i + 5] << endl << tabNormales [9 * i + 6] << ' ' << tabNormales [9 * i + 7] << ' ' << tabNormales [9 * i + 8] << endl << endl;
   }

Et le dessin :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
glEnableClientState (GL_VERTEX_ARRAY);
   glEnableClientState (GL_NORMAL_ARRAY);
 
   glNormalPointer (GL_FLOAT, 0, tabNormales);
   glVertexPointer (3, GL_FLOAT, 0, tabVertices);
 
   //glDrawElements (GL_TRIANGLES, m_iNumFaces * 3, GL_UNSIGNED_INT, tabIndices);
   glDrawArrays (GL_TRIANGLES, 0, m_iNumFaces * 3);
 
   glDisableClientState (GL_NORMAL_ARRAY);
   glDisableClientState (GL_VERTEX_ARRAY);

Bref. En faisant ça, pas de problème, ça marche bien. Toutefois je me pose une question. glDrawElements peut-être intéressant justement à cause des vertices dupliqués. Par exemple sur un cube on a une vertice partagé par trois sommets...

Toutefois étant donné qu'on doit les dupliquer pour pouvoir utiliser correctement les normales, quel est l'intêret ??!!... Par rapport à un glDrawArrays, glDrawElements sera même moins performant (puisqu'il aura en plus un tableau d'indices, au lieu de tout faire dans l'ordre).

Donc ce que je me demande : dnas le cas ou l'on doit utiliser des normales et des textures de coordonnés, glDrawElements est moins performant que glDrawArrays ?

[Bakura]

voiiaaaallaaa mes vbo marchent parfaitement, bon sans indice mais c'est pas grave ! j'ai déjà de bonnes perfs... Sur un modèle de 60 000 vertices, je tourne avec l'éclairage (pas encore mis les textures) à 47 fps avec les vertex arrays et 170 fps avec les vbo sur un 3200+ et radéon 9800 pro ^^

[fearyourself]

voiiaaaallaaa mes vbo marchent parfaitement, bon sans indice mais c'est pas grave ! j'ai déjà de bonnes perfs... Sur un modèle de 60 000 vertices, je tourne avec l'éclairage (pas encore mis les textures) à 47 fps avec les vertex arrays et 170 fps avec les vbo sur un 3200+ et radéon 9800 pro ^^

Ah ben quand même !

Bon je n'ai jamais fait de vbo donc je ne vais pas pouvoir t'aider plus mais c'est déjà de bonnes performances...

Bon boulot mister Bakura
Jc

[Bakura]

Ah ben quand même !

Bon je n'ai jamais fait de vbo donc je ne vais pas pouvoir t'aider plus mais c'est déjà de bonnes performances...

Bon boulot mister Bakura
Jc

Merci ^^... J'espère pouvoir commencer la petite idée de jeu que j'ai en tête dans un ou deux mois

[Bakura]

Voilà j'ai encore un nouveau problème avec les VBO...

Avec les vertex arrays, voilà ce que je fais pour dessiner :

Code :

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

1
2
3
4
5
6
7
8
9
10
11
12
13
glEnableClientState (GL_VERTEX_ARRAY);
glEnableClientState (GL_TEXTURE_COORD_ARRAY);
glEnableClientState (GL_NORMAL_ARRAY);
 
glVertexPointer (3, GL_FLOAT, 0, tabVertices);
glTexCoordPointer (2, GL_FLOAT, 0, tabTextures);
glNormalPointer (GL_FLOAT, 0, &m_vNormales [0].x);
 
glDrawArrays (GL_TRIANGLES, 0, m_iNumFaces * 3);
 
glDisableClientState (GL_NORMAL_ARRAY);
glDisableClientState (GL_TEXTURE_COORD_ARRAY);
glDisableClientState (GL_VERTEX_ARRAY);

Pas de problème, voici le résultat :



Pas de problème d'affichage, mais perfs assez mauvaises...

Toutefois dès que je veux le transcrire en VBO, voici ce que je fais :

à l'initialisation de l'objet :

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
int taille = sizeof (float) * (m_iNumFaces * 9);
   int taille2 = sizeof (float) * m_iNumFaces * 6;
 
   glEnableClientState (GL_VERTEX_ARRAY);
   glEnableClientState (GL_TEXTURE_COORD_ARRAY);
   glEnableClientState (GL_NORMAL_ARRAY);
 
   glGenBuffers (1, &m_uiVBO);
   glBindBuffer (GL_ARRAY_BUFFER, m_uiVBO);
   glBufferData (GL_ARRAY_BUFFER, taille * 2 + taille2, NULL, GL_STATIC_DRAW);
   glBufferSubData (GL_ARRAY_BUFFER, 0, taille, tabVertices);
   glBufferSubData (GL_ARRAY_BUFFER, taille, taille2, tabTextures);
   glBufferSubData (GL_ARRAY_BUFFER, taille + taille2, taille, &m_vNormales [0].x);
 
   glDisableClientState (GL_NORMAL_ARRAY);
   glDisableClientState (GL_TEXTURE_COORD_ARRAY);
   glDisableClientState (GL_VERTEX_ARRAY);

Puis pour dessiner :

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
 
glEnableClientState (GL_VERTEX_ARRAY);
   glEnableClientState (GL_TEXTURE_COORD_ARRAY);
   glEnableClientState (GL_NORMAL_ARRAY);
 
   glBindBuffer (GL_ARRAY_BUFFER, m_uiVBO);
 
   glVertexPointer (3, GL_FLOAT, 0, 0);
   glTexCoordPointer (2, GL_FLOAT, 0, (void *) taille);
   glNormalPointer (GL_FLOAT, 0, (void *) (taille + taille2));
 
   glDrawArrays (GL_TRIANGLES, 0, m_iNumFaces * 3);
 
   glBindBuffer (GL_ARRAY_BUFFER, 0); // On quitte le mode VBO
 
   glDisableClientState (GL_NORMAL_ARRAY);
   glDisableClientState (GL_TEXTURE_COORD_ARRAY);
   glDisableClientState (GL_VERTEX_ARRAY);

La les perfs s'envolent mais j'ai des vertex mal placées :/



La seule solution que j'ai trouvée c'est de remettre en mémoire toutes les éléments à chaque boucle, comme ceci (rien ne change dans la fonction d'initialisation) :

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
glEnableClientState (GL_VERTEX_ARRAY);
   glEnableClientState (GL_TEXTURE_COORD_ARRAY);
   glEnableClientState (GL_NORMAL_ARRAY);

   glBindBuffer (GL_ARRAY_BUFFER, m_uiVBO);
   glBufferData (GL_ARRAY_BUFFER, taille * 2 + taille2, NULL, GL_STATIC_DRAW);
   glBufferSubData (GL_ARRAY_BUFFER, 0, taille, tabVertices);
   glBufferSubData (GL_ARRAY_BUFFER, taille, taille2, tabTextures);
   glBufferSubData (GL_ARRAY_BUFFER, taille + taille2, taille, &m_vNormales [0].x);

   glVertexPointer (3, GL_FLOAT, 0, 0);
   glTexCoordPointer (2, GL_FLOAT, 0, (void *) taille);
   glNormalPointer (GL_FLOAT, 0, (void *) (taille + taille2));

   glDrawArrays (GL_TRIANGLES, 0, m_iNumFaces * 3);

   glBindBuffer (GL_ARRAY_BUFFER, 0); // On quitte le mode VBO

   glDisableClientState (GL_NORMAL_ARRAY);
   glDisableClientState (GL_TEXTURE_COORD_ARRAY);
   glDisableClientState (GL_VERTEX_ARRAY);

Et la je n'ai plus d'artefacts, mais je perds en performance :/



Comment faire pour pouvoir avoir les perfs de la deuxième méthode ?

Le modèle fait un peu près 60 000 triangles,... (c'est bon niveau performance sinon ?)

[Bakura]

Voilà j'ai résolu mon problème, maintenant mon loader ASE est parfaitement fonctionnel. En fait, le problème venait du fait que dans la Ferrari, seules certains meshs avaient des textures, or j'activais le VBO pour les textures pour TOUS les meshs, même ceux qui n'avaient pas de texture.

Maintenant c'est corrigé et ça marche niquel, le seul problème c'est que j'ai pas les 240 fps mais exactement le même nombre qu'avec les vertex arrays , soit 75 fps pour un model de 51 000 faces.

[Bakura]

Ah non en fait, c'est bon, c'est parceque comme un boulet j'avais activé l'anti-crénalage x4 et le ffsa x16 ^^.... Par contre je pige pas, j'ai fait un test, avec AAx4 + AFx16 et en 1024*768 j'obtenais les mêmes perfs qu'en 800*600 !

J'ai donc bien mes 250 fps, sans bug, super ^^

[Laurent Gomila]

N'oublie pas de tapoter sur