Getting the true z value from the depth buffer

by

From http://web.archive.org/web/20130416194336/http://olivers.posterous.com/linear-depth-in-glsl-for-real

// == Post-process frag shader ===========================================
uniform sampler2D depthBuffTex;
uniform float zNear;
uniform float zFar;
varying vec2 vTexCoord;
void main(void)
{
    float z_b = texture2D(depthBuffTex, vTexCoord).x;
    float z_n = 2.0 * z_b - 1.0;
    float z_e = 2.0 * zNear * zFar / (zFar + zNear - z_n * (zFar - zNear));
}

[edit] So here’s the explanation (with 2 mistakes, see Christian’s comment below) :

An OpenGL perspective matrix looks like this : from songho.ca

When you multiply this matrix by an homogeneous point [x,y,z,1], it gives you: [don’t care, don’t care, Az+B, -z] (with A and B the 2 big components in the matrix).

OpenGl next does the perspective division: it divides this vector by its w component. This operation is not done in shaders (except special cases like shadowmapping) but in hardware; you can’t control it. w = -z, so the Z value becomes -A/z -B.

We are now in Normalized Device Coordinates. The Z value is between 0 and 1. For some stupid reason, OpenGL requires that it should be moved to the [-1,1] range (just like x and y). A scaling and offset is applied.

This final value is then stored in the buffer.

The above code does the exact opposite :

  • z_b is the raw value stored in the buffer
  • z_n linearly transforms z_b from [-1,1] to [0,1]
  • z_e is the same formula as z_n=-A/z_e -B, but solved for z_e instead. It’s equivalent to z_e = -A / (z_n+B). A and B should be computed on the CPU and sent as uniforms, btw.

The opposite function is :

varying float depth; // Linear depth, in world units
void main(void)
{
    float A = gl_ProjectionMatrix[2].z;
    float B = gl_ProjectionMatrix[3].z;
    gl_FragDepth  = 0.5*(-A*depth + B) / depth + 0.5;
}

More Related Contents:

  1. How to render depth linearly in modern OpenGL with gl_FragCoord.z in fragment shader?
  2. how should i handle (morphing) 4D objects in opengl? [closed]
  3. How to use GLUT/OpenGL to render to a file?
  4. How to implement 2D raycasting light effect in GLSL
  5. Do conditional statements slow down shaders?
  6. How exactly does OpenGL do perspectively correct linear interpolation?
  7. In a fragment shader, why can’t I use a flat input integer to index a uniform array of sampler2D?
  8. Why does OpenGL not support multiple index buffering?
  9. What is state-of-the-art for text rendering in OpenGL as of version 4.1? [closed]
  10. What does glLoadIdentity() do in OpenGL?
  11. glLineStipple deprecated in OpenGL 3.1
  12. OpenGL: scale then translate? and how?
  13. Frequency of shader invocations in rendering commands
  14. What are shaders in OpenGL and what do we need them for? [closed]
  15. Convert Quaternion rotation to rotation matrix?
  16. OpenGL – How to create Order Independent transparency?
  17. Convert floating-point numbers to decimal digits in GLSL
  18. OpenGL 3D-raypicking with high poly meshes
  19. What are the Attribute locations for fixed function pipeline in OpenGL 4.0++ core profile?
  20. What is the proper way to modify OpenGL vertex buffer?
  21. Interpolating between rotation matrices
  22. How to calculate Tangent and Binormal?
  23. Generating a normal map from a height map?
  24. I have an OpenGL Tessellated Sphere and I want to cut a cylindrical hole in it
  25. Opengl pixel perfect 2D drawing
  26. Edges on polygon outlines not always correct
  27. Initializing OpenGL without GLUT
  28. Multiple textures in GLSL – only one works
  29. GLSL, semaphores?
  30. How to cast int to const GLvoid*?

Leave a Comment