Hi. I was under the impression, from reading some articles/books, that OpenGL calculated its depth values like this: (let's look at a vertex, for simplicity) I.e. calculate the clip-space coordinate, perform the perspective division (which makes -1 <= z <= 1), scale and bias the z-value (so that 0 <= z <= 1) and use this final z-value as the depth. But when i try this, the depth value doesn't seem right. I'm probably missing something. How do i calculate the depth-value? (given a point in clipspace) Thanx for your help! (yeah, i know i could get the depth of a fragment with gl_FragCoord.z in a fragment program, but i'm not actually interested in the depth from the cameras point of view, but rather from the point of view of a lightsource)

I don't know how helpful this is with opengl, but I figured I'd throw it out there.

http://wiki.gamedev.net/index.php/ZBuffer

Learning to love your Z buffer

Thanx for the links. Just to follow up: (in case it can help someone else)

I tried looking at the perspective matrix from DirectX (see [1], if you have the book). After the matrix multiplication and the division by w (done on paper), i got the same expression for the depth as in "Learning to love your Z buffer". (it seems like he assumes that w=1 before the multiplication with the projection matrix - which is ok by me) (and that he assumes DirectX - not ok by me)

Looking at the OpenGL-matrix (again, see [1]), i of course get another expression for the depth. If i plug in z=znear into the expression, i get depth = -1 and if i plug in z=zfar i get depth = 1. (for DirectX i get 0 and 1)


So it seems that DirectX has clipcoords in the range: (for points not outside the frustum)
(x,y,z,1) = [-1;1]x[-1;1]x[0;1]x{1}while OpenGL has clipcoords in the range: (for points not outside the frustum)
(x,y,z,1) = [-1;1]x[-1;1]x[-1;1]x{1}
But depth values are in [0;1], so in OpenGL the clip z-coord has to be scaled/biased to get into [0;1] instead of [-1;1] i guess (as i wrote in the first post).

So it seems to me that my way of calculating the depth in the first post was correct. Or?
(probably something else is wrong in my code)

[1] Möller and Haines: "Real-time rendering", page 65.

typedef struct D3DVIEWPORT9 {
DWORD X;
DWORD Y;
DWORD Width;
DWORD Height;
float MinZ;
float MaxZ;
} D3DVIEWPORT9, *LPD3DVIEWPORT9;

I'm not an expert in Direct3D (mostly use OpenGL), but I believe the MinZ and MaxZ are the values that set the depth range in D3D.

Jeroen

OpenGL spec is your friend. Check out Section 2.11 in glspec15:
zw = [(f-n)/2]zd + (n+f)/2 , where
n and f are by default 0 and 1, so
zw = 0.5 * zd + 0.5, where zd = zc/wc
zw is then converted to the integer range of the depth buffer.

Seeing that you got the transformation right, how exactly don't the values seem right?