Deferred Shading ne fonctionne pas sur Nvidia

**herotom99** · 22/08/2016, 23h07

Bonsoir,

BUT:
Je travail actuellement sur mon moteur 3D qui supporte à la fois du Forward Shading et du Deferred Shading.
Problème:
J'ai deux pc sur lesquels j'effectue des testes:
-PC Portable avec un GPU Intel
-PC "fix" avec une GPU Nvidia GTX770 (driver: 372.54)
Le rendu en Forward Shading fonctionne sur les deux PC. Cependant le rendu en Deferred Shading ne fonctionne que sur le PC portable
et OpenGL (glGetError()) ne me donne aucune erreur.
La seul différence majeur entre ces deux techniques est l'utilisation des FBO donc je pense que le problème vient de là.

Initialisation du GBuffer:

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
39
40
41
42
43
44
45
46
47
48
49
50
//Génération des buffers
	glGenFramebuffers(1, &m_fbo);
	glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
	glFramebufferParameteri(GL_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_WIDTH, m_width);
	glFramebufferParameteri(GL_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_HEIGHT, m_height);
	glFramebufferParameteri(GL_FRAMEBUFFER, GL_FRAMEBUFFER_DEFAULT_SAMPLES, 0);
 
	//Générer les textures et les binds avec leur buffers
	//Diffuse
	glGenTextures(1, &m_textureDiffuse);
	glBindTexture(GL_TEXTURE_2D, m_textureDiffuse);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA, m_width, m_height, 0, GL_RGBA, GL_UNSIGNED_BYTE, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT0, GL_TEXTURE_2D, m_textureDiffuse, 0);
	//Position
	glGenTextures(1, &m_texturePosition);
	glBindTexture(GL_TEXTURE_2D, m_texturePosition);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA32F, m_width, m_height, 0, GL_RGBA, GL_FLOAT, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT1, GL_TEXTURE_2D, m_texturePosition, 0);
	//Normal
	glGenTextures(1, &m_textureNormal);
	glBindTexture(GL_TEXTURE_2D, m_textureNormal);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_RGBA16F, m_width, m_height, 0, GL_RGBA, GL_FLOAT, NULL);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_COLOR_ATTACHMENT2, GL_TEXTURE_2D, m_textureNormal, 0);
 
	//Depth
	glGenTextures(1, &m_depthtexture);
	glBindTexture(GL_TEXTURE_2D, m_depthtexture);
	glTexImage2D(GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, m_width, m_height, 0, GL_DEPTH_COMPONENT, GL_FLOAT, 0);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_LINEAR);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP_TO_EDGE);
	glTexParameteri(GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP_TO_EDGE);
	glFramebufferTexture2D(GL_FRAMEBUFFER, GL_DEPTH_ATTACHMENT, GL_TEXTURE_2D, m_depthtexture, 0);
 
	if (glCheckFramebufferStatus(GL_FRAMEBUFFER) != GL_FRAMEBUFFER_COMPLETE)
		throw new std::exception("ERROR: Can't initialize the GBuffer");
 
	glBindFramebuffer(GL_FRAMEBUFFER, 0);

Geometry Pass:

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
glBindFramebuffer(GL_FRAMEBUFFER, m_fbo);
			glEnable(GL_TEXTURE_2D);
			glEnable(GL_DEPTH_TEST);
			glDepthFunc(GL_LESS);
 
			glClear(GL_COLOR_BUFFER_BIT | GL_DEPTH_BUFFER_BIT);
			glClearColor(0.0f, 0.0f, 0.0f, 1.0f);
 
			GLenum buffers[] = { GL_COLOR_ATTACHMENT0, GL_COLOR_ATTACHMENT1, GL_COLOR_ATTACHMENT2 };
			glDrawBuffers(3, buffers);
 
			Mesh* mesh = m_staticmesh[i]->GetMesh();
			glm::mat4 trans = m_staticmesh[i]->GetTransform();
 
			glUniformMatrix4fv(glGetUniformLocation(DS_GeometryShader, "uModel"), 1, GL_FALSE, glm::value_ptr(trans));
			glUniformMatrix4fv(glGetUniformLocation(DS_GeometryShader, "uView"), 1, GL_FALSE, glm::value_ptr(m_activecamera->ViewMatrix()));
			glUniformMatrix4fv(glGetUniformLocation(DS_GeometryShader, "uProjection"), 1, GL_FALSE, glm::value_ptr(m_activecamera->ProjectionMatrix()));
 
			Material* material = m_staticmesh[i]->GetMaterial();
 
			//Use DiffuseMap or BaseColor
			if (material->useDiffuse && material->diffuse != NULL)
			{
				glUniform1i(glGetUniformLocation(DS_GeometryShader, "uUseDiffuseMap"), true);
 
				glActiveTexture(GL_TEXTURE0);
				glBindTexture(GL_TEXTURE_2D, material->diffuse->GetID());
				glUniform1i(glGetUniformLocation(DS_GeometryShader, "uDiffuseMap"), /*GL_TEXTURE*/ 0);
			}
			else
			{
				glUniform1i(glGetUniformLocation(DS_GeometryShader, "uUseDiffuseMap"), false);
				glUniform4fv(glGetUniformLocation(DS_GeometryShader, "uBaseColor"), 1, glm::value_ptr(material->baseColor));
			}
 
			glBindVertexArray(mesh->GetVAO());
			glDrawArrays(GL_TRIANGLES, 0, mesh->vertices.size());
			glBindVertexArray(0);

Shaders:
Geometry.fragment:

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
#version 400 core
 
layout(location = 0) out vec4 out_diffuse;
layout(location = 1) out vec4 out_position;
layout(location = 2) out vec4 out_normal;
 
in vec4 fFragPos;
in vec2 fUV;
in vec3 fNormal;
 
uniform bool uUseDiffuseMap;
uniform vec4 uBaseColor;
 
uniform sampler2D uDiffuseMap;
 
void main()
{
	if(uUseDiffuseMap)
	{
		out_diffuse = texture(uDiffuseMap, fUV);
	}
	else
	{
		out_diffuse = uBaseColor;
	}
 
	out_position = fFragPos;
	out_normal = vec4(fNormal.xyz, 1);
}

Je vous ai mis l'essentiel, si vous avez besoin de plus dites le moi

Merci !

**dragonjoker59** · 23/08/2016, 11h31

Salut!

As-tu pu vérifier que les différentes textures de la geometry pass sont écrites? (Avec des blits en lieu et place de la light pass, par exemple)

**LittleWhite** · 23/08/2016, 11h59

Bonjour,

Faites-vous un appel à glGetError() à chaque appel OpenGL ? (je tiens à rappeler qu'il est préférable d'utiliser l'extension KHR_debug, maintenant).
Avez-vous essayé gDEBugger pour mieux comprendre le problème ? (vérification des tampons).
Quel est votre rendu sur les deux machines ?

**herotom99** · 23/08/2016, 14h36

Je viens de debugger le programme avec gDEBugger et les textures de la geometry pass sont noirs donc le problème vient bien de l'écriture des textures. D'ailleurs cet outil est vraiment génial !

**herotom99** · 25/08/2016, 00h18

J'ai repassé en vue tout mon code 3 fois et j'ai rien trouvé d'anormal ... Ce que je ne comprend pas c'est surtout le fait que cela fonctionne parfaitement sur un pc et pas sur l'autre !
D'ailleurs j'ai testé le programme sur une carte AMD, même problème (black-screen) ... à croire que mon programme est conçu pour des processeur intel.
Lorsque je vérifie les textures avec gDEBugger, elle sont toutes noirs. Et en changeant la couleur du glClear en rouge par exemple, les textures sont bien rouges donc c'est pas un problème de binding de texture au fbo.

**LittleWhite** · 21/11/2016, 22h35

Cela me semble être un binding qui n'est pas désactivé à la fin de son utilisation ?
On peut faire du debogage des FBO avec glBlitFramebuffer

**herotom99** · 22/11/2016, 18h29

Je ne suis pas retourné sur ce post depuis longtemps, entre temps j'ai trouvé mon erreur. Le problème venait du fait que dans le vertex shader (de la geometry pass), je n'utilisais pas gl_Position. Une erreur simple mais importante

. Cela fonctionnait sans chez Intel et c'est plutôt bizarre, je n'ai pas trouvé plus d'informations à propos.

**LittleWhite** · 22/11/2016, 20h30

Hum. Chaque implémentation de la norme OpenGL diffère. Voici un excellent exemple. Du coup, il ne faut pas être étonné que telle ou telle chose diffère. Et je dois dire, vous n'avez encore rien vu

.

**dragonjoker59** · 23/11/2016, 12h10

En 10 ans, j'ai écrit mon premier code spécifique à une implémentation il y a 15 jours, et j'ai remarqué que le plus important se tient en 2 points:
- Coller à la spécification
- Regarder les retours des extensions de débogage, et fixer les warnings qui y sont reportés.

Ensuite pour gl_Position, en OpenGL 3.x tu dois avoir eu une erreur de link, si tu ne l'utilises pas dans ton vertex shader et que tu as un fragment shader (ou un geometry shader utilisant gl_In).
De plus, écrire dans gl_Position est obligatoire si tu utilises une version de GLSL inférieure ou égale à 140.

Deferred Shading ne fonctionne pas sur Nvidia [OpenGL 4.x]

OpenGL

Discussions similaires

Partager

Partager