Vertex Buffer Object et performance

**ciberrique** · 21/06/2008, 19h29

Bonjour, j'ai ecrit un code en c++ et j'ai fait deux versions, une avec un affichage direct :
glBegin(GL_TRIANGLES);
...
glEnd();

et un avec les VBO, seulement une fois terminé je teste le fps de chacun et je me rend compte que les VBO sont plus lents (environ 30fps de moins), est ce que vous auriez une idée ?

**raptor70** · 21/06/2008, 19h36

Tout dépend du nombre de face que tu dessines et le mode de VBO choisi...

Envoi tu tes données à openGL, pour les VBO, toutes les frames ? ou une seule fois à l'initialisation ?

**ciberrique** · 21/06/2008, 19h50

Mon modele à 15842 triangles, a l'initialisation j'utilise :

Code :

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

1
2
3
4
5
 
glGenBuffers(1, &VertexBuffer[0].Obj[i].VBOPosition);
glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOPosition);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] *  3, NULL, GL_STATIC_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * Model.Mesh.nbrVertex[i]*3, VertexBuffer[0].Obj[i].Position);

puis pour le rendu (pour chaque fps):

Code :

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

1
2
3
4
5
6
7
 
glGenBuffers(1, &VertexBuffer[0].Obj[i].VBOPosition);
glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOPosition);
glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] *  3, NULL, GL_STREAM_DRAW);
glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * Model.Mesh.nbrVertex[i]*3, VertexBuffer[0].Obj[i].Position);
 
glDrawArrays(GL_TRIANGLES, 0, 3);

Mes vertices ne sont pas encore indexés, et je fais de meme pour les normales, et coordonnées de textures.

**raptor70** · 21/06/2008, 19h56

juste, tu recréé un buffer à chaque frame, donc c'est normal que ca ralentisse ...

Est ce que c'est justifié de re-envoyer la données de géométrie à chaque frame ?

L'idéal, c'est ca pour le rendu :

Code :

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

1
2
3
4
 
glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOPosition);
glVertexPointer(3, GL_FLOAT, 0, 0);
glDrawArrays(GL_TRIANGLES, 0, 3);

ou un truc comme ca ... pour ne faire qu'utiliser ton buffer. de la même manière que pour les textures

**ciberrique** · 21/06/2008, 20h01

Oups j'ai fait une erreur de copier/coller pour le rendu :

Code :

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

1
2
3
4
5
6
 
glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[nbrModel-1].Obj[j].VBOPosition);
glVertexPointer(3, GL_FLOAT, 0, 0);
glEnableClientState(GL_VERTEX_ARRAY);
glDrawArrays(GL_TRIANGLES, 0, Model.Mesh.nbrVertex[j]);
glDisableClientState(GL_VERTEX_ARRAY);

**raptor70** · 21/06/2008, 20h03

C'est surprenant alors ... je ne vois pas du tout ..

**ciberrique** · 21/06/2008, 20h08

Si quelqu'un a une idée, ou si vous voulez plus de code dites le moi, je suis dans l'incompréhension la

**ciberrique** · 21/06/2008, 23h32

Voici le code (épuré) concernant le chargement et l'affichage de mes VBO, en esperant que quelqu'un verra une erreur de ma part :

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
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
231
232
233
234
235
236
237
238
239
240
241
242
243
244
245
246
247
248
249
250
251
252
253
254
255
256
257
258
259
260
261
262
263
264
265
266
267
268
269
 
private:
 
        typedef struct {
        float x,y,z;                                        //type de point3d
        }TCoord3d;
 
        bool *visible;
        int nbrModel;
 
      public:
 
        GLuint    texture[1];       //id de la texture<
        cF3d Model;
        TCoord3d *min, *max;
        TCoord3d GlobalMin, GlobalMax;
        TCoord3d *pos, *dim, *rot;
        float CenterX, CenterY, CenterZ;
        int lastFrame;                  //Pour savoir si on doit modifier la frame
 
        typedef struct{
           GLfloat *Position;
           GLfloat *Texture;
           GLfloat *Normal;
           GLuint *Index;
           GLuint VBOPosition;
           GLuint VBOTexture;
           GLuint VBONormal;
           GLuint VBOIndex;
        }tVB;
 
        typedef struct {
            tVB *Obj;
        }tTabVB;
 
        tTabVB *VertexBuffer;
 
 
        bool LoadModel(char *path, char *textureRepPath){
 
            int i,j,r,s,t;
 
            if (Model.LoadF3d(path)) {                          //Chargement du modele
                LoadTexture(Model.Mesh.TextureName[0].path);    //Chargement de la texture
                pos = (TCoord3d *)malloc(sizeof(TCoord3d));
                dim = (TCoord3d *)malloc(sizeof(TCoord3d));
                rot = (TCoord3d *)malloc(sizeof(TCoord3d));
                angle = (float *)malloc(sizeof(float));
                visible = (bool *)malloc(sizeof(bool));
                                                                //Initialisation
                nbrModel=1;                                     //Nombre d'instance du modele
                SetPos(0,0.0,0.0,0.0);                          //Position de l'instance du modele dans le monde 3d
                SetScale(0,1.0,1.0,1.0);                        //Dimension de l'instance du modele dans le monde 3d
                visible[0] = true;                              //L'instance du modele est visible
 
                GetMinMax();                                    //Calcul des minimums et maximums de l'objet
                CenterX = (GlobalMax.x + GlobalMin.x) / 2;      //Calcul du centre de l'objet
                CenterY = (GlobalMax.y + GlobalMin.y) / 2;
                CenterZ = (GlobalMax.z + GlobalMin.z) / 2;
 
                VertexBuffer = (tTabVB *)malloc(sizeof(tTabVB));
 
                VertexBuffer[0].Obj = (tVB *)malloc(sizeof(tVB)*Model.Mesh.nbrMesh);
 
                for (i=0; i< Model.Mesh.nbrMesh;i++){
 
                    VertexBuffer[0].Obj[i].Index = (GLuint *)malloc(sizeof(GLuint)*Model.Mesh.nbrVertex[i]);
                    VertexBuffer[0].Obj[i].Normal  = (GLfloat *)malloc(sizeof(GLfloat)*Model.Mesh.nbrVertex[i] * 3);
                    VertexBuffer[0].Obj[i].Position = (GLfloat *)malloc(sizeof(GLfloat)*Model.Mesh.nbrVertex[i] * 3);
                    VertexBuffer[0].Obj[i].Texture = (GLfloat *)malloc(sizeof(GLfloat)*Model.Mesh.nbrVertex[i] * 2);
 
                    r=0;s=0;t=0;
 
                    for (j=0; j<Model.Mesh.nbrVertex[i];j++){
                        VertexBuffer[0].Obj[i].Index[j] = j;
                        VertexBuffer[0].Obj[i].Position[r] = Model.Mesh.Obj[i].x[j];
                        r++;
                        VertexBuffer[0].Obj[i].Position[r] = Model.Mesh.Obj[i].y[j];
                        r++;
                        VertexBuffer[0].Obj[i].Position[r] = Model.Mesh.Obj[i].z[j];
                        r++;
                        VertexBuffer[0].Obj[i].Texture[s] = Model.Mesh.Obj[i].tu[j];
                        s++;
                        VertexBuffer[0].Obj[i].Texture[s] = Model.Mesh.Obj[i].tv[j];
                        s++;
                        VertexBuffer[0].Obj[i].Normal[t] = Model.Mesh.Obj[i].nx[j];
                        t++;
                        VertexBuffer[0].Obj[i].Normal[t] = Model.Mesh.Obj[i].ny[j];
                        t++;
                        VertexBuffer[0].Obj[i].Normal[t] = Model.Mesh.Obj[i].nz[j];
                        t++;
                    }
 
                    if (Model.nbrOs == -1){
                        glGenBuffers(1, &VertexBuffer[0].Obj[i].VBOPosition);
                        glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOPosition);
                        glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] *  3, NULL, GL_STATIC_DRAW);
                        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * Model.Mesh.nbrVertex[i]*3, VertexBuffer[0].Obj[i].Position);
 
                        glGenBuffers(1, &VertexBuffer[0].Obj[i].VBOIndex);
                        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOIndex);
                        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * Model.Mesh.nbrVertex[i], NULL, GL_STATIC_DRAW);
                        glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(GLuint) * Model.Mesh.nbrVertex[i], VertexBuffer[0].Obj[i].Index);
 
                        glGenBuffers(1, &VertexBuffer[0].Obj[i].VBOTexture);
                        glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOTexture);
                        glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] *  2, NULL, GL_STATIC_DRAW);
                        glBufferSubData(GL_ARRAY_BUFFER, 0,sizeof(GLfloat) * Model.Mesh.nbrVertex[i] * 2, VertexBuffer[0].Obj[i].Texture);
 
                        glGenBuffers(1, &VertexBuffer[0].Obj[i].VBONormal);
                        glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBONormal);
                        glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] *  3, NULL, GL_STATIC_DRAW);
                        glBufferSubData(GL_ARRAY_BUFFER, 0,sizeof(GLfloat) * Model.Mesh.nbrVertex[i] * 3, VertexBuffer[0].Obj[i].Normal);
                    }else{
                        glGenBuffers(1, &VertexBuffer[0].Obj[i].VBOPosition);
                        glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOPosition);
                        glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] *  3, NULL, GL_STREAM_DRAW);
                        glBufferSubData(GL_ARRAY_BUFFER, 0, sizeof(GLfloat) * Model.Mesh.nbrVertex[i]*3, VertexBuffer[0].Obj[i].Position);
 
                        glGenBuffers(1, &VertexBuffer[0].Obj[i].VBOIndex);
                        glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOIndex);
                        glBufferData(GL_ELEMENT_ARRAY_BUFFER, sizeof(GLuint) * Model.Mesh.nbrVertex[i], NULL, GL_STREAM_DRAW);
                        glBufferSubData(GL_ELEMENT_ARRAY_BUFFER, 0, sizeof(GLuint) * Model.Mesh.nbrVertex[i], VertexBuffer[0].Obj[i].Index);
 
                        glGenBuffers(1, &VertexBuffer[0].Obj[i].VBOTexture);
                        glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBOTexture);
                        glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] *  2, NULL, GL_STREAM_DRAW);
                        glBufferSubData(GL_ARRAY_BUFFER, 0,sizeof(GLfloat) * Model.Mesh.nbrVertex[i] * 2, VertexBuffer[0].Obj[i].Texture);
 
                        glGenBuffers(1, &VertexBuffer[0].Obj[i].VBONormal);
                        glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[i].VBONormal);
                        glBufferData(GL_ARRAY_BUFFER, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] *  3, NULL, GL_STREAM_DRAW);
                        glBufferSubData(GL_ARRAY_BUFFER, 0,sizeof(GLfloat) * Model.Mesh.nbrVertex[i] * 3, VertexBuffer[0].Obj[i].Normal);
                    }
                }
 
                return true;
            } else {
                return false;
            }
        }
 
      void RenduFrame(){
            int i, j,r,k;
            float *ptrPos=NULL;
            float *v, *vout;
            extern int ActualFrame;
 
            if (lastFrame != ActualFrame){
                lastFrame = ActualFrame;
 
 
                vout = (float *)malloc(sizeof(float) * 3);
                v = (float *)malloc(sizeof(int) * 3);
 
                for (k=0; k<nbrModel;k++){
 
                    for (i=0; i< Model.nbrOs;i++){
 
                        for (j=0; j < Model.nbrLinkVertexOs[i];j++){
                            v[0] = Model.DisplayMesh.Obj[0].x[Model.linkVertexOs[i].indice[j]];
                            v[1] = Model.DisplayMesh.Obj[0].y[Model.linkVertexOs[i].indice[j]];
                            v[2] = Model.DisplayMesh.Obj[0].z[Model.linkVertexOs[i].indice[j]];
                            Vec3Transform (vout,v, &Model.Frame[ActualFrame].Os[i].transformation[0]);
                            Model.DisplayMesh.Obj[0].x[Model.linkVertexOs[i].indice[j]] = vout[0];
                            Model.DisplayMesh.Obj[0].y[Model.linkVertexOs[i].indice[j]] = vout[1];
                            Model.DisplayMesh.Obj[0].z[Model.linkVertexOs[i].indice[j]] = vout[2];
                        }
                    }
 
                    for (i=0; i< Model.Mesh.nbrMesh;i++){
 
                        r=0;
 
                        for (j=0; j<Model.Mesh.nbrVertex[i];j++){
                            VertexBuffer[k].Obj[i].Position[r] = Model.DisplayMesh.Obj[i].x[j];
                            r++;
                            VertexBuffer[k].Obj[i].Position[r] = Model.DisplayMesh.Obj[i].y[j];
                            r++;
                            VertexBuffer[k].Obj[i].Position[r] = Model.DisplayMesh.Obj[i].z[j];
                            r++;
                        }
                        glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[k].Obj[i].VBOPosition);
                        ptrPos = (float*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
                        memcpy(ptrPos, VertexBuffer[k].Obj[i].Position, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] * 3);
                        glUnmapBuffer(GL_ARRAY_BUFFER);
                        ptrPos = NULL;
 
                    }
                }
            }
            for (k=0;k<nbrModel;k++){
                for (j=0;j< Model.Mesh.nbrMesh;j++){
                    glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[k].Obj[j].VBOPosition);
                    glVertexPointer(3, GL_FLOAT, 0, 0);
 
                    glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[k].Obj[j].VBONormal);
                    glNormalPointer(GL_FLOAT, 0,0);
 
                    glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[k].Obj[j].VBOTexture);
                    glTexCoordPointer(2, GL_FLOAT, 0, 0);
 
                    glEnableClientState(GL_INDEX_ARRAY);
                    glEnableClientState(GL_VERTEX_ARRAY);
                    glEnableClientState(GL_NORMAL_ARRAY);
                    glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
                    glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, VertexBuffer[k].Obj[j].VBOIndex);
                    glDrawElements(GL_TRIANGLES, Model.Mesh.nbrVertex[j], GL_UNSIGNED_INT, 0);
 
                    glDisableClientState(GL_VERTEX_ARRAY);
                    glDisableClientState(GL_NORMAL_ARRAY);
                    glDisableClientState(GL_TEXTURE_COORD_ARRAY);
                    glDisableClientState(GL_INDEX_ARRAY);
                }
            }
        }
 
        void Rendu() {
 
            int k,j;
 
            glBindTexture(GL_TEXTURE_2D, texture[0]);
 
            for (k = 0; k<= nbrModel; k++){
 
                if (visible[k]){
 
                    glPushMatrix();
 
                    glTranslatef(pos[k].x, pos[k].y, pos[k].z);
                    glRotatef(rot[k].x, 1, 0,0);
                    glRotatef(rot[k].y, 0, 1,0);
                    glRotatef(rot[k].z, 0, 0,1);
                    glScalef(dim[k].x,dim[k].y,dim[k].z);
 
                    if (Model.nbrOs==-1){
                        for (j=0;j< Model.Mesh.nbrMesh;j++){
                            glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[j].VBOPosition);
                            glVertexPointer(3, GL_FLOAT, 0, 0);
 
                            glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[j].VBONormal);
                            glNormalPointer(GL_FLOAT, 0,0);
 
                            glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[0].Obj[j].VBOTexture);
                            glTexCoordPointer(2, GL_FLOAT, 0, 0);
 
                            glEnableClientState(GL_INDEX_ARRAY);
                            glEnableClientState(GL_VERTEX_ARRAY);
                            glEnableClientState(GL_NORMAL_ARRAY);
                            glEnableClientState(GL_TEXTURE_COORD_ARRAY);
 
                            glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, VertexBuffer[0].Obj[j].VBOIndex);
                            glDrawElements(GL_TRIANGLES, Model.Mesh.nbrVertex[j], GL_UNSIGNED_INT, 0);
 
                            glDisableClientState(GL_VERTEX_ARRAY);
                            glDisableClientState(GL_NORMAL_ARRAY);
                            glDisableClientState(GL_TEXTURE_COORD_ARRAY);
                            glDisableClientState(GL_INDEX_ARRAY);
                        }
                    } else {
                       RenduFrame();
                    }
                    glPopMatrix();
 
                }
 
            }
        }

**ciberrique** · 23/06/2008, 23h55

Voici le resultat de mes recherches,

Premierement, avec ce code pour le rendu j'obtient 290 fps:

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
 
glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
SwapBuffers (DC);
fps++;
 
    if (bfps == false){
        fpsTickCount2 = GetTickCount();
        bfps = true;
    }
 
    fpsTickCount1 = GetTickCount();
 
    if ((fpsTickCount1 - fpsTickCount2) > 1000){
        sprintf(strFps,"Jeu | Fps : %d",fps);
        SetWindowText(hwnd, strFps);
        fps = 0;
        bfps = false;
    }

Maintenant si je modifie la ligne :

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

par

glClear(GL_DEPTH_BUFFER_BIT);

la je passe à 430fps

Bien entendu je ne peux pas modifier glClear de cette façon sinon l'image n'est plus effacé.

Secondement si j'active un rendu de 15000polygone avec les VBO en ayant desactivé le GL_COLOR_BUFFER_BIT alors je passe a 115fps est ce normal ?

J'espere que vous pourrez m'aider.

**bachir006** · 24/06/2008, 19h57

tu as quoi comme carte graphique?

**ciberrique** · 24/06/2008, 21h18

Une Geforce 7300, mais le probleme le fais est present sur d'autre configuration donc je pense pas que ca vienne de la.

**shenron666** · 25/06/2008, 14h14

dans ta fonction RenduFrame, qu'est-ce que tu fais avec ce bout de code ?

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
                    for (i=0; i< Model.Mesh.nbrMesh;i++){

                        r=0;

                        for (j=0; j<Model.Mesh.nbrVertex[i];j++){
                            VertexBuffer[k].Obj[i].Position[r] = Model.DisplayMesh.Obj[i].x[j];
                            r++;
                            VertexBuffer[k].Obj[i].Position[r] = Model.DisplayMesh.Obj[i].y[j];
                            r++;
                            VertexBuffer[k].Obj[i].Position[r] = Model.DisplayMesh.Obj[i].z[j];
                            r++;
                        }
                        glBindBuffer(GL_ARRAY_BUFFER, VertexBuffer[k].Obj[i].VBOPosition);
                        ptrPos = (float*)glMapBuffer(GL_ARRAY_BUFFER, GL_WRITE_ONLY);
                        memcpy(ptrPos, VertexBuffer[k].Obj[i].Position, sizeof(GLfloat) * Model.Mesh.nbrVertex[i] * 3);
                        glUnmapBuffer(GL_ARRAY_BUFFER);
                        ptrPos = NULL;

                    }
                }
            }

d'autant plus que tes buffers sont déclarés en GL_DRAW_STATIC
si tu entres effectivmeent dans ta fonction RenduFrame c'est certain que ça te grève les perfs méchamment

**ciberrique** · 25/06/2008, 16h27

Non non, les VBO qui sont dans la fonction RenduFrame sont ceux déclaré en GL_STREAM_DRAW.

Regarde dans la fonction LoadModel si nbrOs != -1 alors mes VBO sont en GL_STREAM_DRAW. La fonction renduframe sert actuellement a jouer les animations d'objet au pas a pas.

Merci pour l'idée.
J'ai utilisé un tableau d'index et je gagne une 15aines de fps.

Si vous avez une autre idée.

**shenron666** · 25/06/2008, 17h50

tu met donc à jour un ou des VBOs durant le rendu
est-ce que tu fais ce genre de chose aussi en affichage direct ou seulement avec les VBOs ?

quelque soit ta réponse, le fait de mettre à jour un VBO aura forcément un impact sur les perfs
et les 30 fps de moins dont tu parles dans ton premier post, c'est par rapport à combien de fps de base ?
parceque passer de 430 à 400 fps ou de 50 à 20 fps c'est pas la même chose
dans le premier cas, la différence n'est pas à prendre en considération
dans le second cas, il y a une optimisation à rechercher

**ciberrique** · 25/06/2008, 18h31

Je n'ai plus que des VBO actuellement, j'ai bannis l'affichage direct de mon application.
Sinon pour les fps c'etait de 130 a 100 (environ), mon application n'est jamais monté a 400 fps meme avec une fenetre vide.

**shenron666** · 26/06/2008, 11h06

juste que tu parlais de 430 fps dans un post précédent

Envoyé par ciberrique

Maintenant si je modifie la ligne :

glClear( GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);

par

glClear(GL_DEPTH_BUFFER_BIT);

la je passe à 430fps

Bien entendu je ne peux pas modifier glClear de cette façon sinon l'image n'est plus effacé.

j'en profite pour te dire que le moteur de quake 3 par exemple ne fait pas appel à GL_COLOR_BUFFER_BIT pour effacer l'écran
à a différence de ton application, lorsque l'affichage doit être actualisé, il prend à tous les coup la totalité de l'écran, l'affichage précédent est donc effacé par le nouveau rendu

sinon tu disais avoir également testé ton appli sur d'autres machines, c'était avec la même carte vidéo ?
peux tu me dire si les mises à jour de buffer sont faites à chaque frame (appel à RenduFrame) ?

**ciberrique** · 26/06/2008, 11h45

Donc tu me dis que je pourrais eviter d'utiliser GL_COLOR_BUFFER_BIT si mon affichage est entierement effacé ?

Pour ce qui est de la mise a jour des VBO, la il y en a aucune car c'est moi qui quand j'appuis sur une touche du clavier change la frame du model, donc a ce moment la renduframe actualise le VBO.

Sinon oui j'ai testé sur une machine qui avait une autre cg, une Ati HD 2400 XT, et une ATI mobility radeon X1300 .

Actuellement si je desactive GL_COLOR_BUFFER_BIT je gagne une 20aines de fps donc peut etre que ca ne viens pas de la, peut etre qu'il n'y a pas de bug, je sais pas trop, donnez moi vos avis d'expert s'il vous plait.

**bachir006** · 26/06/2008, 13h24

t'as de la chanc,moi j'ai 30fps maximum avec un objet chargé d'in .bj et affiché avec les VBO

**Kurisu** · 26/06/2008, 23h42

Envoyé par ciberrique

Pour ce qui est de la mise a jour des VBO, la il y en a aucune car c'est moi qui quand j'appuis sur une touche du clavier change la frame du model, donc a ce moment la renduframe actualise le VBO.

Attends, tu changes le contenu du VBO (donc les vertices, normales, etc) par frame? Est-ce que tu calculerais les nouvelles informations des vertices etc sur le CPU? Tu sais que ca prend bien plus de temps que d'envoyer une fois les VBO et de n'actualiser que les matrices des os de ton modèle à chaque frame.

Ou alors, j'ai mal compris et tu fais rendu vers vertex buffer?

**ciberrique** · 27/06/2008, 00h49

Comme je l'ai dis, pour le moment il n'y a aucune actualisation de mes VBO.

Sinon oui plus tard je calculerais en fonction de mes matrices les nouvelles positions des vertices et je metrais a jours a chaque frame. Changer seulement les matrices ne provoque pas de modification sur le modele, il faut donc appliquer les matrices au modele, me trompe-je ?

Vertex Buffer Object et performance

OpenGL

Discussions similaires

Partager

Partager