Discussion :

[Ronan D.]

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 :

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

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

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 :

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
 
// 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 ^^.

[LittleWhite]

Bonjour,

Je crois qu'il va falloir faire du profilage sur votre code (soit mesuré le temps mis par chaque fonction) ... pour savoir ce qui cloche. Je ne suis pas sur que cela vienne d'OpenGL ... ou alors vous utilisez très mal OpenGL (testez aussi avec des glGetError() on ne sait jamais).
Sinon pas d'idée.

Ou alors, essayez des objets plus simples (au lieu des VAO ... des trucs plus basique du genre ... simple buffer (VBO ?))

[Invité]

Salut,

1. Premièrement, si tu fais des quads alors pas besoin d'indices. Tes vertices ne sont pas réutilisés.

2. Essaie de regrouper tes vertex dans un seul VBO (voir plus loin comment).

3. Ensuite il y a le problème des uniform que tu update trop souvent.

Tu peux t'en sortir comme ceci : envoie une seule fois la matrice projection * view (au lieu de projection * view * model) à ton shader et tu fais la transformation model en software en soumettant tes vertex.

Il faudra changer tes VBO de GL_STATIC_DRAW en GL_DYNAMIC_DRAW ou GL_STREAM_DRAW.


Ton algo pourrait être :

1. bouger les carrés
2. remplir le VBO des positions avec les positions world des points de tes carrés.
3. dessiner tout le VBO avec le bon shader et la bonne matrice caméra.


Quand aux VAO je ne sais pas ce que c'est, j'imagine que c'est inutile si tu n'utilise pas les indices.

[LittleWhite]

Si je me rappelle bien, les VAO (Vertex Array Object) sont des tableaux de VBO ... sensé amélioré un peu les performance et surtout réduire le nombre de ligne appelé pour dessiné des VBO ><
Ce ne m'avais pas semblé extrèmement utile à vrai dire ...

De la documentation existe sur la wiki d'OpenGL: http://www.opengl.org/wiki/Vertex_Array_Object (en anglais)

[Ronan D.]

D'accord, merci a vous deux pour vos commentaires et idées, je vais tester ça et je viendrais rendre compte :p.

Oui, les VAO sont comme l'a dit LittleWhite des structures OpenGL qui simplifient grandement l'établissement et l'utilisation de VBOs. Le code est donc plus propre au final (Plus besoin de glVertexPointer etc..).
Je vais essayer de ne pas utiliser de VAOs et de revenir a l'utilisation de VBOs simplement pour voir ce que ça donne.

@ponce : Euh, oui j'ai completement zappé les GL_QUADS en fait.. Comme je travaille uniquement en GL_TRIANGLES normalement.. La j'ai utilisé 4 GL_LINES pour faire mon carré en fait, donc 4 Vertex Position et 8 Index, c'est vrai que c'est une petite perte et quelque chose d'idiot, mais j'ai fait ça vite fait pour voir si les performances changeaient d'avec mes gros cubes solides.

Donc, généralement, j'utilise des Vertices ET des Indices, puisque j'ai l'intention d'importer des modèles 3D par la suite.

Pour mes vertices, en fait j'utilisais un VBO pour chaque composante Vertex, je ne sais pas si c'est une bonne méthode. Donc, par exemple, si je faisait un objet qui avait besoin des composantes Position, Normales et TexCoords, bah ça me faisait 3 VBOs (+ le VBO d'indices). Pas sur que ça soit très performant ça, que me conseillez vous?

Cependant, meme quand je n'utilisait que les positions comme composantes, j'ai toujours le probleme de performances (puisque mon carré la n'a qu'un VBO pour les positions et un pour les indices, donc ça devrait aller). Le problème est ailleurs donc.

A propos de faire la ModelViewProj en software, j'avais pas pensé à ça. Cela va-t-il vraiment améliorer les performances? Car c'est pas comme si j'en demandais beaucoup a mon GPU avec mes shaders tout simples quand meme... De plus, devoir a chaque mouvement/orientation de la camera mettre a jout les VBOs en dynamique, ça me parrait exagéré. Enfin, je dis ça mais je ne suis vraiment pas un professionnel du domaine graphique encore, j'apprends au fur et à mesure, donc si tu avais de plus amples informations là-dessus, ça m'interesse :p.

De plus, mon shader avec Phong illumination doit utiliser les vertex en ViewSpace, donc les passer directement en ClipSpace, ca chamboulerai tout. Enfin, je suppose que je peux calculer l'illumination en Clip Space, ca doit pas etre un probleme. Juste que je refasse mon shader^^.

Bref, encore merci pour ces réponses et celles qui (éventuellement) viendront encore. Je vais bosser là dessus de suite .

[Invité]

Oui, les VAO sont comme l'a dit LittleWhite des structures OpenGL qui simplifient grandement l'établissement et l'utilisation de VBOs. Le code est donc plus propre au final (Plus besoin de glVertexPointer etc..).
Je vais essayer de ne pas utiliser de VAOs et de revenir a l'utilisation de VBOs simplement pour voir ce que ça donne.

Je pense que tu peux les garder en fait vu que tu veux importer des mesh. Après c'est nouveau donc il y a toujours une chance pour que ça soit plus lent.

Pour mes vertices, en fait j'utilisais un VBO pour chaque composante Vertex, je ne sais pas si c'est une bonne méthode. Donc, par exemple, si je faisait un objet qui avait besoin des composantes Position, Normales et TexCoords, bah ça me faisait 3 VBOs (+ le VBO d'indices). Pas sur que ça soit très performant ça, que me conseillez vous?

Non c'est tout à fait valable particulièrement si tu ne veux updater que la position. Tu peux aussi entrelacer tes attributs dans un seul VBO.

A propos de faire la ModelViewProj en software, j'avais pas pensé à ça. Cela va-t-il vraiment améliorer les performances? Car c'est pas comme si j'en demandais beaucoup a mon GPU avec mes shaders tout simples quand meme...

D'après moi je pense que le bottleneck est le nombre de VBO, dis-toi que tu as droit à environ 500 drawElements par frame environ. En pratique aura-tu vraiment besoin de dessiner 200 meshs complets et différents à chaque frame ? J'espère que non.

De plus, devoir a chaque mouvement/orientation de la camera mettre a jour les VBOs en dynamique, ça me parrait exagéré.

A chaque mouvement de tes objets dans le monde. Si tes objets ne bougent pas, tu peux rester en GL_STATIC_DRAW et pas de problème pour les mettre dans le même VBO avec une position en World.

En fait il existe d'autres alternatives dans le cas de meshes qui changent pour éviter de mettre trop de choses à jour :
- l'instancing
- le skinning

De plus, mon shader avec Phong illumination doit utiliser les vertex en ViewSpace, donc les passer directement en ClipSpace, ca chamboulerai tout.

On s'est mal compris, tes vertices sont transformés comme ceci :

espace objet = matrice model => espace World => matrice view => ViewSpace => matrice projection => clipspace (J'en oublies certainement


Je te proposait de passer tes vertices directement en espace World, pas clip. Donc tu peux continuer à faire ton phong en ViewSpace si tu veux.

Je t'ai proposé ça car ça te permet de ne pas envoyer de matrice uniform entre chaque drawElements (tu envoierais projection * view une fois pour toute la frame).

Je suis clair ?