Object Coordinates are transformed by the World matrix to produce World Coordinates.World Coordinates are transformed by the View matrix to produce Eye (View-space) Coordinates.Eye Coordinates are transformed by the Projection matrix to produce Clip Coordinates.Clip Coordinate X, Y, and Z are divided by Clip Coordinate W to produce Normalized Device Coordinates.

Step 1:  create normalized eye-space depth bufferIn vertex shader:-calculate eye-space position of vertex (transform by worldView matrix for D3D, modelView matrix for GL)-pass eye-space position to fragment shaderIn fragment shader:-divide z-component of eye-space position by the z-value of the view frustum's far clip plane-Output the value to the depth bufferStep 2:  calculate world-space position from depth bufferIn application:-calculate world-space positions of the 4 corners of the view frustum's far clip plane-pass points to vertex shader as constants or as values in the vertices of the full-screen quad (the 4 corner points should be mapped to the 4 points of the quad)-pass the world-space position of the camera to the fragment shader-render the quadIn vertex shader:-retrieve the position of the the frustum corner for the current vertex-pass as "viewDirection" to the fragment shader (do not normalize!)In fragment shader:-do not normalize "viewDirection"!-read depth value from the depth buffer-world-space position of the fragment is "cameraPos + (viewDirection * depth)"

// Application... Calculate farplane coordinates, I pass later on them as the normals of that quad// Before rendering the depth and quad, pass the camera matrix// Depth Vertex Shader    // in.pos is an absolute world coordinate    out.Pos	= mul( modelViewProjectionMatrix, in.pos );// Depth Fragment Shader    out.color.r	= out.pos.z / 500; // test 500 is max(test) view distance// Test Quad Vertex Shader    // Just pass. Quad XY Coords are (-1,-1) (-1,+1) (+1,+1) and (+1,-1)    // Already in eye-space... right?    out.pos.xy	= iPos.xy;     // Farplane coordinate (mapped on quad) is placed in the normal iNrm    // MVPI = Inverse ModelViewProjection Matrix, Cg OpenGL:    //    CG_GL_MODELVIEWPROJETION_MATRIX, CG_GL_INVERSE_MATRIX    float4 worldPos = mul( MVPI, in.pos );         // The farplane world coordinates are stored inside the 4 normals    out.viewDir.xy = (worldPos.xy / worldPos.w) * normal.xy;    out.viewDir.z  = normal.z;// Test Quad Fragment Shader    float	pDepth	 = f1tex2D( sceneDepth, iTex.xy ).r;      float3	pPos3D	 = cameraPos.xyz + in.viewDir.xyz * pDepth;                out.color= pPos3D; // test the result

float4 perspective_position = float4(iPos.x, iPos.y, pDepth * iPos.w, iPos.w);perspective_position);float4 world_position_4d = mul(InvProj, perspective_position);float3 world_position_3d = world_position_4d.xyz / world_position_4d.w;

Quote:Original post by Matt Aufderheide

Quote:Original post by MJP

So I think I'll just start over and explain an algorithm that you can use for generating world-space coordinates, using full screen quads. Then perhaps I will post some example code, or discuss some specific optimizations.

MJP: Thank you very much! This explanation is all I needed; now it works perfectly; fast with perfect quality.. its great to eliminate the need for an entire render target and just use depth. Now i just use 2 render targets for my deferred renderer... Thanks again.

// Depth Vertex Shader    // in.pos is in object space     out.pos = mul( modelViewProjectionMatrix, in.pos );  //out.pos is in clip space    out.eyePos = mul( modelViewMatrix, in.pos );  //out.eyePos is in eye space    // Depth Fragment Shader    out.color.r	= out.eyePos.z / 500; // test 500 is max(test) view distance

// Depth Vertex Shader    // in.pos is in object space     out.pos = mul( modelViewProjectionMatrix, in.pos );  //out.pos is in clip space    // Depth Fragment Shader    out.color.r	= out.pos.z / out.pos.w;

Quote:Original post by spek

out.color.r = out.pos.z / 500; // test 500 is max(test) view distance


// Test Quad Vertex Shader
// Just pass. Quad XY Coords are (-1,-1) (-1,+1) (+1,+1) and (+1,-1)
// Already in eye-space... right?
out.pos.xy = iPos.xy;

// Farplane coordinate (mapped on quad) is placed in the normal iNrm
// MVPI = Inverse ModelViewProjection Matrix, Cg OpenGL:
// CG_GL_MODELVIEWPROJETION_MATRIX, CG_GL_INVERSE_MATRIX
float4 worldPos = mul( MVPI, in.pos );

// The farplane world coordinates are stored inside the 4 normals
out.viewDir.xy = (worldPos.xy / worldPos.w) * normal.xy;
out.viewDir.z = normal.z;

// Test Quad Fragment Shader
float pDepth = f1tex2D( sceneDepth, iTex.xy ).r;
float3 pPos3D = cameraPos.xyz + in.viewDir.xyz * pDepth;
out.color= pPos3D; // test the result

// Test Quad Vertex Shader    // Just pass. Quad XY Coords are (-1,-1) (-1,+1) (+1,+1) and (+1,-1)    // (these are actually in normalized device coordinates)    out.pos.xy	= iPos.xy;          // The farplane world coordinates are stored inside the 4 normals    out.viewDir = normal;   // Test Quad Fragment Shader    float	pDepth	 = f1tex2D( sceneDepth, iTex.xy ).r;      float3	pPos3D	 = cameraPos.xyz + in.viewDir.xyz * pDepth;                out.color= pPos3D; // test the result

Application:-Create a view matrix using gluLookAt-Set this view matrix as your modelView matrix in the stack-use the same projection matrix you've been using all along//vertex shader // Just pass. Quad XY Coords are (-1,-1) (-1,+1) (+1,+1) and (+1,-1)    out.pos.xy	= iPos.xy;//fragment shaderfloat	pDepth	 = f1tex2D( sceneDepth, iTex.xy ).r; float4 perspective_position = float4(in.pos.x, in.pos.y, pDepth * in.pos.w, in.pos.w);// MVPI = Inverse ModelViewProjection Matrix, Cg OpenGL://    CG_GL_MODELVIEWPROJETION_MATRIX, CG_GL_INVERSE_MATRIXfloat4 world_position_4d = mul(perspective_position, MVPI);float3 world_position_3d = world_position_4d.xyz / world_position_4d.w;