How to render depth linearly in modern OpenGL with gl_FragCoord.z in fragment shader?

by

but I still don’t know whether or not the gl_FragCoord.z is linear.

Whether gl_FragCoord.z is linear or not depends on, the projection matrix.
While for Orthographic Projection gl_FragCoord.z is linear, for Perspective Projection it is not linear.

In general, the depth (gl_FragCoord.z and gl_FragDepth) is calculated as follows (see GLSL gl_FragCoord.z Calculation and Setting gl_FragDepth):

float ndc_depth = clip_space_pos.z / clip_space_pos.w;
float depth = (((farZ-nearZ) * ndc_depth) + nearZ + farZ) / 2.0;

The projection matrix describes the mapping from 3D points of a scene, to 2D points of the viewport. It transforms from eye space to the clip space, and the coordinates in the clip space are transformed to the normalized device coordinates (NDC) by dividing with the w component of the clip coordinates

Orthographic Projection

At Orthographic Projection the coordinates in the eye space are linearly mapped to normalized device coordinates.

Orthographic Projection

Orthographic Projection Matrix:

r = right, l = left, b = bottom, t = top, n = near, f = far 

2/(r-l)         0               0               0
0               2/(t-b)         0               0
0               0               -2/(f-n)        0
-(r+l)/(r-l)    -(t+b)/(t-b)    -(f+n)/(f-n)    1

At Orthographic Projection, the Z component is calculated by the linear function:

z_ndc = z_eye * -2/(f-n) - (f+n)/(f-n)

Orthographic Z function

Perspective Projection

At Perspective Projection the projection matrix describes the mapping from 3D points in the world as they are seen from of a pinhole camera, to 2D points of the viewport.
The eye space coordinates in the camera frustum (a truncated pyramid) are mapped to a cube (the normalized device coordinates).

Perspective Projection

Perspective Projection Matrix:

r = right, l = left, b = bottom, t = top, n = near, f = far

2*n/(r-l)      0              0               0
0              2*n/(t-b)      0               0
(r+l)/(r-l)    (t+b)/(t-b)    -(f+n)/(f-n)    -1    
0              0              -2*f*n/(f-n)    0

At Perspective Projection, the Z component is calculated by the rational function:

z_ndc = ( -z_eye * (f+n)/(f-n) - 2*f*n/(f-n) ) / -z_eye

Perspective Z function

Depth buffer

Since the normalized device coordinates are in range (-1,-1,-1) to (1,1,1) the Z-coordinate has to be mapped to the depth buffer range [0,1]:

depth = (z_ndc + 1) / 2

Then if it is not linear, how to linearize it in the world space?

To convert form the depth of the depth buffer to the original Z-coordinate, the projection (Orthographic or Perspective), and the near plane and far plane has to be known.

Orthographic Projection

n = near, f = far

z_eye = depth * (f-n) + n;

Perspective Projection

n = near, f = far

z_ndc = 2.0 * depth - 1.0;
z_eye = 2.0 * n * f / (f + n - z_ndc * (f - n));

If the perspective projection matrix is known this can be done as follows:

A = prj_mat[2][2]
B = prj_mat[3][2]
z_eye = B / (A + z_ndc)

See also the answer to

How to recover view space position given view space depth value and ndc xy

More Related Contents:

  1. Do conditional statements slow down shaders?
  2. In a fragment shader, why can’t I use a flat input integer to index a uniform array of sampler2D?
  3. What is state-of-the-art for text rendering in OpenGL as of version 4.1? [closed]
  4. glLineStipple deprecated in OpenGL 3.1
  5. Frequency of shader invocations in rendering commands
  6. Should I ever use a `vec3` inside of a uniform buffer or shader storage buffer object?
  7. Convert floating-point numbers to decimal digits in GLSL
  8. Why transform normals with the transpose of the inverse of the modelview matrix?
  9. How to implement 2D raycasting light effect in GLSL
  10. GLSL fixed function fragment program replacement
  11. Passing a list of values to fragment shader
  12. Getting the true z value from the depth buffer
  13. How to calculate Tangent and Binormal?
  14. How to debug a GLSL shader?
  15. Why does GL divide `gl_Position` by W for you rather than letting you do it yourself?
  16. How to use Pivot Point in Transformations
  17. How to Using the #include in glsl support ARB_shading_language_include
  18. From RGB to HSV in OpenGL GLSL
  19. How do you get the modelview and projection matrices in OpenGL?
  20. Multiple textures in GLSL – only one works
  21. GLSL, semaphores?
  22. GLSL – Using custom output attribute instead of gl_Position
  23. What are shaders in OpenGL and what do we need them for? [closed]
  24. ray and ellipsoid intersection accuracy improvement
  25. OpenGL 3D-raypicking with high poly meshes
  26. Normal mapping gone horribly wrong
  27. What are the Attribute locations for fixed function pipeline in OpenGL 4.0++ core profile?
  28. Why is the sprite not rendering in OpenGL?
  29. Interpolating between rotation matrices
  30. Current state and solutions for OpenGL over Windows Remote [closed]

Leave a Comment