i'm following the tutorials on 3D Graphics with XNA Game Studio 4.0 and
I came up with an horrible effect when
I tried to implement the Light Map
http://i.stack.imgur.com/BUWvU.jpg
this effect shows up when
I look towards the center of the house (and it moves with me).
it has this shape because
I'm using a sphere to represent light; using other light shapes gives different results.
I'm using a class PreLightingRenderer:
using System;
using System.Collections.Generic;
using System.Linq;
using System.Text;
using Microsoft.Xna.Framework;
using Microsoft.Xna.Framework.Graphics;
using Dhpoware;
using Microsoft.Xna.Framework.Content;
namespace XNAFirstPersonCamera
{
public class PrelightingRenderer
{
// Normal, depth, and light map render targets
RenderTarget2D depthTarg;
RenderTarget2D normalTarg;
RenderTarget2D lightTarg;
// Depth/normal effect and light mapping effect
Effect depthNormalEffect;
Effect lightingEffect;
// Point light (sphere) mesh
Model lightMesh;
// List of models,
lights, and the camera
public List<CModel> Models { get; set; }
public List<PPPointLight>
Lights { get; set; }
public FirstPersonCamera Camera { get; set; }
GraphicsDevice graphicsDevice;
int viewWidth = 0, viewHeight = 0;
public PrelightingRenderer(GraphicsDevice GraphicsDevice, ContentManager Content)
{
viewWidth = GraphicsDevice.Viewport.Width;
viewHeight = GraphicsDevice.Viewport.Height;
// Create the three render targets
depthTarg = new RenderTarget2D(GraphicsDevice, viewWidth, viewHeight, false, SurfaceFormat.Single, DepthFormat.Depth24);
normalTarg = new RenderTarget2D(GraphicsDevice, viewWidth, viewHeight, false, SurfaceFormat.Color, DepthFormat.Depth24);
lightTarg = new RenderTarget2D(GraphicsDevice, viewWidth, viewHeight, false, SurfaceFormat.Color, DepthFormat.Depth24);
// Load effects
depthNormalEffect = Content.Load<Effect>(@"Effects\PPDepthNormal");
lightingEffect = Content.Load<Effect>(@"Effects\PPLight");
// Set effect parameters to light mapping effect
lightingEffect.Parameters["viewportWidth"].SetValue(viewWidth);
lightingEffect.Parameters["viewportHeight"].SetValue(viewHeight);
// Load point light mesh and set light mapping effect to it
lightMesh = Content.Load<Model>(@"Models\PPLightMesh");
lightMesh.Meshes[0].MeshParts[0].Effect = lightingEffect;
this.graphicsDevice = GraphicsDevice;
}
public void Draw()
{
drawDepthNormalMap();
drawLightMap();
prepareMainPass();
}
void drawDepthNormalMap()
{
// Set the render targets to 'slots' 1 and 2
graphicsDevice.SetRenderTargets(normalTarg, depthTarg);
// Clear the render target to 1 (infinite depth)
graphicsDevice.Clear(Color.White);
// Draw each model with the PPDepthNormal effect
foreach (CModel model in Models)
{
model.CacheEffects();
model.SetModelEffect(depthNormalEffect, false);
model.Draw(Camera.ViewMatrix, Camera.ProjectionMatrix, Camera.Position);
model.RestoreEffects();
}
// Un-set the render targets
graphicsDevice.SetRenderTargets(null);
}
void drawLightMap()
{
// Set the depth and normal map info to the effect
lightingEffect.Parameters["DepthTexture"].SetValue(depthTarg);
lightingEffect.Parameters["NormalTexture"].SetValue(normalTarg);
// Calculate the view * projection matrix
Matrix viewProjection = Camera.ViewMatrix * Camera.ProjectionMatrix;
// Set the inverse of the view * projection matrix to the effect
Matrix invViewProjection = Matrix.Invert(viewProjection);
lightingEffect.Parameters["InvViewProjection"].SetValue(invViewProjection);
// Set the render target to the graphics device
graphicsDevice.SetRenderTarget(lightTarg);
// Clear the render target to black (no light)
graphicsDevice.Clear(Color.Black);
// Set render states to additive (lights will add their influences)
graphicsDevice.BlendState = BlendState.Additive;
graphicsDevice.DepthStencilState = DepthStencilState.None;
foreach (PPPointLight light in Lights)
{
// Set the light's parameters to the effect
light.SetEffectParameters(lightingEffect);
// Calculate the world * view * projection matrix and set it to
// the effect
Matrix wvp = (Matrix.CreateScale(light.Attenuation) * Matrix.CreateTranslation(light.Position)) * viewProjection;
lightingEffect.Parameters["WorldViewProjection"].SetValue(wvp);
// Determine the distance between the light and camera
float dist = Vector3.Distance(Camera.Position, light.Position);
// If the camera is inside the light-sphere, invert the cull mode
// to draw the inside of the sphere instead of the outside
if (dist < light.Attenuation)
graphicsDevice.RasterizerState = RasterizerState.CullClockwise;
// Draw the point-light-sphere
lightMesh.Meshes[0].Draw();
// Revert the cull mode
graphicsDevice.RasterizerState = RasterizerState.CullCounterClockwise;
}
// Revert the blending and depth render states
graphicsDevice.BlendState = BlendState.Opaque;
graphicsDevice.DepthStencilState = DepthStencilState.Default;
// Un-set the render target
graphicsDevice.SetRenderTarget(null);
}
void prepareMainPass()
{
foreach (CModel model in Models)
foreach (ModelMesh mesh in model.Model.Meshes)
foreach (ModelMeshPart part in mesh.MeshParts)
{
// Set the light map and viewport parameters to each model's effect
if (part.Effect.Parameters["LightTexture"] != null)
part.Effect.Parameters["LightTexture"].SetValue(lightTarg);
if (part.Effect.Parameters["viewportWidth"] != null)
part.Effect.Parameters["viewportWidth"].SetValue(viewWidth);
if (part.Effect.Parameters["viewportHeight"] != null)
part.Effect.Parameters["viewportHeight"].SetValue(viewHeight);
}
}
}
}
that uses three effect:
PPDepthNormal.fx
float4x4 World;
float4x4 View;
float4x4 Projection;
struct VertexShaderInput
{
float4 Position : POSITION0;
float3 Normal : NORMAL0;
};
struct VertexShaderOutput
{
float4 Position : POSITION0;
float2 Depth : TEXCOORD0;
float3 Normal : TEXCOORD1;
};
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
VertexShaderOutput output;
float4x4 viewProjection = mul(View, Projection);
float4x4 worldViewProjection = mul(World, viewProjection);
output.Position = mul(input.Position, worldViewProjection);
output.Normal = mul(input.Normal, World);
// Position's z and w components correspond to the distance
// from camera and distance of the far plane respectively
output.Depth.xy = output.Position.zw;
return output;
}
// We render to two targets simultaneously, so we can't
// simply return a float4 from the pixel shader
struct PixelShaderOutput
{
float4 Normal : COLOR0;
float4 Depth : COLOR1;
};
PixelShaderOutput PixelShaderFunction(VertexShaderOutput input)
{
PixelShaderOutput output;
// Depth is stored as distance from camera / far plane distance
// to get value between 0 and 1
output.Depth = input.Depth.x / input.Depth.y;
// Normal map simply stores X, Y and Z components of normal
// shifted from (-1 to 1) range to (0 to 1) range
output.Normal.xyz = (normalize(input.Normal).xyz / 2) + .5;
// Other components must be initialized to compile
output.Depth.a = 1;
output.Normal.a = 1;
return output;
}
technique Technique1
{
pass Pass1
{
VertexShader = compile vs_1_1 VertexShaderFunction();
PixelShader = compile ps_2_0 PixelShaderFunction();
}
}
PPLight.fx
float4x4 WorldViewProjection;
float4x4 InvViewProjection;
texture2D DepthTexture;
texture2D NormalTexture;
sampler2D depthSampler = sampler_state {
texture = ;
minfilter = point;
magfilter = point;
mipfilter = point;
};
sampler2D normalSampler = sampler_state {
texture = ;
minfilter = point;
magfilter = point;
mipfilter = point;
};
float3 LightColor;
float3 LightPosition;
float LightAttenuation;
// Include shared functions
#include "PPShared.vsi"
struct VertexShaderInput
{
float4 Position : POSITION0;
};
struct VertexShaderOutput
{
float4 Position : POSITION0;
float4 LightPosition : TEXCOORD0;
};
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
VertexShaderOutput output;
output.Position = mul(input.Position, WorldViewProjection);
output.LightPosition = output.Position;
return output;
}
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
// Find the pixel coordinates of the input position in the depth
// and normal textures
float2 texCoord = postProjToScreen(input.LightPosition) + halfPixel();
// Extract the depth for this pixel from the depth map
float4 depth = tex2D(depthSampler, texCoord);
// Recreate the position with the UV coordinates and depth value
float4 position;
position.x = texCoord.x * 2 - 1;
position.y = (1 - texCoord.y) * 2 - 1;
position.z = depth.r;
position.w = 1.0f;
// Transform position from screen space to world space
position = mul(position, InvViewProjection);
position.xyz /= position.w;
// Extract the normal from the normal map and move from
// 0 to 1 range to -1 to 1 range
float4 normal = (tex2D(normalSampler, texCoord) - .5) * 2;
// Perform the lighting calculations for a point light
float3 lightDirection = normalize(LightPosition - position);
float lighting = clamp(dot(normal, lightDirection), 0, 1);
// Attenuate the light to simulate a point light
float d = distance(LightPosition, position);
float att = 1 - pow(d / LightAttenuation, 6);
return float4(LightColor * lighting * att, 1);
}
technique Technique1
{
pass Pass1
{
VertexShader = compile vs_1_1 VertexShaderFunction();
PixelShader = compile ps_2_0 PixelShaderFunction();
}
}
PPShared.vsi has some common functions:
float viewportWidth;
float viewportHeight;
// Calculate the 2D screen position of a 3D position
float2 postProjToScreen(float4 position)
{
float2 screenPos = position.xy / position.w;
return 0.5f * (float2(screenPos.x, -screenPos.y) + 1);
}
// Calculate the size of one half of a pixel, to convert
// between texels and pixels
float2 halfPixel()
{
return 0.5f / float2(viewportWidth, viewportHeight);
}
and finally from the Game class
I set up in LoadContent with:
effect = Content.Load(@"Effects\PPModel");
models[0] = new CModel(Content.Load(@"Models\teapot"), new Vector3(-50, 80, 0), new Vector3(0, 0, 0),
1f, Content.Load(@"Textures\prova_texture_autocad"), GraphicsDevice);
house = new CModel(Content.Load(@"Models\house"), new Vector3(0, 0, 0), new Vector3((float)-Math.PI / 2, 0, 0), 35.0f, Content.Load(@"Textures\prova_texture_autocad"), GraphicsDevice);
models[0].SetModelEffect(effect, true);
house.SetModelEffect(effect, true);
renderer = new PrelightingRenderer(GraphicsDevice, Content);
renderer.Models = new List();
renderer.Models.Add(house);
renderer.Models.Add(models[0]);
renderer.
Lights = new List()
{
new PPPointLight(new Vector3(0, 120, 0), Color.White * .85f, 2000)
};
where PPModel.fx is:
float4x4 World;
float4x4 View;
float4x4 Projection;
texture2D BasicTexture;
sampler2D basicTextureSampler = sampler_state
{
texture = ;
addressU = wrap;
addressV = wrap;
minfilter = anisotropic;
magfilter = anisotropic;
mipfilter = linear;
};
bool TextureEnabled = true;
texture2D LightTexture;
sampler2D lightSampler = sampler_state
{
texture = ;
minfilter = point;
magfilter = point;
mipfilter = point;
};
float3 AmbientColor = float3(0.15, 0.15, 0.15);
float3 DiffuseColor;
#include "PPShared.vsi"
struct VertexShaderInput
{
float4 Position : POSITION0;
float2 UV : TEXCOORD0;
};
struct VertexShaderOutput
{
float4 Position : POSITION0;
float2 UV : TEXCOORD0;
float4 PositionCopy : TEXCOORD1;
};
VertexShaderOutput VertexShaderFunction(VertexShaderInput input)
{
VertexShaderOutput output;
float4x4 worldViewProjection = mul(World, mul(View, Projection));
output.Position = mul(input.Position, worldViewProjection);
output.PositionCopy = output.Position;
output.UV = input.UV;
return output;
}
float4 PixelShaderFunction(VertexShaderOutput input) : COLOR0
{
// Sample model's texture
float3 basicTexture = tex2D(basicTextureSampler, input.UV);
if (!TextureEnabled)
basicTexture = float4(1, 1, 1, 1);
// Extract lighting value from light map
float2 texCoord = postProjToScreen(input.PositionCopy) +
halfPixel();
float3 light = tex2D(lightSampler, texCoord);
light += AmbientColor;
return float4(basicTexture * DiffuseColor * light, 1);
}
technique Technique1
{
pass Pass1
{
VertexShader = compile vs_1_1 VertexShaderFunction();
PixelShader = compile ps_2_0 PixelShaderFunction();
}
}
I don't have any idea on what's wrong... googling the web
I found that this tutorial may have some bug but
I don't know if it's the LightModel fault (the sphere) or in a shader or in the class PrelightingRenderer.
Any help is very appreciated, thank you for reading!
