Kav/Renderer.cs

984 lines
39 KiB
C#
Raw Normal View History

2020-10-19 10:01:37 +00:00
using System;
using System.Collections.Generic;
2020-10-17 20:53:26 +00:00
using System.IO;
2020-08-07 00:58:50 +00:00
using Microsoft.Xna.Framework;
2020-08-04 09:32:02 +00:00
using Microsoft.Xna.Framework.Graphics;
namespace Kav
{
2020-08-07 00:58:50 +00:00
public class Renderer
2020-08-04 09:32:02 +00:00
{
2020-12-07 22:58:03 +00:00
private const int MAX_INSTANCE_VERTEX_COUNT = 1000000;
2020-08-07 00:58:50 +00:00
private GraphicsDevice GraphicsDevice { get; }
private VertexBuffer FullscreenTriangle { get; }
private DeferredPBREffect DeferredPBREffect { get; }
/* FIXME: these next two dont actually have anything to do with PBR */
private DeferredPBR_GBufferEffect Deferred_GBufferEffect { get; }
private DeferredPBR_AmbientLightEffect DeferredAmbientLightEffect { get; }
private DeferredPBR_PointLightEffect DeferredPointLightEffect { get; }
private DeferredPBR_DirectionalLightEffect DeferredDirectionalLightEffect { get; }
private Deferred_ToonEffect Deferred_ToonEffect { get; }
2020-08-07 00:58:50 +00:00
private SimpleDepthEffect SimpleDepthEffect { get; }
private SimpleDepthEffectInstanced SimpleDepthEffectInstanced { get; }
2020-10-19 10:01:37 +00:00
private LinearDepthEffect LinearDepthEffect { get; }
private Effect ToneMapEffect { get; }
2020-10-17 20:53:26 +00:00
private SkyboxEffect SkyboxEffect { get; }
2020-12-06 03:47:01 +00:00
private DiffuseLitSpriteEffect DiffuseLitSpriteEffect { get; }
2020-08-07 00:58:50 +00:00
2020-10-17 20:53:26 +00:00
private Kav.Model UnitCube { get; }
private DynamicVertexBuffer PositionInstanceVertexBuffer { get; }
2020-12-08 11:35:06 +00:00
private readonly PositionInstanceVertex[] PositionInstanceVertices = new PositionInstanceVertex[MAX_INSTANCE_VERTEX_COUNT];
public Renderer(
2020-12-08 05:36:16 +00:00
GraphicsDevice graphicsDevice
) {
2020-08-07 00:58:50 +00:00
GraphicsDevice = graphicsDevice;
SimpleDepthEffect = new SimpleDepthEffect(GraphicsDevice);
SimpleDepthEffectInstanced = new SimpleDepthEffectInstanced(GraphicsDevice);
2020-10-19 10:01:37 +00:00
LinearDepthEffect = new LinearDepthEffect(GraphicsDevice);
DeferredPBREffect = new DeferredPBREffect(GraphicsDevice);
Deferred_GBufferEffect = new DeferredPBR_GBufferEffect(GraphicsDevice);
DeferredAmbientLightEffect = new DeferredPBR_AmbientLightEffect(GraphicsDevice);
DeferredPointLightEffect = new DeferredPBR_PointLightEffect(GraphicsDevice);
DeferredDirectionalLightEffect = new DeferredPBR_DirectionalLightEffect(GraphicsDevice);
ToneMapEffect = new Effect(graphicsDevice, Resources.ToneMapEffect);
Deferred_ToonEffect = new Deferred_ToonEffect(GraphicsDevice);
2020-10-17 20:53:26 +00:00
SkyboxEffect = new SkyboxEffect(GraphicsDevice);
2020-12-06 03:47:01 +00:00
DiffuseLitSpriteEffect = new DiffuseLitSpriteEffect(GraphicsDevice);
FullscreenTriangle = new VertexBuffer(GraphicsDevice, typeof(VertexPositionTexture), 3, BufferUsage.WriteOnly);
FullscreenTriangle.SetData(new VertexPositionTexture[3] {
new VertexPositionTexture(new Vector3(-1, -3, 0), new Vector2(0, 2)),
new VertexPositionTexture(new Vector3(-1, 1, 0), new Vector2(0, 0)),
new VertexPositionTexture(new Vector3(3, 1, 0), new Vector2(2, 0))
});
2020-10-17 20:53:26 +00:00
UnitCube = Kav.ModelLoader.Load(
GraphicsDevice,
Smuggler.Importer.ImportGLB(GraphicsDevice, new MemoryStream(Resources.UnitCubeModel))
);
PositionInstanceVertexBuffer = new DynamicVertexBuffer(
GraphicsDevice,
VertexDeclarations.PositionInstanceDeclaration,
MAX_INSTANCE_VERTEX_COUNT,
BufferUsage.WriteOnly
);
}
2020-12-08 05:36:16 +00:00
public static RenderTargetCube CreateShadowCubeMap(
GraphicsDevice graphicsDevice,
int shadowMapSize
) {
return new RenderTargetCube(
graphicsDevice,
shadowMapSize,
false,
SurfaceFormat.Single,
DepthFormat.Depth24,
0,
RenderTargetUsage.PreserveContents
);
}
public static DirectionalShadowMapData CreateDirectionalShadowMaps(
GraphicsDevice graphicsDevice,
int shadowMapSize,
int numCascades
) {
return new DirectionalShadowMapData(
graphicsDevice,
shadowMapSize,
numCascades
);
}
// TODO: we could make this a lot more efficient probably
// draws mesh sprites with a forward rendered diffuse lighting technique
public void MeshSpriteRender(
2020-12-04 23:39:29 +00:00
RenderTarget2D renderTarget,
PerspectiveCamera camera,
IEnumerable<(MeshSprite, SpriteBillboardConstraint, Matrix)> meshSpriteBillboardTransforms,
2020-12-06 03:47:01 +00:00
AmbientLight ambientLight,
IEnumerable<PointLight> pointLights,
DirectionalLight? directionalLight
2020-12-04 23:39:29 +00:00
) {
2020-12-08 02:46:53 +00:00
GraphicsDevice.SetRenderTarget(renderTarget);
2020-12-04 23:39:29 +00:00
GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
GraphicsDevice.RasterizerState = RasterizerState.CullNone;
GraphicsDevice.SamplerStates[0] = SamplerState.PointClamp;
GraphicsDevice.SamplerStates[1] = SamplerState.PointClamp;
GraphicsDevice.BlendState = BlendState.AlphaBlend;
2020-12-06 03:47:01 +00:00
DiffuseLitSpriteEffect.View = camera.View;
DiffuseLitSpriteEffect.Projection = camera.Projection;
2020-12-06 03:58:29 +00:00
DiffuseLitSpriteEffect.AmbientColor =
ambientLight.Color.ToVector3();
if (directionalLight.HasValue)
{
DiffuseLitSpriteEffect.DirectionalLightDirection =
directionalLight.Value.Direction;
DiffuseLitSpriteEffect.DirectionalLightColor =
directionalLight.Value.Color.ToVector3() * directionalLight.Value.Intensity;
}
else
{
DiffuseLitSpriteEffect.DirectionalLightColor = Vector3.Zero;
}
2020-12-06 03:47:01 +00:00
var i = 0;
foreach (var pointLight in pointLights)
{
if (i > DiffuseLitSpriteEffect.MaxPointLights) { break; }
DiffuseLitSpriteEffect.PointLights[i] = pointLight;
i += 1;
}
2020-12-04 23:39:29 +00:00
2020-12-07 03:27:46 +00:00
var boundingFrustum = new BoundingFrustum(camera.View * camera.Projection);
foreach (var (sprite, transform) in FrustumCull(boundingFrustum, BillboardTransforms(camera, meshSpriteBillboardTransforms)))
2020-12-04 23:39:29 +00:00
{
DiffuseLitSpriteEffect.NormalMapEnabled = sprite.Normal != null;
DiffuseLitSpriteEffect.World = transform;
GraphicsDevice.Textures[0] = sprite.Texture;
GraphicsDevice.Textures[1] = sprite.Normal;
2020-12-04 23:39:29 +00:00
GraphicsDevice.SetVertexBuffer(sprite.VertexBuffer);
GraphicsDevice.Indices = sprite.IndexBuffer;
foreach (var pass in DiffuseLitSpriteEffect.CurrentTechnique.Passes)
{
pass.Apply();
GraphicsDevice.DrawIndexedPrimitives(
PrimitiveType.TriangleList,
0,
0,
sprite.VertexBuffer.VertexCount,
0,
2
);
}
}
2020-12-04 23:39:29 +00:00
}
private IEnumerable<(MeshSprite, Matrix)> BillboardTransforms(
PerspectiveCamera camera,
IEnumerable<(MeshSprite, SpriteBillboardConstraint, Matrix)> meshSpriteBillboardTransforms
) {
foreach (var (sprite, billboardConstraint, transform) in meshSpriteBillboardTransforms)
{
if (billboardConstraint == SpriteBillboardConstraint.None)
{
yield return (sprite, transform);
}
else if (billboardConstraint == SpriteBillboardConstraint.Horizontal)
{
yield return (sprite, Matrix.CreateConstrainedBillboard(
transform.Translation,
camera.Position,
Vector3.Up,
camera.Forward,
camera.Position - transform.Translation
));
}
else
{
yield return (sprite, Matrix.CreateConstrainedBillboard(
transform.Translation,
camera.Position,
Vector3.Up,
null,
null
));
}
}
}
2020-12-08 04:10:27 +00:00
// Renders a series of drawable-transform pairs using an effect that has a World matrix.
// Effect must be pre-configured!!
public static void CullAndRenderIndexed<T, U>(
GraphicsDevice graphicsDevice,
BoundingFrustum boundingFrustum,
2020-12-08 04:10:27 +00:00
IEnumerable<(T, Matrix)> drawableTransformPairs,
U effect
) where T : IIndexDrawable, ICullable where U : Effect, IHasWorldMatrix
{
foreach (var (drawable, transform) in FrustumCull(boundingFrustum, drawableTransformPairs))
{
effect.World = transform;
RenderIndexed(
graphicsDevice,
drawable,
effect
);
}
}
public static void RenderIndexed<T, U>(
GraphicsDevice graphicsDevice,
T drawable,
U effect
) where T : IIndexDrawable where U : Effect
{
graphicsDevice.SetVertexBuffer(drawable.VertexBuffer);
graphicsDevice.Indices = drawable.IndexBuffer;
foreach (var pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
graphicsDevice.DrawIndexedPrimitives(
PrimitiveType.TriangleList,
0,
0,
drawable.VertexBuffer.VertexCount,
0,
drawable.IndexBuffer.IndexCount / 3
);
}
}
2020-12-08 04:10:27 +00:00
public static int FillAndSetBuffersForInstancing<T, V>(
GraphicsDevice graphicsDevice,
T drawable,
IEnumerable<Matrix> transforms,
V[] vertexData,
DynamicVertexBuffer dynamicVertexBuffer
) where T : ICullable, IIndexDrawable where V : struct, IVertexType, IHasTranslation
2020-12-08 04:10:27 +00:00
{
int numInstances = 0;
foreach (var transform in transforms)
2020-10-17 20:53:26 +00:00
{
vertexData[numInstances].Translation = transform.Translation;
2020-12-08 04:10:27 +00:00
numInstances += 1;
}
2020-10-17 20:53:26 +00:00
2020-12-08 04:10:27 +00:00
if (numInstances == 0) { return 0; }
2020-10-17 20:53:26 +00:00
2020-12-08 04:10:27 +00:00
dynamicVertexBuffer.SetData(
vertexData,
0,
numInstances,
SetDataOptions.Discard
);
2020-10-17 20:53:26 +00:00
2020-12-08 04:10:27 +00:00
graphicsDevice.SetVertexBuffers(
drawable.VertexBuffer,
new VertexBufferBinding(dynamicVertexBuffer, 0, 1)
);
graphicsDevice.Indices = drawable.IndexBuffer;
return numInstances;
}
public static void RenderInstanced<T, U>(
GraphicsDevice graphicsDevice,
T drawable,
U effect,
int numInstances
) where T : ICullable, IIndexDrawable where U : Effect
{
foreach (var pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
graphicsDevice.DrawInstancedPrimitives(
PrimitiveType.TriangleList,
0,
0,
drawable.VertexBuffer.VertexCount,
0,
drawable.IndexBuffer.IndexCount / 3,
numInstances
);
}
}
// TODO: can probably make this static somehow
public void RenderFullscreenEffect(
Effect effect
) {
foreach (var pass in effect.CurrentTechnique.Passes)
{
pass.Apply();
GraphicsDevice.SetVertexBuffer(FullscreenTriangle);
GraphicsDevice.DrawPrimitives(PrimitiveType.TriangleList, 0, 1);
2020-10-17 20:53:26 +00:00
}
}
2020-12-08 05:36:16 +00:00
public void RenderDepthIndexed<T>(
2020-12-08 04:10:27 +00:00
RenderTarget2D renderTarget,
PerspectiveCamera camera,
IEnumerable<(T, Matrix)> drawableTransforms
) where T : ICullable, IIndexDrawable
{
GraphicsDevice.SetRenderTarget(renderTarget);
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
SimpleDepthEffect.View = camera.View;
SimpleDepthEffect.Projection = camera.Projection;
CullAndRenderIndexed(
GraphicsDevice,
new BoundingFrustum(camera.View * camera.Projection),
2020-12-08 04:10:27 +00:00
drawableTransforms,
SimpleDepthEffect
);
}
public void RenderSkybox(
RenderTarget2D renderTarget,
2020-10-17 20:53:26 +00:00
PerspectiveCamera camera,
TextureCube skybox
) {
GraphicsDevice.SetRenderTarget(renderTarget);
2020-10-17 20:53:26 +00:00
GraphicsDevice.RasterizerState.CullMode = CullMode.CullClockwiseFace;
2020-12-08 02:46:53 +00:00
GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
2020-10-19 21:00:11 +00:00
SkyboxEffect.Skybox = skybox;
2020-10-17 20:53:26 +00:00
var view = camera.View;
view.Translation = Vector3.Zero;
2020-12-08 04:10:27 +00:00
SkyboxEffect.View = view;
2020-10-17 20:53:26 +00:00
SkyboxEffect.Projection = camera.Projection;
2020-12-08 04:10:27 +00:00
RenderIndexed(
GraphicsDevice,
UnitCube.Meshes[0].MeshParts[0],
SkyboxEffect
);
2020-10-17 20:53:26 +00:00
GraphicsDevice.RasterizerState.CullMode = CullMode.CullCounterClockwiseFace;
}
/// <summary>
/// GBuffer binding must have 4 render targets.
/// </summary>
2020-12-08 04:10:27 +00:00
public void RenderGBufferInstanced<T>(
RenderTargetBinding[] gBuffer,
2020-12-08 02:46:53 +00:00
RenderTarget2D depthBuffer,
PerspectiveCamera camera,
T drawable,
IEnumerable<Matrix> transforms
2020-12-07 22:58:03 +00:00
) where T : ICullable, IIndexDrawable, IGBufferDrawable {
GraphicsDevice.SetRenderTargets(gBuffer);
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
GraphicsDevice.BlendState = BlendState.Opaque;
2020-12-07 21:50:32 +00:00
Deferred_GBufferEffect.HardwareInstancingEnabled = true;
Deferred_GBufferEffect.Albedo = drawable.Albedo;
Deferred_GBufferEffect.Metallic = drawable.Metallic;
Deferred_GBufferEffect.Roughness = drawable.Roughness;
Deferred_GBufferEffect.AlbedoTexture = drawable.AlbedoTexture;
Deferred_GBufferEffect.NormalTexture = drawable.NormalTexture;
Deferred_GBufferEffect.MetallicRoughnessTexture = drawable.MetallicRoughnessTexture;
2020-12-07 21:50:32 +00:00
Deferred_GBufferEffect.View = camera.View;
Deferred_GBufferEffect.Projection = camera.Projection;
2020-12-08 04:10:27 +00:00
var numInstances = FillAndSetBuffersForInstancing(
GraphicsDevice,
drawable,
transforms,
2020-12-08 11:35:06 +00:00
PositionInstanceVertices,
PositionInstanceVertexBuffer
);
if (numInstances == 0) { return; }
2020-12-08 04:10:27 +00:00
RenderInstanced(
GraphicsDevice,
drawable,
Deferred_GBufferEffect,
numInstances
);
2020-12-08 02:46:53 +00:00
2020-12-08 04:10:27 +00:00
// re-render to get depth
GraphicsDevice.SetRenderTargets(depthBuffer);
SimpleDepthEffectInstanced.View = camera.View;
SimpleDepthEffectInstanced.Projection = camera.Projection;
2020-12-08 02:46:53 +00:00
2020-12-08 04:10:27 +00:00
RenderInstanced(
GraphicsDevice,
drawable,
SimpleDepthEffectInstanced,
2020-12-08 04:10:27 +00:00
numInstances
);
}
2020-12-08 04:10:27 +00:00
public void RenderGBufferIndexed<T>(
RenderTargetBinding[] gBuffer,
PerspectiveCamera camera,
2020-12-08 04:10:27 +00:00
IEnumerable<(T, Matrix)> drawableTransforms
) where T : ICullable, IIndexDrawable, IGBufferDrawable {
GraphicsDevice.SetRenderTargets(gBuffer);
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
GraphicsDevice.BlendState = BlendState.Opaque;
2020-12-08 04:10:27 +00:00
Deferred_GBufferEffect.HardwareInstancingEnabled = false;
Deferred_GBufferEffect.View = camera.View;
Deferred_GBufferEffect.Projection = camera.Projection;
2020-10-20 01:22:54 +00:00
var boundingFrustum = new BoundingFrustum(camera.View * camera.Projection);
2020-12-08 04:10:27 +00:00
foreach (var (drawable, transform) in FrustumCull(boundingFrustum, drawableTransforms))
{
2020-12-08 04:10:27 +00:00
Deferred_GBufferEffect.World = transform;
2020-12-08 04:10:27 +00:00
Deferred_GBufferEffect.HardwareInstancingEnabled = false;
2020-12-07 21:50:32 +00:00
2020-12-08 04:10:27 +00:00
Deferred_GBufferEffect.Albedo = drawable.Albedo;
Deferred_GBufferEffect.Metallic = drawable.Metallic;
Deferred_GBufferEffect.Roughness = drawable.Roughness;
2020-12-08 04:10:27 +00:00
Deferred_GBufferEffect.AlbedoTexture = drawable.AlbedoTexture;
Deferred_GBufferEffect.NormalTexture = drawable.NormalTexture;
Deferred_GBufferEffect.MetallicRoughnessTexture = drawable.MetallicRoughnessTexture;
2020-12-08 04:10:27 +00:00
RenderIndexed(GraphicsDevice, drawable, Deferred_GBufferEffect);
}
}
2020-12-08 04:10:27 +00:00
public void RenderAmbientLight(
RenderTarget2D renderTarget,
Texture2D gPosition,
Texture2D gAlbedo,
AmbientLight ambientLight
) {
GraphicsDevice.SetRenderTarget(renderTarget);
2020-10-17 20:53:26 +00:00
GraphicsDevice.BlendState = BlendState.Opaque;
GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
DeferredAmbientLightEffect.GPosition = gPosition;
DeferredAmbientLightEffect.GAlbedo = gAlbedo;
DeferredAmbientLightEffect.AmbientColor = ambientLight.Color.ToVector3();
2020-12-08 04:10:27 +00:00
RenderFullscreenEffect(DeferredAmbientLightEffect);
2020-08-07 00:58:50 +00:00
}
2020-12-08 05:36:16 +00:00
public void RenderPointLight(
RenderTarget2D renderTarget,
Texture2D gPosition,
Texture2D gAlbedo,
Texture2D gNormal,
Texture2D gMetallicRoughness,
2020-12-08 05:36:16 +00:00
TextureCube shadowMap,
2020-10-19 10:01:37 +00:00
PerspectiveCamera camera,
PointLight pointLight
2020-12-08 05:36:16 +00:00
) {
GraphicsDevice.SetRenderTarget(renderTarget);
2020-10-19 10:01:37 +00:00
GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
GraphicsDevice.BlendState = BlendState.Additive;
DeferredPointLightEffect.GPosition = gPosition;
DeferredPointLightEffect.GAlbedo = gAlbedo;
DeferredPointLightEffect.GNormal = gNormal;
2020-12-04 23:39:29 +00:00
DeferredPointLightEffect.GMetallicRoughness = gMetallicRoughness;
2020-12-08 05:36:16 +00:00
DeferredPointLightEffect.ShadowMap = shadowMap;
DeferredPointLightEffect.EyePosition = camera.Position;
DeferredPointLightEffect.PointLightPosition = pointLight.Position;
2020-12-04 23:39:29 +00:00
DeferredPointLightEffect.PointLightColor =
pointLight.Color.ToVector3() * pointLight.Intensity;
2020-10-19 10:01:37 +00:00
DeferredPointLightEffect.FarPlane = 25f; // FIXME: magic value
2020-12-08 04:10:27 +00:00
RenderFullscreenEffect(DeferredPointLightEffect);
}
public void RenderDirectionalLight(
RenderTarget2D renderTarget,
Texture2D gPosition,
Texture2D gAlbedo,
Texture2D gNormal,
Texture2D gMetallicRoughness,
DirectionalShadowMapData shadowMapData,
PerspectiveCamera camera,
DirectionalLight directionalLight
) {
GraphicsDevice.SetRenderTarget(renderTarget);
GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
GraphicsDevice.BlendState = BlendState.Additive;
DeferredDirectionalLightEffect.GPosition = gPosition;
DeferredDirectionalLightEffect.GAlbedo = gAlbedo;
DeferredDirectionalLightEffect.GNormal = gNormal;
DeferredDirectionalLightEffect.GMetallicRoughness = gMetallicRoughness;
2020-12-08 05:36:16 +00:00
DeferredDirectionalLightEffect.ShadowMapSize = shadowMapData.ShadowMapSize;
DeferredDirectionalLightEffect.ShadowMapOne = shadowMapData.ShadowMaps[0];
2020-12-08 11:07:41 +00:00
DeferredDirectionalLightEffect.LightSpaceMatrixOne = shadowMapData.LightSpaceViews[0] * shadowMapData.LightSpaceProjections[0];
DeferredDirectionalLightEffect.CascadeFarPlanes[0] = shadowMapData.CascadeFarPlanes[0];
2020-12-08 05:36:16 +00:00
if (shadowMapData.NumShadowCascades > 1)
{
2020-12-08 05:36:16 +00:00
DeferredDirectionalLightEffect.ShadowMapTwo = shadowMapData.ShadowMaps[1];
2020-12-08 11:07:41 +00:00
DeferredDirectionalLightEffect.LightSpaceMatrixTwo = shadowMapData.LightSpaceViews[1] * shadowMapData.LightSpaceProjections[1];
DeferredDirectionalLightEffect.CascadeFarPlanes[1] = shadowMapData.CascadeFarPlanes[1];
}
2020-12-08 05:36:16 +00:00
if (shadowMapData.NumShadowCascades > 2)
{
2020-12-08 05:36:16 +00:00
DeferredDirectionalLightEffect.ShadowMapThree = shadowMapData.ShadowMaps[2];
2020-12-08 11:07:41 +00:00
DeferredDirectionalLightEffect.LightSpaceMatrixThree = shadowMapData.LightSpaceViews[2] * shadowMapData.LightSpaceProjections[2];
DeferredDirectionalLightEffect.CascadeFarPlanes[2] = shadowMapData.CascadeFarPlanes[2];
}
2020-12-08 05:36:16 +00:00
if (shadowMapData.NumShadowCascades > 3)
{
2020-12-08 05:36:16 +00:00
DeferredDirectionalLightEffect.ShadowMapFour = shadowMapData.ShadowMaps[3];
2020-12-08 11:07:41 +00:00
DeferredDirectionalLightEffect.LightSpaceMatrixFour = shadowMapData.LightSpaceViews[3] * shadowMapData.LightSpaceProjections[3];
DeferredDirectionalLightEffect.CascadeFarPlanes[3] = shadowMapData.CascadeFarPlanes[3];
}
2020-12-04 23:39:29 +00:00
DeferredDirectionalLightEffect.DirectionalLightDirection = directionalLight.Direction;
2020-12-04 23:39:29 +00:00
DeferredDirectionalLightEffect.DirectionalLightColor =
directionalLight.Color.ToVector3() * directionalLight.Intensity;
2020-12-04 23:39:29 +00:00
DeferredDirectionalLightEffect.ViewMatrix = camera.View;
2020-10-02 19:28:28 +00:00
DeferredDirectionalLightEffect.EyePosition = camera.Position;
2020-12-08 04:10:27 +00:00
RenderFullscreenEffect(DeferredDirectionalLightEffect);
2020-08-07 00:58:50 +00:00
}
public void RenderDirectionalLightToon(
RenderTarget2D renderTarget,
Texture2D gPosition,
Texture2D gAlbedo,
Texture2D gNormal,
Texture2D gMetallicRoughness,
2020-12-08 05:36:16 +00:00
DirectionalShadowMapData shadowMapData,
PerspectiveCamera camera,
DirectionalLight directionalLight,
bool ditheredShadows
) {
GraphicsDevice.SetRenderTarget(renderTarget);
2020-10-17 20:53:26 +00:00
GraphicsDevice.DepthStencilState = DepthStencilState.DepthRead;
GraphicsDevice.BlendState = BlendState.Additive;
2020-10-02 19:28:28 +00:00
Deferred_ToonEffect.GPosition = gPosition;
Deferred_ToonEffect.GAlbedo = gAlbedo;
Deferred_ToonEffect.GNormal = gNormal;
Deferred_ToonEffect.GMetallicRoughness = gMetallicRoughness;
2020-10-02 19:28:28 +00:00
Deferred_ToonEffect.DitheredShadows = ditheredShadows;
2020-10-16 01:19:43 +00:00
Deferred_ToonEffect.EyePosition = camera.Position;
Deferred_ToonEffect.DirectionalLightDirection = directionalLight.Direction;
2020-12-04 23:39:29 +00:00
Deferred_ToonEffect.DirectionalLightColor =
directionalLight.Color.ToVector3() * directionalLight.Intensity;
2020-12-08 05:36:16 +00:00
Deferred_ToonEffect.ShadowMapOne = shadowMapData.ShadowMaps[0];
2020-12-08 11:07:41 +00:00
Deferred_ToonEffect.LightSpaceMatrixOne = shadowMapData.LightSpaceViews[0] * shadowMapData.LightSpaceProjections[0];
2020-12-08 05:36:16 +00:00
if (shadowMapData.NumShadowCascades > 1)
2020-10-02 19:28:28 +00:00
{
2020-12-08 05:36:16 +00:00
Deferred_ToonEffect.ShadowMapTwo = shadowMapData.ShadowMaps[1];
2020-12-08 11:07:41 +00:00
Deferred_ToonEffect.LightSpaceMatrixTwo = shadowMapData.LightSpaceViews[1] * shadowMapData.LightSpaceProjections[1];
2020-10-02 19:28:28 +00:00
}
2020-12-08 05:36:16 +00:00
if (shadowMapData.NumShadowCascades > 2)
2020-10-02 19:28:28 +00:00
{
2020-12-08 05:36:16 +00:00
Deferred_ToonEffect.ShadowMapThree = shadowMapData.ShadowMaps[2];
2020-12-08 11:07:41 +00:00
Deferred_ToonEffect.LightSpaceMatrixThree = shadowMapData.LightSpaceViews[1] * shadowMapData.LightSpaceProjections[2];
2020-10-02 19:28:28 +00:00
}
2020-12-08 05:36:16 +00:00
if (shadowMapData.NumShadowCascades > 3)
2020-10-02 19:28:28 +00:00
{
2020-12-08 05:36:16 +00:00
Deferred_ToonEffect.ShadowMapFour = shadowMapData.ShadowMaps[3];
2020-12-08 11:07:41 +00:00
Deferred_ToonEffect.LightSpaceMatrixFour = shadowMapData.LightSpaceViews[2] * shadowMapData.LightSpaceProjections[3];
2020-10-02 19:28:28 +00:00
}
2020-12-04 23:39:29 +00:00
2020-10-02 19:28:28 +00:00
Deferred_ToonEffect.ViewMatrix = camera.View;
2020-12-08 04:10:27 +00:00
RenderFullscreenEffect(Deferred_ToonEffect);
}
2020-12-08 11:07:41 +00:00
public void PrepareDirectionalShadowData(
2020-12-08 05:36:16 +00:00
DirectionalShadowMapData shadowMapData,
2020-10-02 19:28:28 +00:00
PerspectiveCamera camera,
2020-12-08 05:36:16 +00:00
DirectionalLight directionalLight
2020-12-08 11:07:41 +00:00
) {
2020-10-02 19:28:28 +00:00
var previousFarPlane = camera.NearPlane;
2020-12-08 05:36:16 +00:00
for (var i = 0; i < shadowMapData.NumShadowCascades; i++)
2020-10-02 19:28:28 +00:00
{
2020-12-08 05:36:16 +00:00
var farPlane = camera.FarPlane / (MathHelper.Max((shadowMapData.NumShadowCascades - i - 1) * 2f, 1f));
2020-10-02 19:28:28 +00:00
2020-12-04 23:39:29 +00:00
// divide the view frustum
2020-10-02 19:28:28 +00:00
var shadowCamera = new PerspectiveCamera(
camera.Position,
camera.Forward,
camera.Up,
camera.FieldOfView,
camera.AspectRatio,
previousFarPlane,
farPlane
);
2020-12-04 23:39:29 +00:00
2020-12-08 11:07:41 +00:00
PrepareDirectionalShadowCascade(
shadowMapData,
i,
shadowCamera,
2020-12-08 05:36:16 +00:00
directionalLight
);
2020-10-02 19:28:28 +00:00
2020-12-08 05:36:16 +00:00
shadowMapData.CascadeFarPlanes[i] = farPlane;
2020-10-02 19:28:28 +00:00
previousFarPlane = farPlane;
}
}
2020-12-08 11:07:41 +00:00
private void PrepareDirectionalShadowCascade(
2020-12-08 05:36:16 +00:00
DirectionalShadowMapData shadowMapData,
int shadowCascadeIndex,
2020-12-08 11:07:41 +00:00
PerspectiveCamera shadowCamera,
2020-12-08 05:36:16 +00:00
DirectionalLight directionalLight
2020-12-08 11:07:41 +00:00
) {
var cameraBoundingFrustum = new BoundingFrustum(shadowCamera.View * shadowCamera.Projection);
Vector3[] frustumCorners = cameraBoundingFrustum.GetCorners();
Vector3 frustumCenter = Vector3.Zero;
for (var i = 0; i < frustumCorners.Length; i++)
{
frustumCenter += frustumCorners[i];
}
frustumCenter /= 8f;
2020-08-07 00:58:50 +00:00
var lightView = Matrix.CreateLookAt(frustumCenter + directionalLight.Direction, frustumCenter, Vector3.Backward);
for (var i = 0; i < frustumCorners.Length; i++)
{
frustumCorners[i] = Vector3.Transform(frustumCorners[i], lightView);
}
BoundingBox lightBox = BoundingBox.CreateFromPoints(frustumCorners);
2020-12-04 23:39:29 +00:00
2020-12-08 11:07:41 +00:00
shadowMapData.LightSpaceViews[shadowCascadeIndex] = lightView;
shadowMapData.LightSpaceProjections[shadowCascadeIndex] = Matrix.CreateOrthographicOffCenter(
lightBox.Min.X,
lightBox.Max.X,
lightBox.Min.Y,
lightBox.Max.Y,
-lightBox.Max.Z - 10f, // TODO: near clip plane needs scene AABB info to get rid of this magic value
-lightBox.Min.Z
);
2020-12-08 11:07:41 +00:00
}
2020-12-08 11:07:41 +00:00
public void RenderDirectionalShadowsIndexed<T>(
DirectionalShadowMapData shadowMapData,
IEnumerable<(T, Matrix)> drawableTransforms
) where T : ICullable, IIndexDrawable {
// render the individual shadow cascades
for (var i = 0; i < shadowMapData.NumShadowCascades; i++)
{
2020-12-08 11:07:41 +00:00
RenderDirectionalShadowMapIndexed(
shadowMapData,
i,
drawableTransforms
);
}
2020-12-08 11:07:41 +00:00
}
2020-12-08 11:35:06 +00:00
private void RenderDirectionalShadowMapIndexed<T>(
2020-12-08 11:07:41 +00:00
DirectionalShadowMapData shadowMapData,
int shadowCascadeIndex,
IEnumerable<(T, Matrix)> drawableTransforms
) where T : ICullable, IIndexDrawable {
GraphicsDevice.SetRenderTarget(shadowMapData.ShadowMaps[shadowCascadeIndex]);
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
GraphicsDevice.BlendState = BlendState.Opaque;
SimpleDepthEffect.View = shadowMapData.LightSpaceViews[shadowCascadeIndex];
SimpleDepthEffect.Projection = shadowMapData.LightSpaceProjections[shadowCascadeIndex];
CullAndRenderIndexed(
GraphicsDevice,
2020-12-08 11:07:41 +00:00
new BoundingFrustum(SimpleDepthEffect.View * SimpleDepthEffect.Projection),
drawableTransforms,
SimpleDepthEffect
);
2020-08-07 00:58:50 +00:00
}
2020-10-19 10:01:37 +00:00
2020-12-08 11:35:06 +00:00
public void RenderDirectionalShadowsInstanced<T>(
DirectionalShadowMapData shadowMapData,
T drawable,
IEnumerable<Matrix> transforms
) where T : ICullable, IIndexDrawable
{
// render the individual shadow cascades
for (var i = 0; i < shadowMapData.NumShadowCascades; i++)
{
RenderDirectionalShadowMapInstanced(
shadowMapData,
i,
drawable,
transforms
);
}
}
private void RenderDirectionalShadowMapInstanced<T>(
DirectionalShadowMapData shadowMapData,
int shadowCascadeIndex,
T drawable,
IEnumerable<Matrix> transforms
) where T : ICullable, IIndexDrawable
{
GraphicsDevice.SetRenderTarget(shadowMapData.ShadowMaps[shadowCascadeIndex]);
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
GraphicsDevice.BlendState = BlendState.Opaque;
SimpleDepthEffectInstanced.View = shadowMapData.LightSpaceViews[shadowCascadeIndex];
SimpleDepthEffectInstanced.Projection = shadowMapData.LightSpaceProjections[shadowCascadeIndex];
var numInstances = FillAndSetBuffersForInstancing(
GraphicsDevice,
drawable,
transforms,
PositionInstanceVertices,
PositionInstanceVertexBuffer
);
RenderInstanced(
GraphicsDevice,
drawable,
SimpleDepthEffectInstanced,
numInstances
);
}
public void RenderPointShadowMapIndexed<T>(
2020-12-08 04:10:27 +00:00
RenderTargetCube pointShadowCubeMap,
2020-10-19 10:01:37 +00:00
PerspectiveCamera camera,
2020-12-08 04:10:27 +00:00
IEnumerable<(T, Matrix)> modelTransforms,
2020-10-19 10:01:37 +00:00
PointLight pointLight
2020-12-08 04:10:27 +00:00
) where T : ICullable, IIndexDrawable {
2020-10-19 10:01:37 +00:00
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
GraphicsDevice.BlendState = BlendState.Opaque;
foreach (CubeMapFace face in Enum.GetValues(typeof(CubeMapFace)))
{
2020-12-08 04:10:27 +00:00
GraphicsDevice.SetRenderTarget(pointShadowCubeMap, face);
2020-10-19 10:01:37 +00:00
Vector3 targetDirection;
Vector3 targetUpDirection;
switch(face)
{
case CubeMapFace.PositiveX:
targetDirection = Vector3.Right;
targetUpDirection = Vector3.Up;
break;
case CubeMapFace.NegativeX:
targetDirection = Vector3.Left;
targetUpDirection = Vector3.Up;
break;
case CubeMapFace.PositiveY:
targetDirection = Vector3.Up;
targetUpDirection = Vector3.Forward;
break;
case CubeMapFace.NegativeY:
targetDirection = Vector3.Down;
targetUpDirection = Vector3.Backward;
break;
case CubeMapFace.PositiveZ:
targetDirection = Vector3.Backward;
targetUpDirection = Vector3.Up;
break;
case CubeMapFace.NegativeZ:
targetDirection = Vector3.Forward;
targetUpDirection = Vector3.Up;
break;
default:
targetDirection = Vector3.Right;
targetUpDirection = Vector3.Up;
break;
}
LinearDepthEffect.View = Matrix.CreateLookAt(
pointLight.Position,
pointLight.Position + targetDirection,
targetUpDirection
);
2020-12-08 04:10:27 +00:00
LinearDepthEffect.Projection = Matrix.CreatePerspectiveFieldOfView(
MathHelper.PiOver2,
1,
0.1f,
25f // FIXME: magic value
);
LinearDepthEffect.FarPlane = 25f;
2020-10-19 10:01:37 +00:00
2020-12-08 04:10:27 +00:00
LinearDepthEffect.LightPosition = pointLight.Position;
2020-10-20 01:22:54 +00:00
2020-12-08 04:10:27 +00:00
CullAndRenderIndexed(
GraphicsDevice,
new BoundingFrustum(LinearDepthEffect.View * LinearDepthEffect.Projection),
2020-12-08 04:10:27 +00:00
modelTransforms,
LinearDepthEffect
);
2020-10-19 10:01:37 +00:00
}
}
2020-10-20 01:22:54 +00:00
public void RenderPointShadowMapInstanced<T>(
RenderTargetCube pointShadowCubeMap,
PerspectiveCamera camera,
T drawable,
IEnumerable<Matrix> modelTransforms,
PointLight pointLight
) where T : ICullable, IIndexDrawable
{
GraphicsDevice.DepthStencilState = DepthStencilState.Default;
GraphicsDevice.BlendState = BlendState.Opaque;
foreach (CubeMapFace face in Enum.GetValues(typeof(CubeMapFace)))
{
GraphicsDevice.SetRenderTarget(pointShadowCubeMap, face);
Vector3 targetDirection;
Vector3 targetUpDirection;
switch(face)
{
case CubeMapFace.PositiveX:
targetDirection = Vector3.Right;
targetUpDirection = Vector3.Up;
break;
case CubeMapFace.NegativeX:
targetDirection = Vector3.Left;
targetUpDirection = Vector3.Up;
break;
case CubeMapFace.PositiveY:
targetDirection = Vector3.Up;
targetUpDirection = Vector3.Forward;
break;
case CubeMapFace.NegativeY:
targetDirection = Vector3.Down;
targetUpDirection = Vector3.Backward;
break;
case CubeMapFace.PositiveZ:
targetDirection = Vector3.Backward;
targetUpDirection = Vector3.Up;
break;
case CubeMapFace.NegativeZ:
targetDirection = Vector3.Forward;
targetUpDirection = Vector3.Up;
break;
default:
targetDirection = Vector3.Right;
targetUpDirection = Vector3.Up;
break;
}
LinearDepthEffect.View = Matrix.CreateLookAt(
pointLight.Position,
pointLight.Position + targetDirection,
targetUpDirection
);
LinearDepthEffect.Projection = Matrix.CreatePerspectiveFieldOfView(
MathHelper.PiOver2,
1,
0.1f,
25f // FIXME: magic value
);
LinearDepthEffect.FarPlane = 25f;
LinearDepthEffect.LightPosition = pointLight.Position;
// TODO: set up instancing
// var numInstances = FillAndSetBuffersForInstancing(
// GraphicsDevice,
// camera,
// drawable,
// transforms,
// VertexPos
// );
// RenderInstanced(
// GraphicsDevice,
// camera,
// modelTransforms,
// LinearDepthEffect
// );
}
}
2020-12-07 03:36:00 +00:00
private static IEnumerable<(T, Matrix)> FrustumCull<T>(
2020-10-20 01:22:54 +00:00
BoundingFrustum boundingFrustum,
2020-12-07 03:36:00 +00:00
IEnumerable<(T, Matrix)> cullableTransforms
) where T : ICullable {
foreach (var (cullable, transform) in cullableTransforms)
2020-12-07 03:27:46 +00:00
{
2020-12-07 03:36:00 +00:00
var boundingBox = TransformedBoundingBox(cullable.BoundingBox, transform);
2020-12-07 03:27:46 +00:00
var containment = boundingFrustum.Contains(boundingBox);
if (containment != ContainmentType.Disjoint)
{
2020-12-07 03:36:00 +00:00
yield return (cullable, transform);
2020-12-07 03:27:46 +00:00
}
}
}
2020-12-07 22:58:03 +00:00
private static IEnumerable<Matrix> FrustumCull<T>(
BoundingFrustum boundingFrustum,
T cullable,
IEnumerable<Matrix> transforms
) where T : ICullable
{
foreach (var transform in transforms)
{
var boundingBox = TransformedBoundingBox(cullable.BoundingBox, transform);
var containment = boundingFrustum.Contains(boundingBox);
if (containment != ContainmentType.Disjoint)
{
yield return transform;
}
}
}
2020-10-20 01:22:54 +00:00
private static BoundingBox TransformedBoundingBox(BoundingBox boundingBox, Matrix matrix)
{
var center = (boundingBox.Min + boundingBox.Max) / 2f;
var extent = (boundingBox.Max - boundingBox.Min) / 2f;
var newCenter = Vector3.Transform(center, matrix);
var newExtent = Vector3.TransformNormal(extent, AbsoluteMatrix(matrix));
return new BoundingBox(newCenter - newExtent, newCenter + newExtent);
}
private static Matrix AbsoluteMatrix(Matrix matrix)
{
return new Matrix(
Math.Abs(matrix.M11), Math.Abs(matrix.M12), Math.Abs(matrix.M13), Math.Abs(matrix.M14),
Math.Abs(matrix.M21), Math.Abs(matrix.M22), Math.Abs(matrix.M23), Math.Abs(matrix.M24),
Math.Abs(matrix.M31), Math.Abs(matrix.M32), Math.Abs(matrix.M33), Math.Abs(matrix.M34),
Math.Abs(matrix.M41), Math.Abs(matrix.M42), Math.Abs(matrix.M43), Math.Abs(matrix.M44)
);
}
2020-08-04 09:32:02 +00:00
}
}