public void TestSpotLightRendererShadowing()
{
var game = new DX11Game();
game.InitDirectX();
var device = game.Device;
var context = device.ImmediateContext;
var filledGBuffer = new TestFilledGBuffer(game, 800, 600);
var light = new SpotLightRenderer(game, filledGBuffer.GBuffer);
light.LightRadius *= 2;
light.ShadowsEnabled = true;
var toggle = false;
game.GameLoopEvent += delegate
{
filledGBuffer.DrawUpdatedGBuffer();
light.UpdateLightCamera();
game.Camera = light.LightCamera;
light.UpdateShadowMap(filledGBuffer.Draw);
game.Camera = game.SpectaterCamera;
game.SetBackbuffer();
if (game.Keyboard.IsKeyPressed(Key.C))
{
toggle = !toggle;
}
if (toggle)
{
light.SpotDirection = game.SpectaterCamera.CameraDirection;
light.LightPosition = game.SpectaterCamera.CameraPosition;
}
if (game.Keyboard.IsKeyDown(Key.I))
{
GBufferTest.DrawGBuffer(game, filledGBuffer.GBuffer);
}
else
{
light.Draw();
game.TextureRenderer.Draw(light.ShadowMapRv, new Vector2(10, 10), new Vector2(300, 300));
game.LineManager3D.AddViewFrustum(light.LightCamera.ViewProjection,
new Color4(1, 0, 0));
}
};
game.Run();
}
public void TestMeshRendererSimple()
{
var game = new DX11Game();
game.InitDirectX();
var context = game.Device.ImmediateContext;
var mesh = RenderingTestsHelper.CreateSimpleTestMesh();
var texturePool = new TexturePool(game);
var gBuffer = new GBuffer(game.Device, 800, 600);
var renderer = new DeferredMeshesRenderer(game, gBuffer, texturePool);
DeferredMeshElement middle = null;
for (int i = 0; i < 50; i++)
{
for (int j = 0; j < 50; j++)
{
var el = renderer.AddMesh(mesh);
el.WorldMatrix = Matrix.Translation(MathHelper.Right * i * 2 + Vector3.UnitZ * j * 2);
if (i > 20 && i < 30 && j > 20 && j < 30)
{
el.Delete();
}
}
}
game.GameLoopEvent += delegate
{
gBuffer.Clear();
gBuffer.SetTargetsToOutputMerger();
context.Rasterizer.State = game.HelperStates.RasterizerShowAll;
renderer.Draw();
context.ClearState();
game.SetBackbuffer();
GBufferTest.DrawGBuffer(game, gBuffer);
};
game.Run();
}
public void TestPointLightAccumulation()
{
//TODO: add a way to show the specular in the alpha channel
var game = new DX11Game();
game.InitDirectX();
var device = game.Device;
var context = device.ImmediateContext;
var filledGBuffer = new TestFilledGBuffer(game, 800, 600);
var light = new PointLightRenderer(game, filledGBuffer.GBuffer);
var toggle = false;
game.GameLoopEvent += delegate
{
filledGBuffer.DrawUpdatedGBuffer();
game.SetBackbuffer();
if (game.Keyboard.IsKeyPressed(Key.C))
{
toggle = !toggle;
}
if (toggle)
{
light.LightPosition = game.SpectaterCamera.CameraPosition;
}
if (game.Keyboard.IsKeyDown(Key.I))
{
GBufferTest.DrawGBuffer(game, filledGBuffer.GBuffer);
}
else
{
light.Draw();
}
};
game.Run();
light.Dispose();
filledGBuffer.Dispose();
}
public void TestDirectionalLightAccumulation()
{
//TODO: add a way to show the specular in the alpha channel
var game = new DX11Game();
game.InitDirectX();
var device = game.Device;
var context = device.ImmediateContext;
var filledGBuffer = new TestFilledGBuffer(game, 800, 600);
var light = new DirectionalLightRenderer(game, filledGBuffer.GBuffer);
game.GameLoopEvent += delegate
{
filledGBuffer.DrawUpdatedGBuffer();
game.SetBackbuffer();
if (game.Keyboard.IsKeyDown(Key.C))
{
game.SpectaterCamera.Enabled = false;
var mat = Matrix.RotationY(game.Mouse.RelativeX * game.Elapsed * 5) * Matrix.RotationX(game.Mouse.RelativeY * game.Elapsed * 5);
light.LightDirection = Vector3.TransformNormal(light.LightDirection, mat);
}
else
{
game.SpectaterCamera.Enabled = true;
}
if (game.Keyboard.IsKeyDown(Key.I))
{
GBufferTest.DrawGBuffer(game, filledGBuffer.GBuffer);
}
else
{
light.Draw();
}
};
game.Run();
}
public void TestMeshRendererSimpleCulling()
{
var game = new DX11Game();
game.InitDirectX();
var context = game.Device.ImmediateContext;
var mesh = RenderingTestsHelper.CreateSimpleTestMesh();
var texturePool = new TexturePool(game);
var gBuffer = new GBuffer(game.Device, 800, 600);
var renderer = new DeferredMeshesRenderer(game, gBuffer, texturePool);
DeferredMeshElement middle = null;
Vector3 radius = new Vector3(100, 1000, 100);
FrustumCullerSimple culler = new FrustumCullerSimple(new BoundingBox(-radius, radius), 5);
//QuadTreeVisualizer visualizer = new QuadTreeVisualizer();
SpectaterCamera cullCam = new SpectaterCamera(10f, 80);
cullCam.Positie = new Vector3(8, 10, 8);
cullCam.EnableUserInput = false;
SpectaterCamera renderCam = game.SpectaterCamera;
culler.CullCamera = cullCam;
throw new NotImplementedException();
//renderer.Culler = culler;
bool rotate = true;
int selectedNode = -1;
for (int i = 0; i < 50; i++)
{
for (int j = 0; j < 50; j++)
{
var el = renderer.AddMesh(mesh);
el.WorldMatrix = Matrix.Translation(MathHelper.Right * i * 2 + Vector3.UnitZ * j * 2);
if (i > 20 && i < 30 && j > 20 && j < 30)
{
el.Delete();
}
}
}
game.GameLoopEvent += delegate
{
culler.UpdateVisibility();
if (rotate)
{
cullCam.AngleHorizontal += game.Elapsed * MathHelper.Pi * (1 / 8f);
}
cullCam.Update(game.Elapsed, game.Keyboard, game.Mouse);
if (game.Keyboard.IsKeyPressed(Key.NumberPadPlus))
{
selectedNode++;
}
if (game.Keyboard.IsKeyPressed(Key.NumberPadMinus))
{
selectedNode--;
}
if (game.Keyboard.IsKeyPressed(Key.Return))
{
int count = -1;
//visualizer.RenderNodeGroundBoundig(game, culler.RootNode,
//delegate(FrustumCuller.CullNode node, out Color col)
//{
// col = Color.Red;
// count++;
// if (count == selectedNode)
// {
// node.Tag = "SELECTED!";
// }
// return count == selectedNode;
//});
}
if (game.Keyboard.IsKeyPressed(Key.NumberPad0))
{
rotate = !rotate;
}
game.LineManager3D.AddViewFrustum(new BoundingFrustum(cullCam.ViewProjection), new Color4());
//for (int i = 0; i < cullObjects.Count; i++)
//{
// game.LineManager3D.AddBox(cullObjects[i].BoundingBox, Color.Red);
//}
//visualizer.RenderNodeGroundBoundig(game, culler.RootNode,
// delegate(FrustumCuller.CullNode node, out Color col)
// {
// if (node.Visible)
// {
// col = Color.Orange;
// }
// else
// {
// col = Color.Green;
// }
// return true;
// });
gBuffer.Clear();
gBuffer.SetTargetsToOutputMerger();
context.Rasterizer.State = game.HelperStates.RasterizerShowAll;
renderer.Draw();
context.ClearState();
game.SetBackbuffer();
GBufferTest.DrawGBuffer(game, gBuffer);
};
game.Run();
}
public void TestMeshRendererAdvanced()
{
var texFactory = new RAMTextureFactory();
var c = new OBJToRAMMeshConverter(texFactory);
var game = new DX11Game();
game.InitDirectX();
var context = game.Device.ImmediateContext;
var importer = new ObjImporter();
importer.AddMaterialFileStream("Crate01.mtl", File.OpenRead(TestFiles.CrateMtl));
importer.ImportObjFile(TestFiles.CrateObj);
var mesh = c.CreateMesh(importer);
RAMMesh mesh2 = RenderingTestsHelper.CreateMerchantsHouseMesh(c);
RAMMesh mesh3 = RenderingTestsHelper.CreateGuildHouseMesh(c);
var gBuffer = new GBuffer(game.Device, 800, 600);
DeferredMeshesRenderer renderer = InitDefaultMeshRenderer(game, gBuffer);
var el = renderer.AddMesh(mesh);
el.WorldMatrix = Matrix.Translation(MathHelper.Right * 0 * 2 + Vector3.UnitZ * 0 * 2);
el = renderer.AddMesh(mesh2);
el.WorldMatrix = Matrix.Translation(new Vector3(0, 0, 80));
for (int i = 0; i < 3; i++)
{
for (int j = 0; j < 3; j++)
{
el = renderer.AddMesh(mesh3);
el.WorldMatrix = Matrix.Translation(new Vector3(j * 30, 0, 70 + i * 30));
}
}
game.GameLoopEvent += delegate
{
gBuffer.Clear();
gBuffer.SetTargetsToOutputMerger();
context.Rasterizer.State = game.HelperStates.RasterizerShowAll;
renderer.Draw();
context.ClearState();
game.SetBackbuffer();
GBufferTest.DrawGBuffer(game, gBuffer);
};
game.Run();
}
public void TestCascadedShadowMapping()
{
var game = new DX11Game();
game.InitDirectX();
var device = game.Device;
var context = device.ImmediateContext;
var filledGBuffer = new TestFilledGBuffer(game, 800, 600);
var csmRenderer = new CSMRenderer(game);
var toggle = false;
var light = new DirectionalLight();
game.GameLoopEvent += delegate
{
context.ClearState();
filledGBuffer.DrawUpdatedGBuffer();
csmRenderer.UpdateShadowMap(delegate(OrthographicCamera lightCamera)
{
game.Camera = lightCamera;
filledGBuffer.Draw();
game.Camera = game.SpectaterCamera;
}, light, game.SpectaterCamera);
game.SetBackbuffer();
if (game.Keyboard.IsKeyPressed(Key.C))
{
toggle = !toggle;
}
if (toggle)
{
light.Direction = game.SpectaterCamera.CameraDirection;
}
if (game.Keyboard.IsKeyDown(Key.I))
{
GBufferTest.DrawGBuffer(game, filledGBuffer.GBuffer);
}
else
{
csmRenderer.RenderShadowOcclusion(game.SpectaterCamera, filledGBuffer.GBuffer.DepthRV);
//light.Draw();
game.TextureRenderer.Draw(csmRenderer.ShadowMapRV, new Vector2(10, 10), new Vector2(590, 200));
for (int i = 0; i < 6; i++)
{
//game.LineManager3D.AddViewFrustum(light.LightCameras[i].ViewProjection,
//new Color4(0, 1, 0));
}
}
};
game.Run();
}
public void TestMultipleLightAccumulation()
{
//TODO: add a way to show the specular in the alpha channel
var game = new DX11Game();
game.InitDirectX();
var device = game.Device;
var context = device.ImmediateContext;
var filledGBuffer = new TestFilledGBuffer(game, 800, 600);
var spot = new SpotLightRenderer(game, filledGBuffer.GBuffer);
var point = new PointLightRenderer(game, filledGBuffer.GBuffer);
var directional = new DirectionalLightRenderer(game, filledGBuffer.GBuffer);
var state = 0;
var bsDesc = new BlendStateDescription();
var b = new RenderTargetBlendDescription();
b.BlendEnable = true;
b.BlendOperation = BlendOperation.Add;
b.BlendOperationAlpha = BlendOperation.Add;
b.DestinationBlend = BlendOption.One;
b.DestinationBlendAlpha = BlendOption.One;
b.SourceBlend = BlendOption.One;
b.SourceBlendAlpha = BlendOption.One;
b.RenderTargetWriteMask = ColorWriteMaskFlags.All;
bsDesc.RenderTargets[0] = b;
var blendState = BlendState.FromDescription(device, bsDesc);
var depthState = DepthStencilState.FromDescription(device, new DepthStencilStateDescription
{
IsDepthEnabled = false,
IsStencilEnabled = false,
});
game.GameLoopEvent += delegate
{
filledGBuffer.DrawUpdatedGBuffer();
game.SetBackbuffer();
if (game.Keyboard.IsKeyPressed(Key.D1))
{
state = 0;
}
if (game.Keyboard.IsKeyPressed(Key.D2))
{
state = 1;
}
if (game.Keyboard.IsKeyPressed(Key.D3))
{
state = 2;
}
if (game.Keyboard.IsKeyPressed(Key.D4))
{
state = 3;
}
switch (state)
{
case 0:
break;
case 1:
directional.LightDirection = game.SpectaterCamera.CameraDirection;
break;
case 2:
point.LightPosition = game.SpectaterCamera.CameraPosition;
break;
case 3:
spot.LightPosition = game.SpectaterCamera.CameraPosition;
spot.SpotDirection = game.SpectaterCamera.CameraDirection;
break;
}
if (game.Keyboard.IsKeyDown(Key.I))
{
GBufferTest.DrawGBuffer(game, filledGBuffer.GBuffer);
}
else
{
context.OutputMerger.DepthStencilState = depthState;
directional.Draw();
context.OutputMerger.BlendState = blendState;
spot.Draw();
point.Draw();
context.OutputMerger.BlendState = null;
context.OutputMerger.DepthStencilState = null;
}
};
game.Run();
}
public void DrawUpdatedDeferredRendering()
{
FilledGBuffer.DrawUpdatedGBuffer();
if (game.Keyboard.IsKeyPressed(Key.D1))
{
state = 0;
}
if (game.Keyboard.IsKeyPressed(Key.D2))
{
state = 1;
}
if (game.Keyboard.IsKeyPressed(Key.D3))
{
state = 2;
}
if (game.Keyboard.IsKeyPressed(Key.D4))
{
state = 3;
}
switch (state)
{
case 0:
break;
case 1:
directional.LightDirection = game.SpectaterCamera.CameraDirection;
break;
case 2:
point.LightPosition = game.SpectaterCamera.CameraPosition;
break;
case 3:
spot.LightPosition = game.SpectaterCamera.CameraPosition;
spot.SpotDirection = game.SpectaterCamera.CameraDirection;
break;
}
if (game.Keyboard.IsKeyDown(Key.I))
{
context.ClearState();
game.SetBackbuffer();
GBufferTest.DrawGBuffer(game, FilledGBuffer.GBuffer);
}
else
{
combineFinal.ClearLightAccumulation();
combineFinal.SetLightAccumulationStates();
directional.Draw();
spot.Draw();
point.Draw();
context.ClearState();
game.SetBackbuffer(); // This is to set viewport, not sure this is correct
context.OutputMerger.SetTargets(hdrImageRTV);
DrawCombined();
}
if (game.Keyboard.IsKeyPressed(Key.O))
{
Resource.SaveTextureToFile(game.Device.ImmediateContext, hdrImage, ImageFileFormat.Dds,
TWDir.Test.CreateSubdirectory("Deferred") + "\\HdrImage.dds");
}
}
