What do you mean by "screen-space depth"? Do you mean what's stored in the actual z-buffer, AKA post-projection z/w? If so, you can convert that to your original view-space Z value very easily:

float zw = tex2D(DepthBuffer, pixelCoord).x;
float linearZ = Projection._43 / (zw - Projection._33);


For arbitrary geometry you should use vpos register for screen-space xy-coordinates. For directional light and fullscreen quad there's no perspective projection to consider so VS interpolants work, but not for arbitrary 3D geometry needed for local light sources, thus the need for vpos. Once you have constructed screen-space homogenous coordinates [x, y, z, w] from vpos + depth in your pixel shader, transform the vector with inverse projection transform to view/world space (3 4d dot products). Depending on your platform you can use linear depth (i.e. depth rendered to a texture) or z-buffer depth. Using z-buffer depth is a bit more computationally expensive but saves bandwidth because you don't have to render the depth.


Cheers, Jarkko

vpos is linearly interpolated on the screen (contains screen coordinates of the processed pixel, i.e. [0, width-1], [0, height-1]), while vertex shader interpolants are linearly interpolated in 3d, thus affected by the perspective transform. If a rasterized triangle is camera facing (like the fullscreen quad of a directional light), there's no perspective projection to worry about. The triangles of light volumes of omni/spot lights are not camera facing so there's perspective correction applied to the vertex shader interpolants and thus you don't get linear interpolation on the screen.

In Spin-X Platform there's light pre-pass renderer, which performs pixel screen->world transformation using vpos for omni & spot lights. In ps_light.h file there's world_pos() function which performs screen->world space transformation using screen-space coordinates calculated from vpos (scaled to range [0, 1]) and ps_light_omni.hlsl is an example of the use the the function and vpos. In d3d9_lumion_engine.cpp (render_lighting() function in line 1304) the transformations are setup to the pixel shader constants if you like to check how they are calculated. In these shaders I use linear view-space z rendered to a texture.


Cheers, Jarkko

Hey hAk

Could you be so kind and offer me a concrete example regarding my issue and using VPOS?


float2 uvFromVPOS(float2 vPos) { return vPos * InvScreenDim.xy + 0.5f * InvScreenDim.xy; }

PS_output ps_pointLight(in VS_OUTPUT input, in float2 vPos : VPOS)
{
PS_output Out;

float2 texCoord = uvFromVPOS(vPos);

float3 viewRay = float3(input.PositionVS.xy * (FarClipDistance / input.PositionVS.z), FarClipDistance);
float normalizedDepth = DepthTexture.Sample(PointSampler, texCoord).x;
float3 positionVS = viewRay * normalizedDepth;
...
}