Directional light is disabled.

Great tutorial, thanks alot for the effort!

Just a hint for anyone having problems with the point lights not showing. I had to disable depth write for the directional full screen pass. Otherwise, the spheres won’t get rendered.

So in DrawDirectionalLight() do this :

GraphicsDevice.RenderState.DepthBufferWriteEnable = false;
quadRenderer.Render(Vector2.One * -1, Vector2.One);
GraphicsDevice.RenderState.DepthBufferWriteEnable = true;

Thanks for this article, very cool!

I’ve some problem with point lights:
- if the camera is “inside” the sphere’s triangle (== camera eye position intersect sphere triangle), i can’t see anything. What can i do?
- Here is an image: http://yscik.com/jf/pfs.php?m=view&v=2044-screenshot_5.jpg
The 4th square from left is the light render target’s texture. The final image isn’t as contrast as the light RT’s texture. Why?
I cheated a little: in final combine effect, i do this:

float3 diffuse = tex2D(colorSampler, In.TexCoord).rgb;
float3 light = tex2D(lightSampler, In.TexCoord).rgb * 2;

return float4(saturate(diffuse * light), 1.0f);

PS: Sorry for my bad english

For anyone who experiences horizontal lines or similar strange artifacts, this solution I “found” on http://www.sjbaker.org/steve/omniv/love_your_z_buffer.html (well, not exactly) worked on my GeForce 6600GT:

private float cameraDistance = 70;

projection = Matrix.CreatePerspectiveFieldOfView(MathHelper.PiOver4, aspectRatio, 10, 100);

Thanks for the great tutorial!

I found that this problem (or at least my problem, which was utterly similar) was related to parts of the sphere model rendering with wrong culling.
This can be solved if you test the camera position against the light radius taking the near plane distance into account. This is because the rendering “starts” from the near plane, not from the actual camera position.
So the code for determining the cull mode should be something like this:

if (cameraToCenter < lightRadius + camera.NearDistance)
GraphicsDevice.RenderState.CullMode = CullMode.CullClockwiseFace;
else
GraphicsDevice.RenderState.CullMode = CullMode.CullCounterClockwiseFace;

First of all I must say that you’ve done a terrific job with these tutorials!

I’m slowly porting the XNA code to unmanaged C++ DirectX, so far I’ve gotten as far as implementing point lights (here).

The reason I’m porting it is to learn as I code however I’m sort of stuck.

Where you calculate the position in world space:

//compute screen-space position float4 position; position.xy = input.ScreenPosition.xy; position.z = depthVal; position.w = 1.0f; //transform to world space position = mul(position, InvertViewProjection); position /= position.w;

The position created does not seem to be what I think. My assumption is that here you’re getting the position at the point in world space as the comment syas. However if I simply output position (that is, avoid all lighting calculations) right after the position is calculated (after position /= position.w;) I do: return position;

The colours returned do not match up with what I’d expect of if it was a position map because I thought a position map would essentially replace each pixels colour with the colour of its position in terms of r, g, b where r is x, g is y and b is z. However the colours output keep changing based on both the cameras position and cameras orientation.

So I was wondering why this is and also was wondering if there was a way to get a position map as I’ve described

Again, I really like your tutorial! Has helped me more than any other deffered rendering tutorial on the internet!

http://img212.imageshack.us/img212/2303/screenshot3n.png

This is my C++ code
http://pastebin.com/f4becf3ae

and this is how I call it
DeferredPointLight(D3DXVECTOR3(0.0f, 2.0f, 0.0f), vColour3, 10.0f, 2.0f, pBackBuffer)

I’m really lost, thanks =]