Vertex array performance

Version imprimable

Salut, en ce moment je suis entrain de faire un petit moteur 3D basé sur opengl.
Le moteur marche bien, mais j'ai un problème de performance avec les vertex array. J'ai fait plusieurs test et les vertex array s'affiche beaucoup plus vite mais de facon hasardeuse (dés fois sa sera 90fps et d'autre 15fps pour le même objet ).
J'ai fait un test pour mesurer les performmances (en FPS) entre les vertex array et la facon native d'opengl ( glBegin(...);glVertex(...);glEnd(); )
disponible a cette adresse la : http://smartties.netne.net/fgh.rar .
(dans cette démo, l'application charge un .obj de 1mo, et qui a 15240 faces) Pouvez vous me dire si les vertex array s'affiche plus vite que les glVertex() ?

( laisser appuyer la touche " p " pour afficher l'objet en mode vertex array
et " m " pour afficher l'objet en appelant les fonction glVertex();

les Fraps par seconde son affiché dans le titre de la fenetre)

Sachant que pour dessiner mon objet avec les vertex array je fais :
Code:

1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 void ...::draw_array() { glEnableClientState(GL_VERTEX_ARRAY); glEnableClientState(GL_NORMAL_ARRAY); for(indice_face = 0; indice_face <= nb_face; indice_face++) { glVertexPointer(3, GL_FLOAT, 0, face[indice_face]->get_data_vertex()); glNormalPointer( GL_FLOAT, 0, face[indice_face]->get_data_normal()); glDrawArrays(GL_POLYGON, 0, face[indice_face]->get_nb_vertex() ); } glDisableClientState(GL_NORMAL_ARRAY); glDisableClientState(GL_VERTEX_ARRAY); }
Merci

13/04/2011, 09h09
dragonjoker59

As-tu aussi pensé aux VBO ? Parce que ça devrait être plus rapide et ça t'éviterait d'utiliser des trucs obsolètes, surtout qu'au niveau de ton code il n'y aurait pas de trop grosses modifications à apporter, sachant que tu es déjà aux Vertex Arrays.
Pour ton exe, je suis à 60 FPS en Vertex Array ou en Natif, donc ...
13/04/2011, 10h00
smartties

Oui je vais implementer les vbo , mais c'était juste pour tester l'efficacité des vertex array.
Sinon je voulais savoir si les VBO était compatible avec toutes les carte graphique ?
13/04/2011, 10h08
dragonjoker59

Euh, pas toutes, mais c'est supporté au moins depuis les Geforce FX (avant je ne sais pas, mais sur ma FX5600 c'était déjà supporté)
13/04/2011, 10h08
Invité

Non les VBO ne marchent pas bien sur toutes les Intel (aucune idée pour les vertex arrays) de plus tu as un bug dans ton code, si pour chaque face tu donnes un glVertexPointer et glNormalPointer ça ne risque pas d'améliorer les perfs.
13/04/2011, 10h25
oxyde356

L'intérêt des vertex array c'est justement d'envoyer un tableau directement à la carte graphique et pas chaque sommet manuellement, toi tu as une utilisation des vertex array façon glBegin en envoyant chaque face. Bref aucun intérêt de l'utiliser de cette façon. Normalement tu set ton VertexPointer et NormalPointer une seule fois, tu dis combien il y a de points et le type de primitives et hop sa dessine tout d'un coup.
Dans tous les cas je te conseil d'utiliser les VBO (à pars si tu veux modifier les points de ta géometrie en temps réel), si la carte graphique le permet et possède la mémoire nécessaire alors envoie tes données dans la ram graphique et utilise les VBO, s'ils ne sont pas supportés ou qu'il n'y a plus assez de ram graphiques alors stocke tes données dans un vertex array, après tout dépend de tes contraintes, performance, ou bien que ton moteur soit utilisable sur n'importe quelle machine même ancienne etc.
13/04/2011, 10h25
smartties

face[indice_face]->get_data_normal() renvoi un pointeur sur un tableau de normales de dimmension tab[nb_sommet * 3], ce qui me fait une normal par sommet.Ce n'est pas bon?
D'ou vien le bug ?
13/04/2011, 10h27
smartties

Ah d'accord merci! je n'avais pas trop compris,comment utiliser les vertex array.
Mais en utilisant 1 seul fois glVertexPointeur(); avec un tableau contenant toutes mes face, alors toutes mes faces seront relié ?
13/04/2011, 10h28
oxyde356

Qu'appelle tu "face" dans ton programme ... ?
13/04/2011, 10h32
smartties

Dans mon programme une face contient un minimum de 3 points qui appartiennent au même plan.
13/04/2011, 11h01
math_lab

Citation:

Envoyé par oxyde356

Dans tous les cas je te conseil d'utiliser les VBO (à pars si tu veux modifier les points de ta géometrie en temps réel)

Même si on veut modifier la géométrie en temps réel, il vaut mieux passer en VBO et spécifier que le mesh sera dynamique. Ça permet d'unifier le code et de pas avoir 36 classes pour gérer différent types de géométrie. De plus, si la géométrie ne change pas a chaque frame, mais juste régulièrement, les perfs seront améliorées par rapport aux vertex arrays (le mesh sera stocké dans une partie spécifique de la RAM réservée pour le driver - l'aperture memory - qui est un poil plus rapide d’accès).
13/04/2011, 11h52
oxyde356

Il ne me semble pas qu'il y en est depuis que les cartes sont en PCI et plus en AGP :-o
Tu as une source ? Bon après j'imagine que ça se débrouille avec la RAM quand même mais je ne trouve pas d'informations claires à ce sujet, si tu en as je suis preneur !
13/04/2011, 12h04
math_lab

Un de mes profs, mais bon, peut être qu'il était pas tout a fait a jour. :P
Mais un petit coup de Google, et je tombe sur ca, donc on dirait que ça existe toujours.
13/04/2011, 12h15
oxyde356

ça parle que d'AGP :s il n'y en a plus depuis un moment sur les cartes mères, de plus l'article ne m'a pas l'air daté :D En plus je crois que c'est vraiment variable selon les drivers donc pas fiable :aie:
Bref dans le cas d'une géometrie vraiment dynamique je privilégierais les Vertex Arrays personnellement ^^
13/04/2011, 12h29
math_lab

En fait, je crois que je me suis un peu fait avoir par l'image de la GeForce 8800 en dessous, je pensais que ça permettrai de dater, mais c'est peut être juste une pub. A moins que tu considères la 8800 comme étant datée. Enfin bon, je m'y connais assez peu au niveau matos, donc bon... :P

Mais sinon, si tu paramètres le VBO comme il faut, rien ne sera copié sur GPU et le comportement devrait être exactement le même qu'avec un Vertex Array (c'est pour ça que je les aime bien, les VBO :P).
13/04/2011, 12h59
oxyde356

Oui enfin qu'est ce que tu appelle paramétrer. Parce qu'apparemment rien n'est sûr au niveau du comportement (où sont stockées les données).
13/04/2011, 13h08
math_lab

Il est vrai que le comportement dépend grandement du driver. Mais normalement, il n'y a que le mode 'mise a jour du mesh de temps en temps' qui est vraiment flou et dépend du driver et de la mémoire dispo. Le mode complètement statique et complètement dynamique sont normalement relativement bien définis (mais il me semble qu'il y a toujours un peu d’interprétation de la part du driver). Ça se complique surtout quand on veut sortir du simple mode de dessin pour aussi lire dans les buffers, en fait.
Personnellement, je fais plus confiance au driver (pour peu qu'il soit a jour) qu'a l'utilisateur quand il s'agit de décisions de très bas niveau (suffit de voir les horreurs de tutos qu'on trouve sur le net pour se faire une idée :roll:).
13/04/2011, 13h32
oxyde356

Oui et non les drivers (surtout ATI) ne sont pas une plaie mais un fléau. Je pense que je préférerai tout gérer à la mano. Pour les trucs dynamiques à chaque frame mais où il n'y a qu'une partie de la géometrie qui risque de bouger, VBO et une copie dans la ram puis subdata ou map pour mettre à jour. Et si c'est toute la géometrie qui bouge tout le temps alors vertex array je pense.
14/04/2011, 10h57
Robxley

Salut, je me permets d'intervenir.

Pour ma part j'opterai pour du VBO dans tous les cas. Pour la simple bonne raison que pour Opengl 3.x et 4 (et version future), les vertex arrays sont dépréciés, alors après je ne sais pas quelle version d'opengl vous utilisez. Mais malgré ça si vous tenez à jour vos pilotes de GPU, les pilotes seront tout de même optimisés pour les dernières versions d'Opengl (3.x et +) et donc optimisés pour l'ensemble des fonctionnalités non dépréciées.
Bien que le maintient de la prise en charge des fonctions dépréciées tels que les vertex arrays durera encore un bout de temps, j'ai des doutes sur leur optimisation notamment du fait de la prise en charge par émulation coté driver des fonctions dépréciées....

Après peut-être que je me trompe mais bon mieux vaut se plier aux exigences de son temps, si je puis dire.:ccool:
14/04/2011, 11h11
oxyde356

Bref tout dépend des contraintes de ton projet smartties, à toi de faire le bon choix ^^
14/04/2011, 11h29
ShevchenKik

Bonjour, je me permets à mon tour de donner mon avis, surtout en réaction à ce que dit Robxley:

Oui le choix des VBOs fait sens, mais à moins de programmer un soft qui ne tournera que sur VOTRE machine, ne délaissez pas l'option Vertex Array.

Les VBOs sont disponibles (via les extensions) sur la plupart des cartes supportant OpenGL 1.5, et sont standards à partir d'OpenGL 2.0.
Pour tout ce qui est en dessous il n'y a pas le choix, il faut utiliser les vertex array. En particulier, si vous ne savez pas sur quelle machine votre soft tournera, il est bon de noter que les vertex Array sont supportés dès OpenGL 1.1, et donc par le driver OpenGL software de Windows.

Par rapport à ce que dit Robxley, là je fais du nivellement par le bas, c'est clair. Mais comme dit si vous n'avez pas le contrôle des plateformes de destination, je ne peux que vous le recommander chaudement (Quand j'ai commencé dans ma boîte j'ai fait l'inverse et il m'a fallut un temps fou pour tout rendre retro-compatible....)

Oui je vais plutot opter pour les vbo mais comme je débute avec opengl j'essai d'utiliser toutes les possibilité d'afficer un objet pour m'habituer au fonctions et au fonctionement d' Opengl.
Mais une dernier question, est ce que avec les vbo je peut envoyer un tableau 2 dimensions, ou plusieurs tableau séparés( dans mon cas un tableau par faces) en mémoire? J'ai pensé faire appel plusieurs fois à glBufferSubData() pour ranger chaque tableaux en mémoire.
Par exemple avec 2 tableaux séparés:

les tableaux :

Code:

1
2
3
4
 
float face1[3 * nombre_v_face1] = { ... };
 
float face2[3 * nombre_v_face2] = { ... };

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
 
void ...::Init()
{
    glGenBuffers(1, &buffer_objet);
 
    glBindBuffer(GL_ARRAY_BUFFER, buffer_objet);
 
    glBufferData(GL_ARRAY_BUFFER,
                  (nombre_v_face1*3*sizeof(float)) + 
                  (nombre_v_face2*3*sizeof(float)),
                 NULL, GL_STREAM_DRAW);
 
    glBufferSubData(GL_ARRAY_BUFFER,
                 0,
                 (nombre_v_position1*3*sizeof(float)), 
                 face1);    
 
    glBufferSubData(GL_ARRAY_BUFFER,
                 (nombre_v_face1*3*sizeof(float)),
                 (nombre_v_face2*3*sizeof(float)), 
                 face2);
    glBindBuffer(GL_ARRAY_BUFFER, 0);
}

Et pour afficher :

Code:

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
 
void  ...::draw()
{
 
glBindBuffer(GL_ARRAY_BUFFER, buf);
 
        glVertexPointer(3, GL_FLOAT, 0,  BUFFER_OFFSET(0) );
 
        glEnableClientState(GL_VERTEX_ARRAY);
 
        glDrawArrays(GL_TRIANGLES, 0, nombre_v_face1 + nombre_v_face2);
 
        glDisableClientState(GL_VERTEX_ARRAY);
 
}

16/04/2011, 22h43
smartties

Ah c'est bon j'ai tous compris ^^ merci beaucoup pour votre aide !