[OpenGL 3.3] VAO Performances
Bonjour, je programme sur OpenGL depuis quelques temps en parallèle avec mes études pour voir comment ça marche et j'ai commencé un moteur avec SFML 2.0/OpenGL 3.3 il y a quelques temps déjà.
Tout allait plutôt bien et j'implémentait au fur et à mesure de nouvelles fonctionnalitées, mais je viens de m'apercevoir que je les testais toujours sur un deux ou trois cubes. J'ai donc essayé d'en mettre 100, et la le nombre de FPS a chuté et frolait presque les 0.
J'ai donc enlevé le Per-Pixel Lighting. Pareil. Enlevé les textures. Pareil. Réduit mes primitives a de simples carrés dessinés en GL_LINES, et c'est toujours pareil.
Exemple:
0 Carré : Très grosses perturbations entre 1000 et 4000 FPS, normal je suppose
1 Carré : ~1300 FPS
3 Carrés : ~650 FPS
20 Carrés : ~125 FPS
100 Carrés : ~2 FPS
Quand je parle de carré, ça ressemble a ça:
http://d.imagehost.org/0219/Capturecarre.png
Donc, j'utilise comme il se doit uniquement des VAO et des VBO, et je fais mes propres shaders.
Voici des parties importantes de mon code en simplifié, en enlevant quelques commentaires inutiles et en renomant quelques variables pour la compréhension:
Creation des VAOs / VBOs :
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
|
glGenVertexArrays(1, &mVao); // Generation VAO
glGenBuffers(1, &mVbo); // Generation VBO
glBindBuffer(GL_ARRAY_BUFFER, mVbo);
glBufferData(GL_ARRAY_BUFFER, pSize, pVector, GL_STATIC_DRAW);
glBindBuffer(GL_ARRAY_BUFFER, 0);
glGenBuffers(1, &mIbo); // Generation des VBO d'indices
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIbo);
glBufferData(GL_ELEMENT_ARRAY_BUFFER, pSize, pIndices, GL_STATIC_DRAW);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, 0);
mICount = pIndiceSize / sizeof(Index); // Nombre d'indices
// Bind du VAO pour y inclure les deux VBO précédents
glBindVertexArray(mVao);
glBindBuffer(GL_ARRAY_BUFFER, mVbo.GetBuffer());
GLint loc = glGetAttribLocation(pShader->GetProgram(), "inVertex");
glVertexAttribPointer(loc, 3, GL_FLOAT, GL_FALSE, 0, 0);
glEnableVertexAttribArray(loc);
glBindBuffer(GL_ELEMENT_ARRAY_BUFFER, mIbo.GetBuffer());
glBindVertexArray(0); |
Voici le code de render :
Code:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
|
glUseProgram(shader.ID);
// Envoi de la Model * View * Projection Matrix au shader
shader.SendMatrix("ModelViewProjMatrix", entity.GetModelMatrix() * m3DViewProjMatrix);
// Envoi de la couleur diffuse de l'entité au shader
shader.SendColor("Kd", entity.GetMaterial().mDiffuse);
// Bind du VAO afin de le dessiner
glBindVertexArray(entity.GetVAO().ID);
glDrawElements(GL_LINES, entity.GetVAO().GetIndexCount(), GL_UNSIGNED_INT, 0);
glBindVertexArray(0);
glUseProgram(0); |
Des shaders que j'ai simplifié au maximum mais qui n'améliorent pas les choses:
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
|
// VERTEX SHADER
#version 330
// matrix
uniform mat4 ModelViewProjMatrix;
// in attribs
in vec3 inVertex;
void main(){
// VertexPos in clip space
vec4 position = vec4(inVertex, 1.0);
gl_Position = ModelViewProjMatrix * position;
}
// FRAGMENT SHADER
#version 330
// color
uniform vec4 Kd;
// out attribs
out vec4 finalColor;
void main(){
finalColor = Kd;
} |
Voila, je ne sais que faire, je trouve ça anormal, vu que ce ne sont que quelques simples primitives, sans texture, sans éclairage, je devrais pouvoir en afficher des centaines sans qu'il n'y ait de problème non?
Est-ce que j'utilise mal les VAO/VBO? J'ai pourtant il me semble respecté les tutoriels que j'ai pu croiser à mes débuts.
Coté matériel, j'ai une GeForce GTX285 et mes drivers sont à jour.
Si vous avez besoin d'autres parties de mon code que j'aurai oublié ou pour toutes autres questions, demandez-moi. De toute façon, tous mes codes sont open source.
Merci d'avance si quelqu'un a une idée. Et j'espère que c'est pas quelque chose de trop bête ^^.
