protected void DrawDirectionalLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
ComputeFrustumCorners(camera);
ApplyFrustumCorners(directionalLightEffect.Parameters["FrustumCorners"], -Vector2.One, Vector2.One);
render.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
DirectionalhalfPixel.SetValue(ginfo.HalfPixel);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Directional && item.Enabled == true)
{
PloobsEngine.Light.DirectionalLightPE dl = item as PloobsEngine.Light.DirectionalLightPE;
Vector3 vldir = Vector3.Transform(dl.LightDirection, camera.View);
DirectionallightDirection.SetValue(vldir);
DirectionalColor.SetValue(dl.Color.ToVector3());
DirectionallightIntensity.SetValue(dl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
}
}
render.SetSamplerState(s2, 2);
}
protected void DrawDirectionalLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
DirectionalcameraPosition.SetValue(camera.Position);
DirectionalInvertViewProjection.SetValue(Matrix.Invert(camera.ViewProjection));
DirectionalhalfPixel.SetValue(ginfo.HalfPixel);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Directional && item.Enabled == true)
{
PloobsEngine.Light.DirectionalLightPE dl = item as PloobsEngine.Light.DirectionalLightPE;
DirectionallightDirection.SetValue(dl.LightDirection);
DirectionalColor.SetValue(dl.Color.ToVector3());
DirectionallightIntensity.SetValue(dl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
}
}
render.SetSamplerState(s2, 2);
}
protected void DrawPointLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
PointcameraPosition.SetValue(camera.Position);
float _tanFovy = (float)Math.Tan(camera.FieldOfView / 2);
pointLightEffect.Parameters["TanAspect"].SetValue(new Vector2(_tanFovy * camera.AspectRatio, -_tanFovy));
pointLightEffect.Parameters["farPlane"].SetValue(camera.FarPlane);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Point && item.Enabled == true)
{
PointLightPE pl = item as PointLightPE;
Matrix sphereWorldMatrix = Matrix.CreateScale(pl.LightRadius) * Matrix.CreateTranslation(pl.LightPosition);
ContainmentType ct = ContainmentType.Contains;
if (cullPointLight)
{
ct = camera.BoundingFrustum.Contains(new BoundingSphere(pl.LightPosition, pl.LightRadius));
}
if (ct == ContainmentType.Contains || ct == ContainmentType.Intersects)
{
//convert light position into viewspace
Vector3 viewSpaceLPos = Vector3.Transform(pl.LightPosition, camera.View);
PointWordViewProjection.SetValue(sphereWorldMatrix * camera.ViewProjection);
PointlightPosition.SetValue(viewSpaceLPos);
PointColor.SetValue(pl.Color.ToVector3());
PointlightRadius.SetValue(pl.LightRadius);
PointlightIntensity.SetValue(pl.LightIntensity);
Pointquadratic.SetValue(pl.UsePointLightQuadraticAttenuation);
float cameraToCenter = Vector3.Distance(camera.Position, pl.LightPosition);
if (cameraToCenter < pl.LightRadius + camera.NearPlane)
{
render.PushRasterizerState(RasterizerState.CullClockwise);
}
else
{
render.PushRasterizerState(RasterizerState.CullCounterClockwise);
}
render.RenderBatch(sphereModel.GetBatchInformation(0)[0], pointLightEffect);
render.PopRasterizerState();
}
}
}
render.SetSamplerState(s2, 2);
}
protected void DrawPointLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
PointProjection.SetValue(camera.Projection);
PointView.SetValue(camera.View);
PointcameraPosition.SetValue(camera.Position);
PointInvertViewProjection.SetValue(Matrix.Invert(camera.ViewProjection));
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Point && item.Enabled == true)
{
PointLightPE pl = item as PointLightPE;
Matrix sphereWorldMatrix = Matrix.CreateScale(pl.LightRadius) * Matrix.CreateTranslation(pl.LightPosition);
ContainmentType ct = ContainmentType.Contains;
if (cullPointLight)
{
ct = camera.BoundingFrustum.Contains(new BoundingSphere(pl.LightPosition, pl.LightRadius));
}
if (ct == ContainmentType.Contains || ct == ContainmentType.Intersects)
{
PointWorld.SetValue(sphereWorldMatrix);
PointlightPosition.SetValue(pl.LightPosition);
PointColor.SetValue(pl.Color.ToVector3());
PointlightRadius.SetValue(pl.LightRadius);
PointlightIntensity.SetValue(pl.LightIntensity);
Pointquadratic.SetValue(pl.UsePointLightQuadraticAttenuation);
float cameraToCenter = Vector3.Distance(camera.Position, pl.LightPosition);
if (cameraToCenter < pl.LightRadius + camera.NearPlane)
{
render.PushRasterizerState(RasterizerState.CullClockwise);
}
else
{
render.PushRasterizerState(RasterizerState.CullCounterClockwise);
}
render.RenderBatch(sphereModel.GetBatchInformation(0)[0], pointLightEffect);
render.PopRasterizerState();
}
}
}
render.SetSamplerState(s2, 2);
}
/// <summary>
/// Renders a list of models to the shadow map, and returns a surface
/// containing the shadow occlusion factor
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <param name="render">The render.</param>
/// <param name="ginfo">The ginfo.</param>
/// <param name="light">The light for which the shadow is being calculated</param>
/// <param name="mainCamera">The camera viewing the scene containing the light</param>
/// <param name="world">The world.</param>
/// <param name="deferredGBuffer">The deferred G buffer.</param>
/// <returns>
/// The shadow occlusion texture
/// </returns>
internal RenderTarget2D Render(GameTime gameTime, RenderHelper render, GraphicInfo ginfo, DirectionalLightPE light,
ICamera mainCamera, IWorld world, IDeferredGBuffer deferredGBuffer)
{
vp = render.GetViewPort();
// Set our targets
render.PushRenderTarget(shadowMap);
render.Clear(Color.White, ClearOptions.Target, 1.0f, 0);
render.Clear(Color.Black, ClearOptions.DepthBuffer, 1.0f, 0);
// Get corners of the main camera's bounding frustum
Matrix cameraTransform, viewMatrix;
viewMatrix = mainCamera.View;
cameraTransform = Matrix.Invert(viewMatrix);
mainCamera.BoundingFrustum.GetCorners(frustumCornersWS);
Vector3.Transform(frustumCornersWS, ref viewMatrix, frustumCornersVS);
for (int i = 0; i < 4; i++)
{
farFrustumCornersVS[i] = frustumCornersVS[i + 4];
}
// Calculate the cascade splits. We calculate these so that each successive
// split is larger than the previous, giving the closest split the most amount
// of shadow detail.
float N = NumSplits;
float near = mainCamera.NearPlane, far = mainCamera.FarPlane;
splitDepths[0] = near;
splitDepths[NumSplits] = far;
for (int i = 1; i < splitDepths.Length - 1; i++)
{
splitDepths[i] = splitConstant * near * (float)Math.Pow(far / near, i / N) + (1.0f - splitConstant) * ((near + (i / N)) * (far - near));
}
// Render our scene geometry to each split of the cascade
for (int i = 0; i < NumSplits; i++)
{
float minZ = splitDepths[i];
float maxZ = splitDepths[i + 1];
CalculateFrustum(light, mainCamera, minZ, maxZ, out lightProjectionMatrices[i], out lightViewMatrices[i], out lightViewProjectionMatrices[i]);
RenderShadowMap(gameTime, render, i, world);
}
render.PopRenderTargetAsSingleRenderTarget2D();
render.SetViewPort(ginfo.Viewport);
RenderShadowOcclusion(render, mainCamera, light, deferredGBuffer);
return(shadowOcclusion);
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Transparent, ClearOptions.Target);
render.PushBlendState(_lightAddBlendState);
render.PushDepthStencilState(DepthStencilState.None);
DrawDirectionalLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer, render);
DrawPointLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer, render);
DrawnSpotLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer, render);
render.PopBlendState();
render.PopDepthStencilState();
}
/// <summary>
/// Initializes a new instance of the <see cref="DeferredRenderTechnicInitDescription"/> struct.
/// </summary>
/// <param name="DeferredGBuffer">The deferred G buffer.</param>
/// <param name="DeferredLightMap">The deferred light map.</param>
/// <param name="BackGroundColor">Color of the back ground.</param>
/// <param name="LightDebug">if set to <c>true</c> [light debug].</param>
/// <param name="DefferedDebug">if set to <c>true</c> [deffered debug].</param>
/// <param name="UseFloatingBufferForLightMap">if set to <c>true</c> [use floating buffer for light map].</param>
/// <param name="CullPointLight">if set to <c>true</c> [cull point light].</param>
/// <param name="ExtraForwardPass">if set to <c>true</c> [extra forward pass].</param>
/// <param name="RenderTargetsNameToDefferedDebug">The render targets name to deffered debug.</param>
/// <param name="RestoreDepthOption">The restore depth option.</param>
public PrePassRenderTechnicInitDescription(IDeferredGBuffer DeferredGBuffer, IDeferredLightMap DeferredLightMap, Color BackGroundColor, bool LightDebug, bool DefferedDebug,
bool CullPointLight, bool ExtraForwardPass, String[] RenderTargetsNameToDefferedDebug, RestoreDepthOption RestoreDepthOption)
{
this.DefferedDebug = DefferedDebug;
this.LightDebug = LightDebug;
this.CullPointLight = CullPointLight;
this.ExtraForwardPass = ExtraForwardPass;
this.DeferredGBuffer = DeferredGBuffer;
this.DeferredLightMap = DeferredLightMap;
this.RenderTargetsNameToDefferedDebug = RenderTargetsNameToDefferedDebug;
this.BackGroundColor = BackGroundColor;
OrderAllObjectsBeforeDraw = null;
OrderDeferredObjectsBeforeDraw = null;
OrderForwardObjectsBeforeDraw = null;
}
/// <summary>
/// Initializes a new instance of the <see cref="DeferredRenderTechnicInitDescription"/> struct.
/// </summary>
/// <param name="DeferredGBuffer">The deferred G buffer.</param>
/// <param name="DeferredLightMap">The deferred light map.</param>
/// <param name="BackGroundColor">Color of the back ground.</param>
/// <param name="LightDebug">if set to <c>true</c> [light debug].</param>
/// <param name="DefferedDebug">if set to <c>true</c> [deffered debug].</param>
/// <param name="UseFloatingBufferForLightMap">if set to <c>true</c> [use floating buffer for light map].</param>
/// <param name="CullPointLight">if set to <c>true</c> [cull point light].</param>
/// <param name="ExtraForwardPass">if set to <c>true</c> [extra forward pass].</param>
/// <param name="RenderTargetsNameToDefferedDebug">The render targets name to deffered debug.</param>
/// <param name="RestoreDepthOption">The restore depth option.</param>
public PrePassRenderTechnicInitDescription(IDeferredGBuffer DeferredGBuffer, IDeferredLightMap DeferredLightMap,Color BackGroundColor, bool LightDebug, bool DefferedDebug,
bool CullPointLight, bool ExtraForwardPass, String[] RenderTargetsNameToDefferedDebug, RestoreDepthOption RestoreDepthOption)
{
this.DefferedDebug = DefferedDebug;
this.LightDebug = LightDebug;
this.CullPointLight = CullPointLight;
this.ExtraForwardPass = ExtraForwardPass;
this.DeferredGBuffer = DeferredGBuffer;
this.DeferredLightMap = DeferredLightMap;
this.RenderTargetsNameToDefferedDebug = RenderTargetsNameToDefferedDebug;
this.BackGroundColor = BackGroundColor;
OrderAllObjectsBeforeDraw = null;
OrderDeferredObjectsBeforeDraw = null;
OrderForwardObjectsBeforeDraw = null;
}
public void DrawScene(GameTime gameTime, IWorld world, IDeferredGBuffer gbuffer, IDeferredLightMap lightmap, RenderHelper render)
{
//if (useFloatBuffer)
//{
// render.SetSamplerState(SamplerState.PointClamp, 0);
//}
//else
//{
// render.SetSamplerState(ginfo.SamplerState, 0);
// render.SetSamplerState(ginfo.SamplerState, 1);
// render.SetSamplerState(ginfo.SamplerState, 2);
//}
render.Clear(Color.CornflowerBlue);
effect.Parameters["halfPixel"].SetValue(half);
effect.Parameters["View"].SetValue(world.CameraManager.ActiveCamera.View);
effect.Parameters["Projection"].SetValue(world.CameraManager.ActiveCamera.Projection);
effect.Parameters["light"].SetValue(lightmap[DeferredLightMapType.LIGHTMAP]);
{
foreach (IObject item in world.Culler.GetNotCulledObjectsList(MaterialType.DEFERRED))
{
for (int i = 0; i < item.Modelo.MeshNumber; i++)
{
BatchInformation[] bi = item.Modelo.GetBatchInformation(i);
for (int j = 0; j < bi.Count(); j++)
{
effect.Parameters["Texture"].SetValue(item.Modelo.getTexture(TextureType.DIFFUSE, i, j));
effect.Parameters["World"].SetValue(bi[j].ModelLocalTransformation * item.WorldMatrix);
render.RenderBatch(bi[j], effect);
}
}
}
}
if (saveToTexture)
{
render.PopRenderTarget();
}
}
protected void DrawnSpotLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.PushRasterizerState(RasterizerState.CullNone);
render.PushDepthStencilState(DepthStencilState.None);
render.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
ApplyFrustumCorners(directionalLightEffect.Parameters["FrustumCorners"], -Vector2.One, Vector2.One);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Spot && item.Enabled == true)
{
SpotLightPE sl = item as SpotLightPE;
Vector3 viewSpaceLPos = Vector3.Transform(sl.Position, camera.View);
Vector3 viewSpaceLDir = Vector3.Transform(sl.Direction, camera.View);
spotLightEffect.Parameters["lightPosition"].SetValue(viewSpaceLPos);
spotLightEffect.Parameters["lightDirection"].SetValue(viewSpaceLDir);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
}
}
render.PopDepthStencilState();
render.PopRasterizerState();
render.SetSamplerState(s2, 2);
}
private void DrawDirectionalLight(RenderHelper render, GraphicInfo ginfo, ICamera camera, DirectionalLightPE dl, IDeferredGBuffer DeferredGBuffer)
{
directionalLightEffect.Parameters["shadowBufferSize"].SetValue(shadownBufferSize);
if(dl.CastShadown)
//directionalLightEffect.Parameters["xShadowMap"].SetValue(shadowMap);
render.device.Textures[3] = shadowMap;
else
//directionalLightEffect.Parameters["xShadowMap"].SetValue(blank);
render.device.Textures[3] = blank;
//directionalLightEffect.Parameters["colorMap"].SetValue(DeferredGBuffer[GBufferTypes.COLOR]);
//directionalLightEffect.Parameters["normalMap"].SetValue(DeferredGBuffer[GBufferTypes.NORMAL]);
//directionalLightEffect.Parameters["depthMap"].SetValue(DeferredGBuffer[GBufferTypes.DEPH]);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
SamplerState s3 = render.SetSamplerState(SamplerState.PointClamp, 3);
directionalLightEffect.Parameters["View"].SetValue(camera.View);
directionalLightEffect.Parameters["Projection"].SetValue(camera.Projection);
directionalLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
directionalLightEffect.Parameters["shadown"].SetValue(dl.CastShadown);
directionalLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewProjection));
directionalLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
directionalLightEffect.Parameters["lightDirection"].SetValue(dl.LightDirection);
directionalLightEffect.Parameters["Color"].SetValue(dl.Color.ToVector3());
directionalLightEffect.Parameters["lightIntensity"].SetValue(dl.LightIntensity);
render.PushDepthStencilState(DepthStencilState.None);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
render.PopDepthStencilState();
render.SetSamplerState(s2, 2);
render.SetSamplerState(s3, 3);
}
protected void DrawnSpotLight(ICamera camera, IList <ILight> lights, IDeferredGBuffer DeferredGBuffer, RenderHelper render)
{
render.PushRasterizerState(RasterizerState.CullNone);
render.PushDepthStencilState(DepthStencilState.None);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
spotLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.View * camera.Projection));
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Spot && item.Enabled == true)
{
SpotLightPE sl = item as SpotLightPE;
spotLightEffect.Parameters["lightPosition"].SetValue(sl.Position);
spotLightEffect.Parameters["lightDirection"].SetValue(sl.Direction);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
}
}
render.PopDepthStencilState();
render.PopRasterizerState();
render.SetSamplerState(s2, 2);
}
public void DrawScene(GameTime gameTime, IWorld world, IDeferredGBuffer gbuffer, IDeferredLightMap lightmap, RenderHelper render)
{
render.PushDepthStencilState(DepthStencilState.None);
PambientColor.SetValue(ambientColor.ToVector3());
render.device.Textures[0] = lightmap[DeferredLightMapType.LIGHTMAP];
SamplerState s0 = render.SetSamplerState(SamplerState.PointClamp, 0);
render.device.Textures[1] = gbuffer[GBufferTypes.Extra1];
render.device.Textures[2] = gbuffer[GBufferTypes.COLOR];
//PEXTRA1.SetValue(gbuffer[GBufferTypes.Extra1]);
//PcolorMap.SetValue(gbuffer[GBufferTypes.COLOR]);
//PlightMap.SetValue(lightmap[DeferredLightMapType.LIGHTMAP]);
render.RenderFullScreenQuadVertexPixel(finalCombineEffect);
render.SetSamplerState(s0, 0);
if (saveToTexture)
{
render.PopRenderTarget();
}
render.PopDepthStencilState();
}
private void RenderShadowMap(GameTime gt, RenderHelper render, ref Matrix view, ref Matrix proj, IWorld world, IDeferredGBuffer deferredGBuffer)
{
render.PushRenderTarget(shadowRT);
render.Clear(Color.Transparent,ClearOptions.Target | ClearOptions.DepthBuffer,1,0);
render.RenderSceneDepth(world, gt, ref view, ref proj, true);
shadowMap = render.PopRenderTargetAsSingleRenderTarget2D();
}
private void DrawnSpotLight(RenderHelper render, GraphicInfo ginfo, ICamera camera, SpotLightPE sl, IDeferredGBuffer DeferredGBuffer)
{
//if(sl.CastShadown)
// spotLightEffect.Parameters["xShadowMap"].SetValue(shadowMap);
//else
// spotLightEffect.Parameters["xShadowMap"].SetValue(blank);
if (sl.CastShadown)
render.device.Textures[3] = shadowMap;
else
render.device.Textures[3] = blank;
spotLightEffect.Parameters["shadowBufferSize"].SetValue(shadownBufferSize);
spotLightEffect.Parameters["BIAS"].SetValue(sl.SHADOWBIAS);
//spotLightEffect.Parameters["colorMap"].SetValue(DeferredGBuffer[GBufferTypes.COLOR]);
//spotLightEffect.Parameters["normalMap"].SetValue(DeferredGBuffer[GBufferTypes.NORMAL]);
//spotLightEffect.Parameters["depthMap"].SetValue(DeferredGBuffer[GBufferTypes.DEPH]);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
SamplerState s3 = render.SetSamplerState(SamplerState.PointClamp, 3);
spotLightEffect.Parameters["xLightViewProjection"].SetValue(sl.ViewMatrix * sl.ProjMatrix);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
spotLightEffect.Parameters["shadown"].SetValue(sl.CastShadown);
spotLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewProjection));
spotLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
spotLightEffect.Parameters["lightPosition"].SetValue(sl.Position);
spotLightEffect.Parameters["lightDirection"].SetValue(sl.Direction);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.PushDepthStencilState(DepthStencilState.None);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
render.PopDepthStencilState();
render.SetSamplerState(s2, 2);
render.SetSamplerState(s3, 3);
}
private void DrawPointLight(RenderHelper render, GraphicInfo ginfo, ICamera camera, PointLightPE pl, IDeferredGBuffer DeferredGBuffer,bool cullPointLight)
{
pointLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
pointLightEffect.Parameters["Projection"].SetValue(camera.Projection);
pointLightEffect.Parameters["View"].SetValue(camera.View);
pointLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
pointLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewProjection));
Matrix sphereWorldMatrix = Matrix.CreateScale(pl.LightRadius) * Matrix.CreateTranslation(pl.LightPosition);
ContainmentType ct = ContainmentType.Contains;
if (cullPointLight)
ct = camera.BoundingFrustum.Contains(new BoundingSphere(pl.LightPosition, pl.LightRadius));
if (ct == ContainmentType.Contains || ct == ContainmentType.Intersects)
{
pointLightEffect.Parameters["World"].SetValue(sphereWorldMatrix);
pointLightEffect.Parameters["lightPosition"].SetValue(pl.LightPosition);
pointLightEffect.Parameters["Color"].SetValue(pl.Color.ToVector3());
pointLightEffect.Parameters["lightRadius"].SetValue(pl.LightRadius);
pointLightEffect.Parameters["lightIntensity"].SetValue(pl.LightIntensity);
pointLightEffect.Parameters["quadratic"].SetValue(pl.UsePointLightQuadraticAttenuation);
float cameraToCenter = Vector3.Distance(camera.Position, pl.LightPosition);
if (cameraToCenter < pl.LightRadius + camera.NearPlane)
render.PushRasterizerState(RasterizerState.CullClockwise);
else
render.PushRasterizerState(RasterizerState.CullCounterClockwise);
render.RenderBatch(sphereModel.GetBatchInformation(0)[0], pointLightEffect);
render.PopRasterizerState();
}
render.SetSamplerState(s2, 2);
}
public void DrawScene(GameTime gameTime, IWorld world, IDeferredGBuffer gbuffer, IDeferredLightMap lightmap, RenderHelper render)
{
render.PushDepthStencilState(DepthStencilState.None);
PambientColor.SetValue(ambientColor.ToVector3());
render.device.Textures[0] = lightmap[DeferredLightMapType.LIGHTMAP];
SamplerState s0 = render.SetSamplerState(SamplerState.PointClamp, 0);
render.device.Textures[1] = gbuffer[GBufferTypes.Extra1];
render.device.Textures[2] = gbuffer[GBufferTypes.COLOR];
//PEXTRA1.SetValue(gbuffer[GBufferTypes.Extra1]);
//PcolorMap.SetValue(gbuffer[GBufferTypes.COLOR]);
//PlightMap.SetValue(lightmap[DeferredLightMapType.LIGHTMAP]);
render.RenderFullScreenQuadVertexPixel(finalCombineEffect);
render.SetSamplerState(s0, 0);
if (saveToTexture)
{
render.PopRenderTarget();
}
render.PopDepthStencilState();
}
protected void DrawnSpotLight(ICamera camera, IList<ILight> lights, IDeferredGBuffer DeferredGBuffer,RenderHelper render)
{
render.PushRasterizerState(RasterizerState.CullNone);
render.PushDepthStencilState(DepthStencilState.None);
render.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
ApplyFrustumCorners(directionalLightEffect.Parameters["FrustumCorners"], -Vector2.One, Vector2.One);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Spot && item.Enabled == true)
{
SpotLightPE sl = item as SpotLightPE;
Vector3 viewSpaceLPos = Vector3.Transform(sl.Position, camera.View);
Vector3 viewSpaceLDir = Vector3.Transform(sl.Direction, camera.View);
spotLightEffect.Parameters["lightPosition"].SetValue(viewSpaceLPos);
spotLightEffect.Parameters["lightDirection"].SetValue(viewSpaceLDir);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
}
}
render.PopDepthStencilState();
render.PopRasterizerState();
render.SetSamplerState(s2, 2);
}
private void DrawDirectionalLight(RenderHelper render, GraphicInfo ginfo, ICamera camera, DirectionalLightPE dl, IDeferredGBuffer DeferredGBuffer)
{
directionalLightEffect.Parameters["shadowBufferSize"].SetValue(shadownBufferSize);
if (dl.CastShadown)
{
//directionalLightEffect.Parameters["xShadowMap"].SetValue(shadowMap);
render.device.Textures[3] = shadowMap;
}
else
{
//directionalLightEffect.Parameters["xShadowMap"].SetValue(blank);
render.device.Textures[3] = blank;
}
//directionalLightEffect.Parameters["colorMap"].SetValue(DeferredGBuffer[GBufferTypes.COLOR]);
//directionalLightEffect.Parameters["normalMap"].SetValue(DeferredGBuffer[GBufferTypes.NORMAL]);
//directionalLightEffect.Parameters["depthMap"].SetValue(DeferredGBuffer[GBufferTypes.DEPH]);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
SamplerState s3 = render.SetSamplerState(SamplerState.PointClamp, 3);
directionalLightEffect.Parameters["View"].SetValue(camera.View);
directionalLightEffect.Parameters["Projection"].SetValue(camera.Projection);
directionalLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
directionalLightEffect.Parameters["shadown"].SetValue(dl.CastShadown);
directionalLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewProjection));
directionalLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
directionalLightEffect.Parameters["lightDirection"].SetValue(dl.LightDirection);
directionalLightEffect.Parameters["Color"].SetValue(dl.Color.ToVector3());
directionalLightEffect.Parameters["lightIntensity"].SetValue(dl.LightIntensity);
render.PushDepthStencilState(DepthStencilState.None);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
render.PopDepthStencilState();
render.SetSamplerState(s2, 2);
render.SetSamplerState(s3, 3);
}
protected void DrawDirectionalLight(ICamera camera, IList<ILight> lights, IDeferredGBuffer DeferredGBuffer,RenderHelper render)
{
ComputeFrustumCorners(camera);
ApplyFrustumCorners(directionalLightEffect.Parameters["FrustumCorners"], -Vector2.One, Vector2.One);
render.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
DirectionalhalfPixel.SetValue(ginfo.HalfPixel);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Directional && item.Enabled == true)
{
PloobsEngine.Light.DirectionalLightPE dl = item as PloobsEngine.Light.DirectionalLightPE;
Vector3 vldir = Vector3.Transform(dl.LightDirection, camera.View);
DirectionallightDirection.SetValue(vldir);
DirectionalColor.SetValue(dl.Color.ToVector3());
DirectionallightIntensity.SetValue(dl.LightIntensity);
render.RenderFullScreenQuadVertexPixel(directionalLightEffect);
}
}
render.SetSamplerState(s2, 2);
}
private void RenderShadowMap(GameTime gt, RenderHelper render, ref Matrix view, ref Matrix proj, IWorld world, IDeferredGBuffer deferredGBuffer)
{
render.PushRenderTarget(shadowRT);
render.Clear(Color.Transparent, ClearOptions.Target | ClearOptions.DepthBuffer, 1, 0);
render.RenderSceneDepth(world, gt, ref view, ref proj, true);
shadowMap = render.PopRenderTargetAsSingleRenderTarget2D();
}
/// <summary>
/// Renders a texture containing the final shadow occlusion
/// </summary>
protected void RenderShadowOcclusion(RenderHelper render, ICamera mainCamera,DirectionalLightPE dl, IDeferredGBuffer deferredGBuffer)
{
// Set the device to render to our shadow occlusion texture,
render.PushRenderTarget(shadowOcclusion);
Matrix cameraTransform = Matrix.Invert(mainCamera.View);
// We'll use these clip planes to determine which split a pixel belongs to
for (int i = 0; i < NumSplits; i++)
{
lightClipPlanes[i].X = -splitDepths[i];
lightClipPlanes[i].Y = -splitDepths[i + 1];
//lightCameras[i].GetViewProjMatrix(out lightViewProjectionMatrices[i]);
}
// Setup the Effect
shadowMapEffect.CurrentTechnique = shadowOcclusionTechniques[(int)filteringType];
shadowMapEffect.Parameters["g_matInvView"].SetValue(cameraTransform);
shadowMapEffect.Parameters["g_matLightViewProj"].SetValue(lightViewProjectionMatrices);
shadowMapEffect.Parameters["g_vFrustumCornersVS"].SetValue(farFrustumCornersVS);
shadowMapEffect.Parameters["g_vClipPlanes"].SetValue(lightClipPlanes);
shadowMapEffect.Parameters["ShadowMap"].SetValue(shadowMap);
shadowMapEffect.Parameters["DepthTexture"].SetValue(deferredGBuffer[GBufferTypes.DEPH]);
shadowMapEffect.Parameters["g_matInvProj"].SetValue(Matrix.Invert(mainCamera.Projection));
shadowMapEffect.Parameters["g_vOcclusionTextureSize"].SetValue(new Vector2(shadowOcclusion.Width, shadowOcclusion.Height));
shadowMapEffect.Parameters["g_vShadowMapSize"].SetValue(new Vector2(shadowMap.Width, shadowMap.Height));
shadowMapEffect.Parameters["g_bShowSplitColors"].SetValue(showCascadeSplits);
shadowMapEffect.Parameters["BIAS"].SetValue(dl.SHADOWBIAS);
// Draw the full screen quad
render.RenderFullScreenQuadVertexPixel(shadowMapEffect);
render.PopRenderTargetAsSingleRenderTarget2D();
//DeferredDebugImageRender dir2 = new DeferredDebugImageRender(new Rectangle(250, 0, 250, 250), shadowOcclusion.GetTexture());
//DeferredRenderTechnic.DebugImages.Add(dir2);
}
private void DrawPointLight(RenderHelper render, GraphicInfo ginfo, ICamera camera, PointLightPE pl, IDeferredGBuffer DeferredGBuffer, bool cullPointLight)
{
pointLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
pointLightEffect.Parameters["Projection"].SetValue(camera.Projection);
pointLightEffect.Parameters["View"].SetValue(camera.View);
pointLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
pointLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewProjection));
Matrix sphereWorldMatrix = Matrix.CreateScale(pl.LightRadius) * Matrix.CreateTranslation(pl.LightPosition);
ContainmentType ct = ContainmentType.Contains;
if (cullPointLight)
{
ct = camera.BoundingFrustum.Contains(new BoundingSphere(pl.LightPosition, pl.LightRadius));
}
if (ct == ContainmentType.Contains || ct == ContainmentType.Intersects)
{
pointLightEffect.Parameters["World"].SetValue(sphereWorldMatrix);
pointLightEffect.Parameters["lightPosition"].SetValue(pl.LightPosition);
pointLightEffect.Parameters["Color"].SetValue(pl.Color.ToVector3());
pointLightEffect.Parameters["lightRadius"].SetValue(pl.LightRadius);
pointLightEffect.Parameters["lightIntensity"].SetValue(pl.LightIntensity);
pointLightEffect.Parameters["quadratic"].SetValue(pl.UsePointLightQuadraticAttenuation);
float cameraToCenter = Vector3.Distance(camera.Position, pl.LightPosition);
if (cameraToCenter < pl.LightRadius + camera.NearPlane)
{
render.PushRasterizerState(RasterizerState.CullClockwise);
}
else
{
render.PushRasterizerState(RasterizerState.CullCounterClockwise);
}
render.RenderBatch(sphereModel.GetBatchInformation(0)[0], pointLightEffect);
render.PopRasterizerState();
}
render.SetSamplerState(s2, 2);
}
/// <summary>
/// Renders a list of models to the shadow map, and returns a surface
/// containing the shadow occlusion factor
/// </summary>
/// <param name="gameTime">The game time.</param>
/// <param name="render">The render.</param>
/// <param name="ginfo">The ginfo.</param>
/// <param name="light">The light for which the shadow is being calculated</param>
/// <param name="mainCamera">The camera viewing the scene containing the light</param>
/// <param name="world">The world.</param>
/// <param name="deferredGBuffer">The deferred G buffer.</param>
/// <returns>
/// The shadow occlusion texture
/// </returns>
internal RenderTarget2D Render(GameTime gameTime, RenderHelper render,GraphicInfo ginfo, DirectionalLightPE light,
ICamera mainCamera, IWorld world, IDeferredGBuffer deferredGBuffer)
{
vp = render.GetViewPort();
// Set our targets
render.PushRenderTarget(shadowMap);
render.Clear(Color.White,ClearOptions.Target, 1.0f, 0);
render.Clear(Color.Black, ClearOptions.DepthBuffer, 1.0f, 0);
// Get corners of the main camera's bounding frustum
Matrix cameraTransform, viewMatrix;
viewMatrix = mainCamera.View;
cameraTransform = Matrix.Invert(viewMatrix);
mainCamera.BoundingFrustum.GetCorners(frustumCornersWS);
Vector3.Transform(frustumCornersWS, ref viewMatrix, frustumCornersVS);
for (int i = 0; i < 4; i++)
farFrustumCornersVS[i] = frustumCornersVS[i + 4];
// Calculate the cascade splits. We calculate these so that each successive
// split is larger than the previous, giving the closest split the most amount
// of shadow detail.
float N = NumSplits;
float near = mainCamera.NearPlane, far = mainCamera.FarPlane;
splitDepths[0] = near;
splitDepths[NumSplits] = far;
for (int i = 1; i < splitDepths.Length - 1; i++)
splitDepths[i] = splitConstant * near * (float)Math.Pow(far / near, i / N) + (1.0f - splitConstant) * ((near + (i / N)) * (far - near));
// Render our scene geometry to each split of the cascade
for (int i = 0; i < NumSplits; i++)
{
float minZ = splitDepths[i];
float maxZ = splitDepths[i + 1];
CalculateFrustum(light, mainCamera, minZ, maxZ, out lightProjectionMatrices[i], out lightViewMatrices[i],out lightViewProjectionMatrices[i]);
RenderShadowMap(gameTime,render, i,world);
}
render.PopRenderTargetAsSingleRenderTarget2D();
render.SetViewPort(ginfo.Viewport);
RenderShadowOcclusion(render,mainCamera,light,deferredGBuffer);
return shadowOcclusion;
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Black,ClearOptions.Target);
render.PushBlendState(_lightAddBlendState);
render.PushDepthStencilState(DepthStencilState.None);
DrawDirectionalLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer,render);
DrawPointLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer,render);
DrawnSpotLight(world.CameraManager.ActiveCamera, world.Lights, deferredGBuffer,render);
render.PopBlendState();
render.PopDepthStencilState();
}
protected void DrawPointLight(ICamera camera, IList<ILight> lights, IDeferredGBuffer DeferredGBuffer,RenderHelper render)
{
render.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
PointcameraPosition.SetValue(camera.Position);
float _tanFovy = (float)Math.Tan(camera.FieldOfView /2);
pointLightEffect.Parameters["TanAspect"].SetValue(new Vector2(_tanFovy * camera.AspectRatio, -_tanFovy));
pointLightEffect.Parameters["farPlane"].SetValue(camera.FarPlane);
foreach (ILight item in lights)
{
if (item.LightType == LightType.Deferred_Point && item.Enabled == true)
{
PointLightPE pl = item as PointLightPE;
Matrix sphereWorldMatrix = Matrix.CreateScale(pl.LightRadius) * Matrix.CreateTranslation(pl.LightPosition);
ContainmentType ct = ContainmentType.Contains;
if(cullPointLight)
ct = camera.BoundingFrustum.Contains(new BoundingSphere(pl.LightPosition, pl.LightRadius ));
if (ct == ContainmentType.Contains || ct == ContainmentType.Intersects)
{
//convert light position into viewspace
Vector3 viewSpaceLPos = Vector3.Transform(pl.LightPosition,camera.View);
PointWordViewProjection.SetValue(sphereWorldMatrix * camera.ViewProjection);
PointlightPosition.SetValue(viewSpaceLPos);
PointColor.SetValue(pl.Color.ToVector3());
PointlightRadius.SetValue(pl.LightRadius);
PointlightIntensity.SetValue(pl.LightIntensity);
Pointquadratic.SetValue(pl.UsePointLightQuadraticAttenuation);
float cameraToCenter = Vector3.Distance(camera.Position, pl.LightPosition);
if (cameraToCenter < pl.LightRadius + camera.NearPlane)
render.PushRasterizerState(RasterizerState.CullClockwise);
else
render.PushRasterizerState(RasterizerState.CullCounterClockwise);
render.RenderBatch(sphereModel.GetBatchInformation(0)[0], pointLightEffect);
render.PopRasterizerState();
}
}
}
render.SetSamplerState(s2, 2);
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Transparent, ClearOptions.Target);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown == true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
shadowMap = shadow.Render(gameTime, render, ginfo, dl, world.CameraManager.ActiveCamera, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawDirectionalLight(render, ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
render.PopBlendState();
break;
case LightType.Deferred_Point:
#if WINDOWS
System.Diagnostics.Debug.Fail("Point Light Shadow not supported, in production no error will be created, the light just wont cast any shadow");
#endif
render.PushBlendState(_lightAddBlendState);
DrawPointLight(render, ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer, true);
render.PopBlendState();
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
Matrix v = sl.ViewMatrix;
Matrix p =sl.ProjMatrix;
RenderShadowMap(gameTime, render, ref v, ref p, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawnSpotLight(render, ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
render.PopBlendState();
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.DettachBindedTextures();
render.SetSamplerStates(ginfo.SamplerState);
render.PushBlendState(_lightAddBlendState);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown != true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
DrawDirectionalLight(render,ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
break;
case LightType.Deferred_Point:
DrawPointLight(render,ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer,true);
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
DrawnSpotLight(render,ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.PopBlendState();
}
public void DrawLights(GameTime gameTime, IWorld world, IDeferredGBuffer deferredGBuffer, RenderHelper render)
{
render.Clear(Color.Transparent, ClearOptions.Target);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown == true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
shadowMap = shadow.Render(gameTime, render, ginfo, dl, world.CameraManager.ActiveCamera, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawDirectionalLight(render, ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
render.PopBlendState();
break;
case LightType.Deferred_Point:
#if WINDOWS
System.Diagnostics.Debug.Fail("Point Light Shadow not supported, in production no error will be created, the light just wont cast any shadow");
#endif
render.PushBlendState(_lightAddBlendState);
DrawPointLight(render, ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer, true);
render.PopBlendState();
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
Matrix v = sl.ViewMatrix;
Matrix p = sl.ProjMatrix;
RenderShadowMap(gameTime, render, ref v, ref p, world, deferredGBuffer);
render.PushBlendState(_lightAddBlendState);
DrawnSpotLight(render, ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
render.PopBlendState();
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.DettachBindedTextures();
render.SetSamplerStates(ginfo.SamplerState);
render.PushBlendState(_lightAddBlendState);
foreach (ILight light in world.Lights.Where((a) => a.CastShadown != true && a.Enabled == true))
{
switch (light.LightType)
{
case LightType.Deferred_Directional:
DirectionalLightPE dl = light as DirectionalLightPE;
DrawDirectionalLight(render, ginfo, world.CameraManager.ActiveCamera, dl, deferredGBuffer);
break;
case LightType.Deferred_Point:
DrawPointLight(render, ginfo, world.CameraManager.ActiveCamera, light as PointLightPE, deferredGBuffer, true);
break;
case LightType.Deferred_Spot:
SpotLightPE sl = light as SpotLightPE;
DrawnSpotLight(render, ginfo, world.CameraManager.ActiveCamera, sl, deferredGBuffer);
break;
default:
throw new Exception("Light type Unexpected");
}
}
render.PopBlendState();
}
private void DrawnSpotLight(RenderHelper render, GraphicInfo ginfo, ICamera camera, SpotLightPE sl, IDeferredGBuffer DeferredGBuffer)
{
//if(sl.CastShadown)
// spotLightEffect.Parameters["xShadowMap"].SetValue(shadowMap);
//else
// spotLightEffect.Parameters["xShadowMap"].SetValue(blank);
if (sl.CastShadown)
{
render.device.Textures[3] = shadowMap;
}
else
{
render.device.Textures[3] = blank;
}
spotLightEffect.Parameters["shadowBufferSize"].SetValue(shadownBufferSize);
spotLightEffect.Parameters["BIAS"].SetValue(sl.SHADOWBIAS);
//spotLightEffect.Parameters["colorMap"].SetValue(DeferredGBuffer[GBufferTypes.COLOR]);
//spotLightEffect.Parameters["normalMap"].SetValue(DeferredGBuffer[GBufferTypes.NORMAL]);
//spotLightEffect.Parameters["depthMap"].SetValue(DeferredGBuffer[GBufferTypes.DEPH]);
render.device.Textures[0] = DeferredGBuffer[GBufferTypes.COLOR];
render.device.Textures[1] = DeferredGBuffer[GBufferTypes.NORMAL];
render.device.Textures[2] = DeferredGBuffer[GBufferTypes.DEPH];
SamplerState s2 = render.SetSamplerState(SamplerState.PointClamp, 2);
SamplerState s3 = render.SetSamplerState(SamplerState.PointClamp, 3);
spotLightEffect.Parameters["xLightViewProjection"].SetValue(sl.ViewMatrix * sl.ProjMatrix);
spotLightEffect.Parameters["View"].SetValue(camera.View);
spotLightEffect.Parameters["Projection"].SetValue(camera.Projection);
spotLightEffect.Parameters["cameraPosition"].SetValue(camera.Position);
spotLightEffect.Parameters["shadown"].SetValue(sl.CastShadown);
spotLightEffect.Parameters["InvertViewProjection"].SetValue(Matrix.Invert(camera.ViewProjection));
spotLightEffect.Parameters["halfPixel"].SetValue(ginfo.HalfPixel);
spotLightEffect.Parameters["lightPosition"].SetValue(sl.Position);
spotLightEffect.Parameters["lightDirection"].SetValue(sl.Direction);
spotLightEffect.Parameters["lightRadius"].SetValue(sl.LightRadius);
spotLightEffect.Parameters["lightDecayExponent"].SetValue(sl.ConeDecay);
spotLightEffect.Parameters["Color"].SetValue(sl.Color.ToVector3());
spotLightEffect.Parameters["lightAngleCosine"].SetValue(sl.LightAngleCosine);
spotLightEffect.Parameters["lightIntensity"].SetValue(sl.LightIntensity);
render.PushDepthStencilState(DepthStencilState.None);
render.RenderFullScreenQuadVertexPixel(spotLightEffect);
render.PopDepthStencilState();
render.SetSamplerState(s2, 2);
render.SetSamplerState(s3, 3);
}
/// <summary>
/// Renders a texture containing the final shadow occlusion
/// </summary>
protected void RenderShadowOcclusion(RenderHelper render, ICamera mainCamera, DirectionalLightPE dl, IDeferredGBuffer deferredGBuffer)
{
// Set the device to render to our shadow occlusion texture,
render.PushRenderTarget(shadowOcclusion);
Matrix cameraTransform = Matrix.Invert(mainCamera.View);
// We'll use these clip planes to determine which split a pixel belongs to
for (int i = 0; i < NumSplits; i++)
{
lightClipPlanes[i].X = -splitDepths[i];
lightClipPlanes[i].Y = -splitDepths[i + 1];
//lightCameras[i].GetViewProjMatrix(out lightViewProjectionMatrices[i]);
}
// Setup the Effect
shadowMapEffect.CurrentTechnique = shadowOcclusionTechniques[(int)filteringType];
shadowMapEffect.Parameters["g_matInvView"].SetValue(cameraTransform);
shadowMapEffect.Parameters["g_matLightViewProj"].SetValue(lightViewProjectionMatrices);
shadowMapEffect.Parameters["g_vFrustumCornersVS"].SetValue(farFrustumCornersVS);
shadowMapEffect.Parameters["g_vClipPlanes"].SetValue(lightClipPlanes);
shadowMapEffect.Parameters["ShadowMap"].SetValue(shadowMap);
shadowMapEffect.Parameters["DepthTexture"].SetValue(deferredGBuffer[GBufferTypes.DEPH]);
shadowMapEffect.Parameters["g_matInvProj"].SetValue(Matrix.Invert(mainCamera.Projection));
shadowMapEffect.Parameters["g_vOcclusionTextureSize"].SetValue(new Vector2(shadowOcclusion.Width, shadowOcclusion.Height));
shadowMapEffect.Parameters["g_vShadowMapSize"].SetValue(new Vector2(shadowMap.Width, shadowMap.Height));
shadowMapEffect.Parameters["g_bShowSplitColors"].SetValue(showCascadeSplits);
shadowMapEffect.Parameters["BIAS"].SetValue(dl.SHADOWBIAS);
// Draw the full screen quad
render.RenderFullScreenQuadVertexPixel(shadowMapEffect);
render.PopRenderTargetAsSingleRenderTarget2D();
//DeferredDebugImageRender dir2 = new DeferredDebugImageRender(new Rectangle(250, 0, 250, 250), shadowOcclusion.GetTexture());
//DeferredRenderTechnic.DebugImages.Add(dir2);
}
