Questions sur les VBOs

Version imprimable

11/08/2006, 20h48
Ekinoks

Questions sur les VBOs

Salut !
Je viens de faire des testes de comparaison entre les VBO et les vertex arrays et j’ai plain de questions :^/

Déjà, pour un objet de 2608 vertex avec 6000 faces (ou plus), il y a une erreur avec l’utilisation des VBO...
On ne peu donc pas utiliser les VBO avec de gros objet ???
Si c’est le cas, y a t’il un moyen de savoir la limite de grosseur d’un objet pour les VBO ?

Ensuite, pour un objet de 2141 vertex et 4860 faces, si on met l’objet dans un VBO des le début (glGenBuffersARB + glBindBufferARB + glBufferDataARB) puis que lors de l’affichage juste on affiche l’objet... les performance sont plus de sept foie plus rapide que les vertex arrays !
Par contre ! si à chaque nouvelle image, on modifie integralement l’objet (glBindBufferARB + glMapBufferARB + modif + glUnmapBufferARB), là les performance sont trois foie moins rapide que les vertex arrays !
Donc si l’objet est animée, il vaut mieux utiliser les vertex arrays ?

Pour terminé, j’ai fait les teste avec les trois mode GL_STREAM_DRAW_ARB, GL_DYNAMIC_DRAW_ARB et GL_STATIC_DRAW_ARB mais les résultats ne change pas...

Merci

he... j'ai fait une petite erreur dans le calcules des temps d'affichage :fessee:
je pris en compte que le temps d'écriture dans la mémoire video :^/
J'ai refait les tests en prenant cette foi si une boucle d'affichage complète !! =)

Voici les résultats obtenue :
Code:

1 2 3 4 5 6 7 VBO statique avec un objet dynamique : 1.44Ms VBO dynamique avec un objet dynamique : 1.44Ms VBO statique avec un objet statique : 1.34Ms VBO dynamique avec un objet statique : 1.34Ms vertex arrays : 1.38Ms
du coup ça ne me choque plus trop si ce n'est qu'il n'y a pas de différence entre le statique et le dynamique :^/

Mais j'ai surtout et toujours cette grande question de savoir, si le fait que je ne puisse pas créé de VBO (ou vertex arrays d’ailleurs) avec un objet de plus de 6000 Faces viens du fait qu’il y est une éventuel limite de taille ???

Merci

12/08/2006, 17h07
Laurent Gomila

Faire des mesures au dizième de millisecondes près sur des OS non temps réel, ça me semble douteux.

Ensuite, le GPU et le CPU ne sont pas synchrones, pour avoir quelque chose de cohérent il faut donc faire très attention à la manière dont tu fais tes mesures.

Enfin, 2000 face ça peut sembler peu, surtout pour le matos actuel.

Bref charge plutôt une très grosse scène (plusieurs millions de polys) et mesure le framerate.

Quant à ton problème avec les VBOs, ce n'est pas normal. Quelle est l'erreur renvoyée par OpenGL ?

Merci pour ta réponse Laurent :)

Oui effectivement j’ai du faire une petite erreur pour la limite des vertex, j’ai tout recodé la partie des VBO et du coup il n’y a plus de limite (ou une limite très grosse que je n'ai pas reussi à atteindre) je suis monté à 600 000 Faces et ça marche toujours... ===)

Donc, maintenant avec 600 000 Faces on commence a voir une grosse différence entre les vertex arrays et les VBO mais toujours pas de différence entre les VBO statique et VBO dynamique...
Voici les résultat obtenue avec une géosphère de 600 000 Faces :
Code:

1 2 3 4 5 6 7 vertex arrays = 14FPS VBO statique avec un objet statique = 108FPS VBO dynamique avec un objet statique = 108FPS VBO statique avec un objet statique = 49FPS VBO dynamique avec un objet statique = 49FPS
He... quand je dit que l’objet est dynamique, c’est que a chaque frames je lui change les valeur des normal, vertex et face avec (glMapBufferARB ... glUnmapBufferARB)

Merci

14/08/2006, 01h43
Sixissor

Voici un lien très intéressant concernant les VBO et les display lists:
http://www.sci.utah.edu/~bavoil/opengl/

J'ai tout simplement "halluciné" quand j'ai vu qu'en changeant 1 type de données en un autre, on DOUBLE les fps...
Faudrait vraiment vérifier parce que ça semble bizarre...

PS: tu trouveras les réponses dans les liens du site plus haut. Lis bien tout ;)

ha ouais, effectivement très très intéressent ce lien !!! merci Sixissor
c'est que les doc sur les VBOs sont rare

je trouve leur résultas un peu bizarre quand même, les display lise peuvent être suivent les cas plus rapide que les VBOs ?...

si non, je n'ai rien trouver sur le pourquoi les VBO statique et VBO dynamique on les même résultat, c'est peu être moi qui est fait une erreur... voici la class de gestion des VBO :

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
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
 
void initVbo ()		//Inisalise l'utilisation des VBOs
{
 
    #ifndef NO_VBOS
	   g_fVBOSupported = IsExtensionSupported( "GL_ARB_vertex_buffer_object" );
	   if( g_fVBOSupported )
	   {
            glBindBufferARB =           (PFNGLBINDBUFFERARBPROC)                wglGetProcAddress("glBindBufferARB");
            glDeleteBuffersARB =        (PFNGLDELETEBUFFERSARBPROC)             wglGetProcAddress("glDeleteBuffersARB");
            glGenBuffersARB =           (PFNGLGENBUFFERSARBPROC)                wglGetProcAddress("glGenBuffersARB");
            glIsBufferARB =             (PFNGLISBUFFERARBPROC)                  wglGetProcAddress("glIsBufferARB");
            glBufferDataARB =           (PFNGLBUFFERDATAARBPROC)                wglGetProcAddress("glBufferDataARB");
            glBufferSubDataARB =        (PFNGLBUFFERSUBDATAARBPROC)             wglGetProcAddress("glBufferSubDataARB");
            glGetBufferSubDataARB =     (PFNGLGETBUFFERSUBDATAARBPROC)          wglGetProcAddress("glGetBufferSubDataARB");
            glGetBufferSubDataARB =     (PFNGLGETBUFFERSUBDATAARBPROC)          wglGetProcAddress("glGetBufferSubDataARB");
            glMapBufferARB =            (PFNGLMAPBUFFERARBPROC)                 wglGetProcAddress("glMapBufferARB");
            glUnmapBufferARB =          (PFNGLUNMAPBUFFERARBPROC)               wglGetProcAddress("glUnmapBufferARB");
            glGetBufferParameterivARB = (PFNGLGETBUFFERPARAMETERIVARBPROC)      wglGetProcAddress("glGetBufferParameterivARB");
            glGetBufferPointervARB =    (PFNGLGETBUFFERPOINTERVARBPROC)         wglGetProcAddress("glGetBufferPointervARB");
        }
    #else
	   g_fVBOSupported = false;
    #endif
}
 
void Vbo::buildVertex(float * vertex, int taille)
{
    if(g_fVBOSupported == true)
    {
	   glGenBuffersARB( 1, &arbVertex );						
	   glBindBufferARB( GL_ARRAY_BUFFER_ARB, arbVertex );			
	   glBufferDataARB( GL_ARRAY_BUFFER_ARB, taille*sizeof(float), vertex, /*GL_STREAM_DRAW_ARB*//*GL_DYNAMIC_DRAW_ARB*/GL_STATIC_DRAW_ARB );
    }else
    {
        bufVertex = vertex;
    }
    bVertex=true;
}
 
void Vbo::buildNormal(float * normal, int taille)
{
    if(g_fVBOSupported == true)
    {
	   glGenBuffersARB( 1, &arbNormal );						
	   glBindBufferARB( GL_ARRAY_BUFFER_ARB, arbNormal );		
	   glBufferDataARB( GL_ARRAY_BUFFER_ARB, taille*sizeof(float), normal, /*GL_STREAM_DRAW_ARB*//*GL_DYNAMIC_DRAW_ARB*/GL_STATIC_DRAW_ARB );
    }else
    {
        bufNormal = normal;
    }
    bNormal=true;
}
 
void Vbo::buildFace(int * face, int taille)
{
    nbFace = taille;
 
    if(g_fVBOSupported == true)
    {
	   glGenBuffersARB( 1, &arbFace );						
	   glBindBufferARB( GL_ARRAY_BUFFER_ARB, arbFace );		
	   glBufferDataARB( GL_ARRAY_BUFFER_ARB, taille*sizeof(float), face, /*GL_STREAM_DRAW_ARB*//*GL_DYNAMIC_DRAW_ARB*/GL_STATIC_DRAW_ARB );
    }else
    {
        bufFace = face;
    }
    bFace=true;
}
 
void Vbo::afficher()
{
    if(bFace && bVertex)
    {
        glEnableClientState( GL_VERTEX_ARRAY );
        if( g_fVBOSupported )
        {
            if(bNormal)
            {
                glEnableClientState(GL_NORMAL_ARRAY);
                glBindBufferARB( GL_ARRAY_BUFFER_ARB, arbNormal );
                glNormalPointer(GL_FLOAT, 0, 0);
            }
 
            glBindBufferARB( GL_ARRAY_BUFFER_ARB, arbVertex );
            glVertexPointer( 3, GL_FLOAT, 0, (char *) NULL );	
 
            glBindBufferARB(GL_ELEMENT_ARRAY_BUFFER_ARB, arbFace);
            glDrawElements(GL_TRIANGLES, nbFace, GL_UNSIGNED_INT, 0);
 
            if(bNormal)
            {
                glDisableClientState(GL_NORMAL_ARRAY);
            }
        }else
        {
            if(buildList==1)
            {
                list = glGenLists(1);
                glNewList(list, GL_COMPILE);
                if(bNormal)
                {
                    glEnableClientState(GL_NORMAL_ARRAY);
                    glNormalPointer(GL_FLOAT, 0, bufNormal);
                }
 
                glVertexPointer(3, GL_FLOAT, 0, bufVertex);
                glDrawElements(GL_TRIANGLES, nbFace, GL_UNSIGNED_INT, bufFace);
 
                if(bNormal)
                {
                    glDisableClientState(GL_NORMAL_ARRAY);
                }
                glEndList();
 
                buildList=0;
            }
 
            glCallList(list);
        }
        glDisableClientState( GL_VERTEX_ARRAY );
    }else
    {
        printf("Impossible d'afficher le model car les faces ou les vertex n'on pas etait builder !\n");
    }
}

il ne me semble pas que j'ai fait d'erreur pourtant si ?

Merci

14/08/2006, 19h25
Sixissor

Citation:

je trouve leur résultas un peu bizarre quand même, les display lise peuvent être suivent les cas plus rapide que les VBOs ?...

Oui bien sûr. A toi d'en faire bon usage ;)

Pour la différence entre les VBO statique et dynamique, d'après ce que j'ai lu, la différence ne se situe pas au niveau des performances, mais au niveau de l'utilisation: les buffer statiques sont en lecture seul, alors que les buffers dynamiques sont en lecture ET écriture (pour modifier les vertex, etc.).
A mon avis c'est question de "thread safe".

++
15/08/2006, 12h39
Groove

Sixissor c'est faux alors oublié ta def de static et dynamic, ce que tu dis correpond aux usages READ, COPY et DRAW
DRAW : ecriture
READ : lecture XD
COPY : lecture et ecriture

Au detail que les GPU actuelle ne supporte pas les features READ et COPY. Ca arrive avec la prochaine generation de cartes !

Les VBOs sont vraiment géniales alors une petite lecture assez complete:
http://www.g-truc.net/article/vbo-fr.pdf

Les types de données sont effectivement important et pour obtenir les meilleurs perfs il faut utilisé les types de données qui correspondent à l'implémentation hardware. Pour les VBOs par exemple les float sont souvent un bon choix d'ailleurs une normal en unsigned char est un non sens par exemple, tant pour le programme C++ qui va devoir faire des conversions, que pour le GPU qui va devoir diviser en flottant (une opération tres longue) chaque normales. Pour les couleurs c'est un peu moins evident par contre. En fait tout le problème est de savoir si a glVertexAttribPointer, je vais devoir mettre true ou false on 4eme parameters ou plutot si nous sommes succeptible de mettre true. Si vous utilisez les fonctions du fixed pipeline, vous pouvez aussi déduire la valeur potenciel de ce parametre bien qu'il n'existe pas.

Autre exemple le read back de texture. En unsigned char RGB est beaucoup plus rapide, en half ou float les BGR est beaucoup plus rapide sur nVidia. Sur ATI, je n'en ai aucune idée que je supose que les deux fabricent on choisi des convension similaire dans leur carte ... heum j'espère plutot. Pour optimiser une application 3D, les sources de données sont à mon avis le facteur 2 après le control du batching.

VOilà ++
15/08/2006, 16h54
Sixissor

Humm...
Non non j'ai pas oublié ma définition de statique et dynamique ne t'inquiète pas ;)
Mais ici ce n'est pas les définitions "ordinaires", ce sont comme des comportements.

Tiré du PDF "Using Vertex Buffer Objects (VBOs)" sur le site de Nvidia, dans la section développeurs:
http://www.noob.fr/upload/a7f9c_vbo1j.jpg

Et voici les commentaires:
http://www.noob.fr/upload/d4c1a_vbo2j.jpg

Et pour finir par ton lien (pdf):
http://www.noob.fr/upload/7cff8_vbo3j.jpg

Donc ça revient au même... non ?
Si ça te gênes je reformule: Pour la différence entre les VBO statique et dynamique, la différence ne se situe pas au niveau des performances, mais au niveau de l'utilisation: il est TRES fortement conseillé que les buffers statiques ne soient pas modifiés une fois crées, alors que les buffers dynamiques sont spécialement conçus pour être modifiés en temps réel.

C'est pour ça que j'ai dit buffer statique => lecture seule et buffer dynamique => lecture et écriture. Sachant qu'ils ne l'imposent pas, mais le conseil très fortement, c'est comme si...

Après, bien sûr, il faut explicitement spécifier les flags read/write/copy correspondant au bon type de buffer.
Par exemple, c'est "idiot" de définir un buffer statique avec le flag copy. Tout autant qu'un buffer dynamique avec le flag read only.

J'espère m'être mieux exprimé.
++
15/08/2006, 21h38
Ekinoks

ok oui d’accord, je commence a mieux comprendre, en fait utiliser les modes dynamic, static ou stream est plus une histoire de convention que de performance ?
C’est pour cela que quelque soit le mode utilisé, les performances sont les même... ?

Merci
15/08/2006, 22h19
Sixissor

Oui c'est ça.
Par exemple, si tu as un tableau de vertices que tu initialises au début et après t'y touches plus, si tu utilises le mode dynamic, static ou stream, ça ne change rien aux perfs.

A MOINS QUE le placement du buffer dans la mémoire système, AGP ou vidéo dépende du mode utilisé...

Citation:

This combination of memory usage can help the memory manager balance between
three kinds of memory: system, AGP and video. On the other hand, it has to figure
out how areas of memory can be recycled for the other buffers.

Donc au final c'est assez confus... mais de toute façon on n'y peut rien vu que c'est le memory manager qui s'occupe de ça et tu ne peux pas décider toi-même quel type de mémoire tu veux utiliser.

Enjoy les VBO, même si c'est assez bizarre comme système au final...

++
15/08/2006, 22h56
Ekinoks

^^ ok ! c'est vrais que c'est bizarre comme système :^/

Merci pour tout ces renseignements sur les VBOs !
16/08/2006, 00h27
Groove

Heum pourtant STATIC et COPY en meme n'a rien d'idiot, c'est juste pas encore possible ca il faut l'output stream. En fait, ce mode sera tres util pour faire des opérations recursives dans le pixel pipeline. La lecture des buffers par le CPU via vertex mapping, n'a rien a voir, je ne voudrais pas qu'il y est confusion entre GL_READ_ONLY et GL_STATIC_READ par exemple.

Non vraiment le système n'a rien de bizard, il correspond totalement au hardware.

Ekinoks tu peux cobsiderablement améliorer ton prog est déplacant tes gl*Pointer au niveau du chargement des VBOs.
16/08/2006, 12h15
Ekinoks

Citation:

Envoyé par Groove

Heum pourtant STATIC et COPY en meme n'a rien d'idiot, c'est juste pas encore possible ca il faut l'output stream. En fait, ce mode sera tres util pour faire des opérations recursives dans le pixel pipeline. La lecture des buffers par le CPU via vertex mapping, n'a rien a voir, je ne voudrais pas qu'il y est confusion entre GL_READ_ONLY et GL_STATIC_READ par exemple.

ok, donc dans le futur les modes de transfère serons plus important qu'aujourd'hui...

Citation:

Envoyé par Groove

Ekinoks tu peux cobsiderablement améliorer ton prog est déplacant tes gl*Pointer au niveau du chargement des VBOs.

Ha ? c'est a dir ? je ne comprend pas bien se que tu veux dir... :^/

Merci
16/08/2006, 15h33
Sixissor

Citation:

Envoyé par Groove

Heum pourtant STATIC et COPY en meme n'a rien d'idiot, c'est juste pas encore possible ca il faut l'output stream. En fait, ce mode sera tres util pour faire des opérations recursives dans le pixel pipeline.[...]

Non vraiment le système n'a rien de bizard, il correspond totalement au hardware.

Tu peux détailler un peu plus stp ça m'intéresse... Niveau hardware je n'y connais presque rien donc si tu peux m'éclairer la lanterne ça serait cool :mrgreen:

++