Discussion :

[Ekinoks]

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

[Ekinoks]

he... j'ai fait une petite erreur dans le calcules des temps d'affichage
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 :

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

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

[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 ?

[Ekinoks]

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 :

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

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

[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

[Ekinoks]

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 :

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