Vertex Buffer Object et performance

Version imprimable

21/06/2008, 19h29
ciberrique

Vertex Buffer Object et performance

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 ?
21/06/2008, 19h36
raptor70

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 ?

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

Code:

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:

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.

21/06/2008, 19h56
raptor70
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:

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

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

Code:

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

21/06/2008, 20h03
raptor70

C'est surprenant alors ... je ne vois pas du tout ..
21/06/2008, 20h08
ciberrique

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

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:

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();
 
                }
 
            }
        }

Voici le resultat de mes recherches,

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

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.

24/06/2008, 19h57
bachir006

tu as quoi comme carte graphique?
24/06/2008, 21h18
ciberrique

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

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

Code:

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

25/06/2008, 16h27
ciberrique

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.
25/06/2008, 17h50
shenron666

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
25/06/2008, 18h31
ciberrique

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.
26/06/2008, 11h06
shenron666

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

Citation:

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) ?
26/06/2008, 11h45
ciberrique

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.
26/06/2008, 13h24
bachir006

t'as de la chanc,moi j'ai 30fps maximum avec un objet chargé d'in .bj et affiché avec les VBO :(
26/06/2008, 23h42
Kurisu

Citation:

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?
27/06/2008, 00h49
ciberrique

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 ?
28/06/2008, 01h00
Kurisu

Citation:

Envoyé par ciberrique

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 ?

Oui, mais tu appliqueras les matrices au modèle via un shader, mais sans que cela change forcement les vertices d'origine. Ou plutôt, ca changera les vertices pour les faire traiter par la GPU, mais tu n'auras pas besoin d'enregistrer ces changements.
29/06/2008, 20h30
ciberrique

Hum pourrais je avoir plus d'explication ou un tutorial si possible, je connais pas les shaders, donc je ne vois pas trop ce que tu veux dire.

ps : j'ai commencé a lire le tutot de Laurent Gomila sur le site mais il ne traite que des cartes nvidia et pas ATI.
01/07/2008, 16h33
ciberrique

Petite question si j'utilise GLSL ce n'est pas compatible avec toute les cartes graphiques, a partir de quel carte c'est compatible?
01/07/2008, 17h50
shenron666

concernant ce sujet, un petit outil utile à télécharger :
http://www.realtech-vr.com/glview/download.html
01/07/2008, 21h07
ciberrique

Plutot utile comme logiciel. Merci.
04/07/2008, 11h48
Kurisu

Citation:

Envoyé par ciberrique

Petite question si j'utilise GLSL ce n'est pas compatible avec toute les cartes graphiques, a partir de quel carte c'est compatible?

De toutes facons, les VBO ne sont pas compatibles avec toutes les cartes graphiques, au même point que les shaders ne sont pas compatibles avec toutes les cartes graphiques.
Mais tu utilises vraiment encore une 3dfx/Voodoo ou une RivaTNT sur ton PC?
En principe, toutes cartes graphiques actuelles (disons à partir de GeForce 5) supportent ces 2 extensions. Puis GLSL vient de l'ARB, ca a intérêt à être compatible (j'en sais d'ailleurs moins pour Cg, vu que ca vient de nvidia).
04/07/2008, 11h59
ciberrique

Ok alors je vais utiliser aussi GLSL, merci pour tout.
05/07/2008, 13h20
ciberrique

REBonjours, j'ai une nouvelle question, vaut il mieu mettre a jour mes vertices avec glMapBuffer
ou en supprimant le buffer glDeleteBuffers puis en le reconstruisant avec glGenBuffers ?
05/07/2008, 13h33
raptor70

Citation:

Envoyé par ciberrique

REBonjours, j'ai une nouvelle question, vaut il mieu mettre a jour mes vertices avec glMapBuffer
ou en supprimant le buffer glDeleteBuffers puis en le reconstruisant avec glGenBuffers ?

Detruire et recréer les buffers à chaque fois que tu mets à jour des données est assez couteux ( allocation mémoire, etc...). Il est effectivement préférable d'utiliser glMapBuffer et glUnMapBuffer pour modifier les données. Ils te permettent d'accéder directement à la mémoire GPU où sont stocké tes buffers pour les modifier.
07/07/2008, 14h43
ciberrique

Bonjour, je reviens içi pour apporter une reponse à un des problemes que j'ai posé ici, je rappel :
J'ai une fenetre vide et je n'ai que 290fps est ce normal ?

En faite c'est juste a cause de la taille de ma fenetre :
1340x800

Voila, desolé de vous avoir embétté pour rien.
07/07/2008, 15h38
shenron666

Citation:

Envoyé par ciberrique

En faite c'est juste a cause de la taille de ma fenetre : 1340x800

c'est malin lol :lol:
tu auras au moins appris quelques petites choses :roll: ;)