Compilation shader dans boucle de rendu

Version imprimable

26/10/2016, 16h01
Nooay

Compilation shader dans boucle de rendu

Bonjour,

En openGL3.3, lorsque je compile mon shader à l'intérieur de la boucle de rendu (qui contient le drawArrays et le swapbuffers), l'image retournée contient seulement la clearcolor mais pas l'objet à rendre.
Par contre, en remettant la compilation de mon shader à l'extérieur de la boucle, mon objet est correctement affiché.

Avec la compilation du shader à l'extérieur de la passe de rendu, j'ai remarqué qu'à la fin de la première passe de rendu, juste après le swapbuffer, mon image
contient uniquement la clearcolor, j'imagine que tout cela est en lien et j'aimerais en savoir plus ...

Merci à vous.
26/10/2016, 16h46
dragonjoker59

Salut!

Tu peux nous montrer cette boucle de rendu?

La boucle principale :

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
 
 
// Placement camera et affichage des elements de la scene
void display() {
 
	glClearColor(0.0f, 0.0f, 0.2f, 0.0f);
 
	while (!glfwWindowShouldClose(window) && (glfwGetKey(window, GLFW_KEY_ESCAPE) != GLFW_PRESS)) {
 
		glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
 
		viewMatrix = lookAt(cam.getVPosition(), cam.getVTarget(), cam.getVUp());
 
		// Compilation shader
		GLuint idshader = loadShaders("shaders/basicColorVertexShader.txt", "shaders/basicColorFragmentShader.txt");
 
		glutils::dessinerObjet(GL_LINES, glutils::repereVertexTab, glutils::repereTabSize, glutils::repereColorsTab, glutils::repereTabSize, idshader, &modelMatrix, &viewMatrix, &projectionMatrix);
 
                glDeleteProgram(idshader);
 
		glfwSwapBuffers(window);
 
		// Execution des callbacks en attente
		glfwPollEvents();
	}
}

La fonction de dessin:

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
 
 
void dessinerObjet(GLenum mode, float vertexTab[], int vertexTabSize, float colorTab[], int colorTabSize, GLuint shaderId, mat4 * modelMatrix, mat4 * viewMatrix, mat4 * projectionMatrix) {
 
		//Vbo vertex
		GLuint idVertexVbo;
		glGenBuffers(1, &idVertexVbo);
		glBindBuffer(GL_ARRAY_BUFFER, idVertexVbo);
		glBufferData(GL_ARRAY_BUFFER, vertexTabSize * sizeof(float), vertexTab, GL_STATIC_DRAW);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
 
		//Vbo color
		GLuint idColorVbo;
		glGenBuffers(1, &idColorVbo);
		glBindBuffer(GL_ARRAY_BUFFER, idColorVbo);
		glBufferData(GL_ARRAY_BUFFER, colorTabSize * sizeof(float), colorTab, GL_STATIC_DRAW);
		glBindBuffer(GL_ARRAY_BUFFER, 0);
 
		// Programmation Vao
		GLuint idVao;
		glGenVertexArrays(1, &idVao);
		glBindVertexArray(idVao);
 
			// pointeur tableau vertex
			glBindBuffer(GL_ARRAY_BUFFER, idVertexVbo);
			glVertexAttribPointer(0, 3, GL_FLOAT, GL_FALSE, 0, 0);
			glEnableVertexAttribArray(0);
			glBindBuffer(GL_ARRAY_BUFFER, 0);
 
			// pointeur tableau couleur
			glBindBuffer(GL_ARRAY_BUFFER, idColorVbo);
			glVertexAttribPointer(1, 3, GL_FLOAT, GL_FALSE, 0, 0);
			glEnableVertexAttribArray(1);
			glBindBuffer(GL_ARRAY_BUFFER, 0);
 
		glBindVertexArray(0);
 
		// Localisation des variables uniformes du shader
		GLuint idModelMatrix = glGetUniformLocation(shaderId, "modelMatrix");
		GLuint idViewMatrix = glGetUniformLocation(shaderId, "viewMatrix");
		GLuint idProjectionMatrix = glGetUniformLocation(shaderId, "projectionMatrix");
		// Envoi des matrices aux variables uniformes du shader
		glUniformMatrix4fv(idModelMatrix, 1, GL_FALSE, &(*modelMatrix)[0][0]);
		glUniformMatrix4fv(idViewMatrix, 1, GL_FALSE, &(*viewMatrix)[0][0]);
		glUniformMatrix4fv(idProjectionMatrix, 1, GL_FALSE, &(*projectionMatrix)[0][0]);
 
		// Execution Vao
		glBindVertexArray(idVao);
		glUseProgram(shaderId);
		glDrawArrays(mode, 0, 6);
		glBindVertexArray(0);
 
		// Suppresion Vao et Vbo
		glDisableVertexAttribArray(0);
		glDeleteVertexArrays(1, &idVao);
		glDeleteBuffers(1, &idVertexVbo);
		glDeleteBuffers(1, &idColorVbo);
		//glDeleteProgram(idShader);
	}

26/10/2016, 22h15
dragonjoker59

Alors, il faut commencer par sortir de dessinerObjet() la création et l'initialisation des VBO et VAO, elle se fait une fois, et une seule.
Pareil, j'aimerais savoir pourquoi tu tiens à initialiser tes shaders à chaque frame?
28/10/2016, 19h32
Nooay

Ok je note je te remercie,
simplement dans un but de compréhension générale d'openGL3.3,
est-il possible d'intégrer la compilation du shader à chaque frame ? et sinon pourquoi ?
28/10/2016, 23h38
monwarez

J'ai envie de dire que ça ne devrait pas être permis de compiler le shader à chaque frame, une seule fois suffit, le processeur graphique ne va pas changer d'une frame à l'autre. Par ailleurs il serrait utile de vérifier s'il n'y as pas d'erreur lors de la compilation/linkage, j'imagine qu'au bout d'un certain nombre d'itération le driver arrêtera de compiler.
PS:
J'ai fais quelques recherches, la compilation du shader se fait de manière asynchrone (la synchronisation peut être forcée lorsque l'on vérifie s'il y a eu des erreurs lors de la compilation).
Donc ce qui peut se passer : le shader n'as pas finis d'être compilé, et un appel à glUseProgram est fait sur un objet pas encore valide, donc cela revient à faire un glUseProgram(0), et ceci à chaque frame.
Je cite : OpenGL superbible sixth edition:

Citation:

While you might not think that shader compilation performance can affect the running time of your application (after all, you don't compile shader in the middle of rendering ... do you ?), it actually does impact the user's experience when they run your application.
02/11/2016, 12h41
Nooay

C'est bon à savoir, en particulier pour les shaders importants.

Merci pour ta recherche !