Hi Everybody,

I'm in a long journey of implementing deferred shading. I've got a clear idea of the algorithm, but have some troubles reconstructing object position. I've followed this article http://mynameismjp.wordpress.com/2009/03/10/reconstructing-position-from-depth/ but still easily get lots. There are too many uncertainties. So I want to go over it step by step and make that I did not make any mistakes in previous steps.


Storing the depth into a texture:


// Depth Pass Vertex Shader

varying float depth;
void main (void)
{
gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;
vec4 pos = gl_ModelViewMatrix * gl_Vertex;
depth = pos.z;
}



// Depth Pass Fragment Shader
varying float depth;
uniform float FarClipPlane;
void main (void)
{
float d = - depth / FarClipPlane;
gl_FragColor.r = d;
}


My understanding of this is that I do store the liner depth value into the texture. Is that correct?

Thank you,
Ruben


Also, I'm easily getting lost when it gets to the perspective division. Can somebody suggest some article where i can learn about it.

Yes, this is correct, but you should move the division into the vertex shader.

varying float depth;
uniform float FarClipPlane;
void main (void)
{
gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;
vec4 pos = gl_ModelViewMatrix * gl_Vertex;
depth = -pos.z / FarClipPlane;
}

// Depth Pass Fragment Shader
varying float depth;
void main (void)
{
gl_FragColor.r = depth;
}

And remember, that holding the depth in a single component of 8bit or 16bit will introduce artifacts.

Hi Everybody,

I'm in a long journey of implementing deferred shading. I've got a clear idea of the algorithm, but have some troubles reconstructing object position. I've followed this article http://mynameismjp.w...ion-from-depth/ but still easily get lots. There are too many uncertainties. So I want to go over it step by step and make that I did not make any mistakes in previous steps.


Storing the depth into a texture:


// Depth Pass Vertex Shader

varying float depth;
void main (void)
{
gl_Position = gl_ProjectionMatrix * gl_ModelViewMatrix * gl_Vertex;
vec4 pos = gl_ModelViewMatrix * gl_Vertex;
depth = pos.z;
}



// Depth Pass Fragment Shader
varying float depth;
uniform float FarClipPlane;
void main (void)
{
float d = - depth / FarClipPlane;
gl_FragColor.r = d;
}


My understanding of this is that I do store the liner depth value into the texture. Is that correct?

Thank you,
Ruben


Also, I'm easily getting lost when it gets to the perspective division. Can somebody suggest some article where i can learn about it.

Ashaman73 is correct, however you seem to be having trouble with the theory itself.
before reading take a look at this:
http://mynameismjp.wordpress.com/2010/09/05/position-from-depth-3/
namely method #2

Ok so you store the depth like this:

[vertex shader]

varying float depth;
const float far_plane_distance = 1000.0f; //far plane is at -1000

[...]

//transform the input vertex to view (or eye) space
vec4 viewspace_position = modelview_matrix * input_vertex;

//this is not perspective division but scaling the depth value.
//initially you'd have depth values in the range [-near ... -far distance]
//but you have to linearize them, so that you can get more
//precision
//this is why you divide by the far plane distance
//and you divide by the negative one, so that you can
//check the result in the texture
depth = viewspace_position.z / -far_plane_distance;

[pixel shader]

varying float depth;
out vec4 out_depth;

[...]

//store the depth into the R channel of the texture
//assuming you chose a R16F or R31F format
out_depth.x = depth;



and retrieve (decode) the depth like this:

[vertex shader]

varying vec4 viewspace_position;
varying vec2 texture_coordinates;

[...]

//store the view space position of the far plane
//this gets interpolated as you could see in the mjp drawing
viewspace_position = modelview_matrix * input_vertex;
texture_coordinates = input_texture_coordinates;

[pixel shader]

varying vec4 viewspace_position;
varying vec2 texture_coordinates;
uniform sampler2D depth_texture;
const float far_plane_distance = 1000.0f;

[...]

//sample depth from the texture's R channel
//this will be in range [0 ... 1]
float linear_depth = texture(depth_texture, texture_coordinates).x;

//you have to construct the view vector at the extrapolated viewspace position
//and scale it by the far / z, but this is unnecessary if you use the far plane as the input viewspace position
//since the division will give you 1
//the z coordinate will be the far distance (negative, since we're in viewspace)
vec3 view_vector = vec3(viewspace_position.xy * (-far_plane_distance / viewspace_position.z), -far_plane_distance);

//scaling the view vector with the linear depth will give the true viewspace position
vec3 reconstructed_viewspace_position = view_vector * linear_depth;



hope this helped I had trouble with reconstructing position so search for it on gamedev.

Yes, this is correct, but you should move the division into the vertex shader.

Could you please explain what would be the difference of doing that in a vertex vs pixel shaders. Except the performance difference, aren't the numbers supposed to be same?

And remember, that holding the depth in a single component of 8bit or 16bit will introduce artifacts.

I will try to encode it into 3 or 4 8bit components. You already gave the idea how to do that in another thread.

Ashaman73 is correct, however you seem to be having trouble with the theory itself.
before reading take a look at this:
http://mynameismjp.w...n-from-depth-3/
namely method #2

Ok so you store the depth like this:

hope this helped I had trouble with reconstructing position so search for it on gamedev.

I've read those lots of times but its very hard to understand the entire thing at once. I need to do it step-by-step.
Yours3!f, in one of the methods in the article frustum corner positions are used to reconstruct the position. I guess
it was used for world space position reconstruction, and you're reconstructing into view space, right?

So, if I go with the same approach, how should I perform lighting calculation? What would be the positions
of the camera and lights. Also regarding the normals, should that be translated? My understand is that in
view space:

camera_position_view_space = [0, 0, 0];
light_position_view_space = view_matrix * light_position_world_space;
light_direction_view_space = view_matrix * light_direction_world_space;
normal_view_space = normalize(view_matrix * normal_world_space);


Ashaman73, Yours3!f, you guys help me a lot with this! I need some time to digest it.

[quote name='Yours3!f' timestamp='1336564479' post='4938643']
Ashaman73 is correct, however you seem to be having trouble with the theory itself.
before reading take a look at this:
http://mynameismjp.w...n-from-depth-3/
namely method #2

Ok so you store the depth like this:

hope this helped I had trouble with reconstructing position so search for it on gamedev.

I've read those lots of times but its very hard to understand the entire thing at once. I need to do it step-by-step.
Yours3!f, in one of the methods in the article frustum corner positions are used to reconstruct the position. I guess
it was used for world space position reconstruction, and you're reconstructing into view space, right?

So, if I go with the same approach, how should I perform lighting calculation? What would be the positions
of the camera and lights. Also regarding the normals, should that be translated? My understand is that in
view space:

camera_position_view_space = [0, 0, 0];
light_position_view_space = view_matrix * light_position_world_space;
light_direction_view_space = view_matrix * light_direction_world_space;
normal_view_space = normalize(view_matrix * normal_world_space);


Ashaman73, Yours3!f, you guys help me a lot with this! I need some time to digest it.
[/quote]

yep I describe the frustum corner method. I made it work in view space, but mjp describes a world space method as well. (so I guess the frustum one doesn't work in worldspace)
The lighting calculation is independent from what space you're using. Or at least I've seen lighting in world space, view space, tangent space... The basic thing is that you have to be consistent. If you're performing lighting in view space then you need to transform everything into view space. Normals, position, light position are the needed parameters. You should also read the lighthouse3d articles about lighting. If you wanna go the deferred way then I think viewspace suits your needs best.
To you viewspace, you just have to export your meshes to object space. The you can use your modelview matrix to transform them instantly into view space, and then the projection matrix to transform them to projection space.

for the normals you need to use a so called "normal matrix". This matrix is either the upper left 3x3 part of your view matrix, or the transpose of the inverse of your modelview matrix. You probably want to do this on the cpu side. In glsl:

mat3 normal_matrix_1 = mat3(view_matrix);

mat3 normal_matrix_2 = mat3(transpose(inverse(modelview_matrix)));


yep I describe the frustum corner method. I made it work in view space, but mjp describes a world space method as well. (so I guess the frustum one doesn't work in worldspace)

OMG!! I didn't know those were your articles! Those are awesome! I honestly take my hat off for you!

Just want to confirm with you that with your method#2 I'd not need to deal with frustum corners, right? Multiplication of view_vector and linear_depth would give me reconstructed position in the view space.

Also, could you suggest some article where I can learn more about view/projection spaces in order to get a better idea how it works and why is the depth projected into [-far, -near] range.

Thank you!
Ruben

[quote name='Yours3!f' timestamp='1336662686' post='4939004']
yep I describe the frustum corner method. I made it work in view space, but mjp describes a world space method as well. (so I guess the frustum one doesn't work in worldspace)

OMG!! I didn't know those were your articles! Those are awesome! I honestly take my hat off for you!

Just want to confirm with you that with your method#2 I'd not need to deal with frustum corners, right? Multiplication of view_vector and linear_depth would give me reconstructed position in the view space.

Also, could you suggest some article where I can learn more about view/projection spaces in order to get a better idea how it works and why is the depth projected into [-far, -near] range.

Thank you!
Ruben
[/quote]

ummm... I think you misunderstood me. That is not my article. I just implemented it. That article belongs to MJP: http://www.gamedev.n...ser/118414-mjp/

you DO have to deal with it. That is the basis of the reconstruction. If you read the mjp article #3 (back in the habit) then you'll understand it. View vector is actually constructed from the coordinates of the far plane of the view frustum, that were interpolated along the whole screen.

just a couple of articles:
http://www.songho.ca..._transform.html
http://www.songho.ca...tionmatrix.html
http://www.songho.ca...omogeneous.html
http://www.glprogram.../chapter03.html
http://www.glprogramming.com/red/ ---> this is a whole book (although it is for OGL 1.1, some parts are still relevant like the article above)

this is an awesome book about the maths behind all this:
http://www.amazon.co...y/dp/1556229119
despite it describes maths in a left-handed coordinate system, I'm sure that after reading this you'll be able to apply it in the OpenGL world, the right-handed cooridnate system.

Yours3!f, thank you so much for this! I really appreciate.
I need few days to digest and try it out. I will get back to this thread with my results!