openGL - converting a non-linear depth buffer to a linear depth buffer

Question

According to the thread on this page, The equation given for calculating the depth buffer:

F_depth = 1/z - 1/n/(1/f - 1/n)   

is non-linear only because of the perspective divide.(Note that this is a combination of from the view-space z coord to window coord directly)

So, as per my understanding:
to convert it to a linear depth buffer, the only thing we would do is to remove the perspective divide(?) and then perform the glDepthRange(a,b) given here.

In that case, the equation would be like this:

z_linear = z_NDC * W_clip = -(f+n)/(f-n)*z_eye + ( 2fn/(f-n) )

and, with depth range transformation:

z_[0,1] = ( z_linear + 1 ) /2
= ( (f+n)*z_eye - 2fn + f - n )/ ( 2(f-n) )

but, in the learnopenGL site for depth testing this is done:

First we transform the depth value to NDC which is not too difficult:

float ndc = depth * 2.0 - 1.0; 

We then take the resulting ndc value and apply the inverse transformation to retrieve its linear depth value:

float linearDepth = (2.0 * near * far) / (far + near - ndc * (far - near)

how is the non-linear to linear depth-buffer being computed?(i.e. equation being formed)?

Answer 1

Using glm in a right handed system I found the following solutions for converting from ndc depth [-1, 1] to eye depth [0-far].

perspective projection:

float screen_to_eye_depth_perspective(float d, float zNear, float zFar)
{
    // [0; 1] -> [-1; 1]
    float depth = d * 2.0 - 1.0;
    return  (2.0 * zNear * zFar) / (zFar + zNear - depth * (zFar - zNear));
}

orthographic projection:

float screen_to_eye_depth_ortho(float d, float zNear, float zFar)
{
    // [0; 1] -> [-1; 1]
    float depth = d * 2.0 - 1.0;
    return (depth * (zFar - zNear) + (zFar + zNear)) / 2.0;
}

I advise you to test with your own near and far value to check the final result.

n = 10;
f = 100;
// -------------
z = 2 * f * n  / (f + n) - ndc * (f - n);
z = 2000 / (110 - ndc * 90);
// -------------
ndc = -1;
z = 2000 / (110 + 90) = 10;
ndc = 1;
z = 2000 / (110 - 90) = 100;