FBO: Depth Texture vide

Bonjours à tous

Je suis enfin en train de bossé sur mon système HDR, avec flou de profondeur, seulement, le souci est que la depth texture avec la quel j'ai rendu ma scène ne semble pas être remplis. Quand je dessine directement à l'écran la texture du fbo, tout fonctionne : la scène est affiché. Mais quand je veux dessiner la depth texture pour vérifié ses valeurs, c'est tout noir. or j'ai besoin que la depth texture fonctionne pour appliqué mon flou gaussien sur les objet lointain.

CODE GLSL:

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
 
 
/*
le shader se compile bien et les "uniform's location" son bien récupéré.
*/
 
 
HdrShader.vertex
{
	#version 330
 
	in vec4 Vertex ;
 
	void main ()
	{
		gl_Position = Vertex ;
	}
}
 
HdrShader.fragment
{
	#version 330
	#define GAUSSIAN_COUNT 225
 
	uniform sampler2D PixelBuffer ; // GL_TEXTURE1
	uniform sampler2D DepthBuffer ; // GL_TEXTURE0
	uniform vec2 ResolutionCoefs ;
 
	out vec4 FragColor ;
 
	void main ()
	{
		vec2 ReflectCoord = gl_FragCoord.xy * ResolutionCoefs ;
 
/*
 j'ai retiré tout ce qui est relatif au flou gaussien pour
 vous simplifié la lecture du shader
*/
 
		//FragColor.rgb = texture2D (PixelBuffer, ReflectCoord).rgb;
		FragColor.rgb = texture2D (DepthBuffer, ReflectCoord).rgb;
		FragColor.a = 1.0f ;
	}
}

MA CLASS HDR

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
60
61
62
63
 
class HDR_PROCESSING
{
private:
	// ------------------------------------ SHADER
	class : public shader::classic
	{
	public:
		buffer::location ResolutionCoefs ;
	} Render ;
 
 
        GLuint FramId, TextureId, DepthTextureId ;
	GLuint DepthBuffer ;
 
	vec2f ResolutionCoefs ;
	size2i FramDimension ;
 
public:
	// ------------------------------------ FUNCTION
	void creat (const size2i & NewSize);
 
	// ------------------------------------ DRAWING
	inline void select ()
	{
		glBindFramebuffer (GL_FRAMEBUFFER_EXT, FramId);
	}
 
	inline void unSelect ()
	{
        	glBindFramebuffer (GL_FRAMEBUFFER_EXT, 0);
    	}
 
 
	// ------------------------------------ RENDER
 
	inline void render ()
	{
		glActiveTexture (GL_TEXTURE1);
		glBindTexture (GL_TEXTURE_2D, TextureId);
 
		glActiveTexture (GL_TEXTURE0);
		glBindTexture (GL_TEXTURE_2D, DepthTextureId);
 
		glUseProgram (Render.ProgramId);
 
		glBegin (GL_TRIANGLES);
 
		glVertex2i (-1, 1);
		glVertex2i (1, -1);
		glVertex2i (-1, -1);
 
		glVertex2i (1, -1);
		glVertex2i (-1, 1);
		glVertex2i (1, 1);
 
		glEnd ();
	}
 
 
	// ------------------------------------ IDLE
	HDR_PROCESSING ();
};

CREATION DU FBO

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
// -------------------------------- INIT TEXTURES
	glGenTextures (1, &TextureId);
	glBindTexture (GL_TEXTURE_2D, TextureId);
 
	glTexImage2D (GL_TEXTURE_2D, 0, 4, NewSize.Width, NewSize.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_REPEAT);	
	glTexParameteri (GL_TEXTURE_3D, GL_TEXTURE_WRAP_T, GL_REPEAT);
 
	glGenTextures (1, &DepthTextureId);
	glBindTexture (GL_TEXTURE_2D, DepthTextureId);
 
	glTexImage2D (GL_TEXTURE_2D, 0, GL_DEPTH_COMPONENT, NewSize.Width, NewSize.Height, 0, GL_DEPTH_COMPONENT, GL_UNSIGNED_BYTE, 0);
 
	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_COMPARE_MODE, GL_NONE);
	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MIN_FILTER, GL_NEAREST);
	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_MAG_FILTER, GL_NEAREST);
	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_S, GL_CLAMP);
	glTexParameteri (GL_TEXTURE_2D, GL_TEXTURE_WRAP_T, GL_CLAMP);
 
	// -------------------------------- INIT BUFFER
	glGenFramebuffersEXT (1, &FramId);
	glBindFramebuffer (GL_FRAMEBUFFER_EXT, FramId);
	glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_COLOR_ATTACHMENT0_EXT, GL_TEXTURE_2D, TextureId, 0);
	glFramebufferTexture2DEXT (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_TEXTURE_2D, DepthTextureId, 0);
 
	// -------------------------------- INIT DEPTH TEST
	glGenRenderbuffersEXT (1, &DepthBuffer);
	glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, DepthBuffer);
	glRenderbufferStorageEXT (GL_RENDERBUFFER_EXT, GL_DEPTH_COMPONENT, NewSize.Width, NewSize.Height);
	glFramebufferRenderbufferEXT (GL_FRAMEBUFFER_EXT, GL_DEPTH_ATTACHMENT_EXT, GL_RENDERBUFFER_EXT, DepthBuffer);
 
	glBindFramebuffer (GL_FRAMEBUFFER_EXT, 0);
	glBindRenderbufferEXT (GL_RENDERBUFFER_EXT, DepthBuffer);

RENDU:

Code:

1
2
3
4
5
6
7
 
Hdr.select ();
 
// rendu de la scène
 
Hdr.unSelect ();
Hdr.render ();

En l'attente de votre aide, je vous remercie de votre lecture.

J'ai lu assez vite en diagonale, mais tu sembles utiliser à la fois une texture et un renderbuffer pout ton rendu de profondeur.
Etant donné que tu configure le renderbuffer en dernier, c'est lui qui doit se faire écrire et non ta texture.

J'ai beau inversé les activations voir même ne pas crée le render buffer, ma depth texture reste vide. :cry: Je me demande à la limité, crée une GL_COLOR_ATTACHEMENT1 auquel l'un des canal serai réservé à la profondeur que je remplirai manuellement par les shaders, mais je craint une perte de performance ... qu'en pensez vous ?

Effectivement tu risques de perdre en performance, puisque l'écriture dans une texture/render buffer n'est pas gratuite.

Mais d'un autre coté c'est exactement ce qui est fait quand tu demande à ce que le depth soit écris dans une texture :)
De plus cette technique est régulièrement utilisé (voir deferred shading) et tu peux y stocker d'autres informations que la profondeur intéressante pour appliquer des post-effect.
Peut-être que ta texture t'apparait noir non pas parcequ'il n'y a pas de valeur stocké mais peut-être parceque la valeur est bien trop petite pour affiché une couleur.
Si je me souviens bien le depth stocké est normalisé selon ton zNear et ton zFar. Il y a une opération du genre :
depth = (gl_FragCoord.z - zNear) / zFar
un truc dans le genre, sauf que si ton zFar est très grand alors que les objets que tu dessine son très proche tu ne vera rien, essaye de multiplier ton depth par zFar pour voir si ça change ;)

Et bien, j'ai essayé, mais çà ne fonctionnai pas. Mais de toute façon, j'ai mis un second GL_COLOR_ATTACHMENT avec plusieurs type d'informations dedans dont la profondeur.

Par contre est il possible que le blending de tout les attachement ce fasse juste sur le alpha du premier automatiquement ? çà me permettrai d'utilisé le canal alpha des attachement auxiliaire et appeler donc moins de fois texture2D() dans les shaders.