Discussion :

[tickyletroll]

Bonjour,

Je maintiens un programme dont chaque classe s'occupe d'afficher sa "partie" en OpenGL.
Environ 140 fichiers, 50 classes. Ni trop gros, ni trop petit, humainement gérable.
C'était du vieux code OpenGL avec du gLbegin, gLvertex gLend partout...

Je rénove le programme et la transformation en OpenGL4 arrive petit à petit à quelque chose.

Chaque classe qui s'occupe d'afficher quelque chose gère ses propres fonctions d'affichage.
J'ai une classe spécialisée qui me charge mes shaders et qui me compile le tout, me donnant un shaderProgram .

Ainsi, pour chaque shader que j'emploie, je me retrouve avec ces portions de codes :

Pour les données:

Code :

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

1
2
3
4
5
 
	//shader for first layer
	shaderProgram* shaderLayer;
	GLuint vboLayerPos;
	GLuint vaoLayer;

Pour les méthodes:

Code :

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

1
2
3
4
 
	void initLayerShader();
	void initLayerParam();
	void drawFirstLayer();

Le programme tourne mais ...
Autant avant mes classes d’affichage avaient peu de fonction, autant la je me retrouve avec 5 à 7 fonctions, pour chaque shader à utiliser, qui font que mes classes deviennent au final denses, difficiles à lire et que je sens bien que je copie/colle trop.
Je ne sais pas comment m'en sortir élégamment.

Comment faites vous pour gérer de nombreux shaders ? VAO ? VBO ?
J'aime pas les spaghettis.

Merci par avance !

[Mat.M]

Autant avant mes classes d’affichage avaient peu de fonction, autant la je me retrouve avec 5 à 7 fonctions, pour chaque shader à utiliser, qui font que mes classes deviennent au final denses, difficiles à lire et que je sens bien que je copie/colle trop.

est-ce que tu utilises l'héritage, ne serait-ce qu'un minimum ?
L'héritage ça permet d'éviter les copier-coller notamment.
Si tu fais hériter une méthode d'une classe grâce à l'héritage pas besoin de redéfinir les méthodes de la classe de base c'est fait pour ça

[tickyletroll]

Merci Mat.M pour ta rapide réponse.
Alors oui, j'ai été formé à penser en orienté objet.

Mais la, en OpenGL je bloque. En fait j'ai pas d'idées de comment faire.
Je n'ai pas posté de code car je ne veux pas qu'on me fasse, je veux juste savoir comment faire, et je ferai le reste.

Si je regarde 3 fonctions de tracés dans une de mes classes, je vois ceci :

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
 
void App::drawFirstLayer()
{
	glDisable(GL_BLEND);
	shaderLayer->use();
	glBindVertexArray(vaoLayer);
	glDrawArrays(GL_TRIANGLE_STRIP,0,4);
	glUseProgram(0);
}
 
void App::drawViewportShape()
{
	glDisable(GL_BLEND);
	glBlendFunc(GL_ONE, GL_ONE);
 
	shaderViewportShape->use();
 
	glActiveTexture(GL_TEXTURE0);
	glBindTexture(GL_TEXTURE_2D, texViewportShape->getID());
	glUniform1i(ViewportShapeTex,0);
 
	glBindVertexArray(vaoViewportShape);
	glDrawArrays(GL_TRIANGLE_STRIP,0,4);
	glUseProgram(0);
}
 
void App::drawColorInverse()
{
	glEnable(GL_BLEND);
	glBlendFunc(GL_ONE_MINUS_DST_COLOR, GL_ZERO);
 
	shaderColorInverse->use();
	glUniform1i(ViewportShapeTex,0);
 
	glBindVertexArray(vaoViewportShape);
	glDrawArrays(GL_TRIANGLE_STRIP,0,4);
	glUseProgram(0);
}

Je suis embêté de voir ces trois fonctions similaires. D'où ma requête.

[dragonjoker59]

Ce que je vais dire relève de mon expérience personnelle, et de ce que je dois faire pour passer mon moteur sous Vulkan.
Dans Vulkan, tu as un VkPipeline, qui contient en gros tous les états de rendu (tout ce qui se fait avec glEnable/glDisable), le viewport, le shader program, et encore plus...
Le truc, c'est qu'une fois créé, un pipeline est immuable, il n'y a plus moyen de le changer.
Dans mon moteur, comme dans le code que tu as, tout était changé à la volée, et au niveau du GPU, on ne peut pas faire pire.
Au final, j'implémente cette notion de pipeline immuable, et ça apporte des gains de performance notables.

Tout ça pour dire, je ne peux que te conseiller de commencer par regrouper les divers états dans des classes qui ne s'occuperont que de gérer ces états (BlendState, RasteriserState, DepthStencilState, ...), puis tu mets ces états dans un pipeline, avec le shader pour ce pipeline.
Ce, afin de pouvoir faire un truc du genre:

Code :

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

1
2
3
4
Pour chaque pipeline
  BindPipeline
    Dessin de tous les objets utilisant ce pipeline
  UnbindPipeline

C'est un changement de longue haleine, mais qui au final va simplifier le boulot, et améliorer les performances de rendu.

[tickyletroll]

Je sais alors ce qu'il me reste à faire.

Merci !