static void Main()
{
m_FrameNumber = 0;
m_Time = 0.0f;
Device device;
SwapChain swapChain;
//var form = new RenderForm("CSharpRenderer");
var form = new CSharpRendererMainForm();
var panel = form.GetRenderingPanel();
form.ClientSize = new System.Drawing.Size(ResolutionX, ResolutionY);
var description = new SwapChainDescription()
{
BufferCount = 2,
Usage = Usage.RenderTargetOutput,
OutputHandle = panel.Handle,
IsWindowed = true,
ModeDescription = new ModeDescription(ResolutionX, ResolutionY, new Rational(60, 1), Format.R8G8B8A8_UNorm),
SampleDescription = new SampleDescription(1, 0),
Flags = SwapChainFlags.AllowModeSwitch,
SwapEffect = SwapEffect.Discard
};
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, description, out device, out swapChain);
var swapChainResource = Resource.FromSwapChain <Texture2D>(swapChain, 0);
SamplerStates.Initialize(device);
ShaderManager.Initialize(device);
GPUProfiler.Initialize(device);
ContextHelper.Initialize(device);
RenderTargetManager.Initialize(device);
PostEffectHelper.Initialize(device, ResolutionX, ResolutionY);
CubemapRenderHelper.Initialize(device);
PerlinNoiseRenderHelper.Initialize(device, device.ImmediateContext);
LightingLUTHelper.Initialize(device, device.ImmediateContext);
DebugManager.Initialize(device, ResolutionX, ResolutionY);
InitializeControls(form);
Scene scene = new Scene();
scene.Initialize(device, form, panel, ResolutionX, ResolutionY);
var resolvedRenderTarget = RenderTargetSet.CreateRenderTargetSet(device, ResolutionX, ResolutionY, Format.R8G8B8A8_UNorm, 1, false);
RenderTargetSet.BindNull(device.ImmediateContext);
// setting a viewport is required if you want to actually see anything
var context = device.ImmediateContext;
// prevent DXGI handling of alt+enter, which doesn't work properly with Winforms
using (var factory = swapChain.GetParent <Factory>())
factory.SetWindowAssociation(panel.Handle, WindowAssociationFlags.IgnoreAltEnter);
int counter = 0;
Dictionary <string, double> profilers;
profilers = new Dictionary <String, double>();
DateTime now = DateTime.Now;
CustomConstantBufferInstance globalFrameConstantBuffer = ShaderManager.CreateConstantBufferInstance("GlobalFrameBuffer", device);
MessagePump.Run(form, () =>
{
TemporalSurfaceManager.UpdateTemporalSurfaces();
if (ShaderManager.UpdateShaderManager(device))
{
InitializeControls(form);
}
GPUProfiler.BeginFrameProfiling(context);
double timeDelta = (DateTime.Now - now).TotalMilliseconds;
if (!form.GetFreezeTime())
{
m_Time += timeDelta / 1000.0;
m_FrameNumber++;
}
UpdateGlobalConstantBuffer(context, globalFrameConstantBuffer, form);
scene.RenderFrame(context, timeDelta, resolvedRenderTarget);
now = DateTime.Now;
DebugManager.PresentDebug(context, resolvedRenderTarget);
context.CopyResource(resolvedRenderTarget.m_RenderTargets[0].m_TextureObject2D, swapChainResource);
GPUProfiler.EndFrameProfiling(context);
swapChain.Present(0, PresentFlags.None);
context.PixelShader.SetShaderResource(null, 0);
if (GPUProfiler.m_CurrentFrameProfilerTree != null)
{
Action <GPUProfiler.ProfilerTreeMember, String> processLevel = null;
processLevel = (GPUProfiler.ProfilerTreeMember treeMember, String level) =>
{
string finalName = level + treeMember.m_Name;
if (profilers.ContainsKey(finalName))
{
profilers[finalName] += treeMember.m_Time;
}
else
{
profilers.Add(finalName, treeMember.m_Time);
}
foreach (var v in treeMember.m_ChildMembers)
{
processLevel(v, level + "_");
}
};
processLevel(GPUProfiler.m_CurrentFrameProfilerTree, "");
}
CheckAndUpdateDebugUI(context, form);
if (++counter == 10)
{
UpdateControls();
DataGridView dataGridView = form.GetDataGridView();
dataGridView.Rows.Clear();
foreach (var profilerEntry in profilers)
{
DataGridViewRow row = new DataGridViewRow();
row.CreateCells(dataGridView);
row.Cells[0].Value = profilerEntry.Key;
row.Cells[1].Value = String.Format("{0}", Math.Round(profilerEntry.Value * 100.0 / 10.0) / 100.0);
dataGridView.Rows.Add(row);
}
profilers.Clear();
counter = 0;
}
else
{
// avoid 2ms frame times...
System.Threading.Thread.Sleep(10);
}
});
}
public void ExecutePass(DeviceContext context, RenderTargetSet target, RenderTargetSet linearDepth, RenderTargetSet motionVectors, RenderTargetSet surfaceNormals, DepthOperationsPass depthOps)
{
RenderTargetSet ssaoCurrent = TemporalSurfaceManager.GetRenderTargetCurrent("SSAO");
RenderTargetSet ssaoHistory = TemporalSurfaceManager.GetRenderTargetHistory("SSAO");
if (DebugManager.IsFeatureOn("SSAO"))
{
RenderTargetSet tempBlurBuffer = RenderTargetManager.RequestRenderTargetFromPool(m_RTDescriptor);
Random rand = new Random();
dynamic scb = m_SSAOBuffer;
scb.g_SSAOPhase = (float)rand.NextDouble() * 3.1415f;
m_SSAOBuffer.CompileAndBind(context);
using (new GpuProfilePoint(context, "SSAO"))
{
using (new GpuProfilePoint(context, "SSAOCalculate"))
{
linearDepth.BindSRV(context, 0);
ssaoHistory.BindSRV(context, 1);
motionVectors.BindSRV(context, 2);
surfaceNormals.BindSRV(context, 3);
ssaoCurrent.BindAsRenderTarget(context);
PostEffectHelper.RenderFullscreenTriangle(context, "SSAOCalculate");
RenderTargetSet.BindNull(context);
ContextHelper.ClearSRVs(context);
}
DebugManager.RegisterDebug(context, "SSAOMain", ssaoCurrent);
using (new GpuProfilePoint(context, "SSAOBlur"))
{
ssaoCurrent.BindSRV(context, 1);
tempBlurBuffer.BindAsRenderTarget(context);
PostEffectHelper.RenderFullscreenTriangle(context, "SSAOBlurHorizontal");
RenderTargetSet.BindNull(context);
ContextHelper.ClearSRVs(context);
DebugManager.RegisterDebug(context, "SSAOBlurH", tempBlurBuffer);
tempBlurBuffer.BindSRV(context, 1);
target.BindAsRenderTarget(context);
PostEffectHelper.RenderFullscreenTriangle(context, "SSAOBlurVertical");
RenderTargetSet.BindNull(context);
ContextHelper.ClearSRVs(context);
DebugManager.RegisterDebug(context, "SSAOBlurV", target);
}
}
RenderTargetManager.ReleaseRenderTargetToPool(tempBlurBuffer);
}
else
{
target.Clear(context, new SlimDX.Color4(1.0f, 1.0f, 1.0f, 1.0f));
}
if (DebugManager.IsDebugging("UpsampledSSAO"))
{
RenderTargetSet tempFullResBuffer = RenderTargetManager.RequestRenderTargetFromPool(m_UpsampleDebugRTDescriptor);
target.BindSRV(context, 0);
depthOps.m_BilateralUpsampleOffsets.BindSRV(context, 10);
tempFullResBuffer.BindAsRenderTarget(context);
PostEffectHelper.RenderFullscreenTriangle(context, "BilateralUpsample");
RenderTargetSet.BindNull(context);
ContextHelper.ClearSRVs(context);
DebugManager.RegisterDebug(context, "UpsampledSSAO", tempFullResBuffer);
RenderTargetManager.ReleaseRenderTargetToPool(tempFullResBuffer);
}
}
public void RenderFrame(DeviceContext context, double timeElapsed, RenderTargetSet targetRT)
{
ShaderManager.BindSamplerStates(context);
PerlinNoiseRenderHelper.BindTextures(context);
RenderTargetSet currentFrameMainBuffer = TemporalSurfaceManager.GetRenderTargetCurrent("SceneMainRender");
RenderTargetSet ssaoRT = RenderTargetManager.RequestRenderTargetFromPool(m_SSAODescriptor);
bool useTemporal = !DebugManager.m_DisabledTemporal;
if (!m_ShadowsInitialized)
{
InitializeShadowmapAndCubemaps(context, timeElapsed);
}
CalculateAndUpdateConstantBuffer(context, timeElapsed);
if (false)
{
m_GIRenderer.PartialGIUpdate(context, m_SimpleSceneWrapper, m_ResolvedShadow);
}
m_CurrentViewportBuffer.Bind(context);
using (new GpuProfilePoint(context, "DepthPrepass"))
{
// set the shaders
context.VertexShader.Set(ShaderManager.GetVertexShader("VertexScene"));
context.PixelShader.Set(ShaderManager.GetPixelShader("DepthNormalPrepass"));
currentFrameMainBuffer.Clear(context, new Color4(1.0f, 1.0f, 1.0f, 1.5f), true);
currentFrameMainBuffer.BindAsRenderTarget(context, true, true);
ContextHelper.SetDepthStencilState(context, ContextHelper.DepthConfigurationType.DepthWriteCompare);
// render triangles
m_SimpleSceneWrapper.Render(context);
ContextHelper.SetDepthStencilState(context, ContextHelper.DepthConfigurationType.NoDepth);
RenderTargetSet.BindNull(context);
DebugManager.RegisterDebug(context, "NormalsPrepass", currentFrameMainBuffer);
}
RenderTargetSet motionVectorsSurface = TemporalSurfaceManager.GetRenderTargetCurrent("MotionVectors");
RenderTargetSet motionVectorsSurfacePrevious = TemporalSurfaceManager.GetRenderTargetHistory("MotionVectors");
m_ResolveMotionVectorsPass.ExecutePass(context, motionVectorsSurface, currentFrameMainBuffer);
DebugManager.RegisterDebug(context, "MotionVectors", motionVectorsSurface);
m_DepthOperationsPass.ExecutePass(context, currentFrameMainBuffer);
RenderTargetSet linearDepth = m_DepthOperationsPass.m_LinearDepth;
m_SSAOPass.ExecutePass(context, ssaoRT, m_DepthOperationsPass.m_HalfLinearDepth, motionVectorsSurface, m_DepthOperationsPass.m_HalfNormals, m_DepthOperationsPass);
m_SSReflectionsPass.ExecutePass(context, m_DepthOperationsPass.m_HalfLinearDepth, motionVectorsSurface, m_DepthOperationsPass.m_HalfNormals, TemporalSurfaceManager.GetRenderTargetHistory("SceneMainRender"), m_ViewportCamera, m_DepthOperationsPass);
m_VolumetricFog.RenderVolumetricFog(context, m_ResolvedShadow.m_RenderTargets[0], m_GIRenderer);
using (new GpuProfilePoint(context, "MainForwardRender"))
{
// set the shaders
context.VertexShader.Set(ShaderManager.GetVertexShader("VertexScene"));
context.PixelShader.Set(ShaderManager.GetPixelShader("PixelScene"));
currentFrameMainBuffer.BindAsRenderTarget(context, true);
m_ResolvedShadow.BindSRV(context, 0);
ssaoRT.BindSRV(context, 1);
TemporalSurfaceManager.GetRenderTargetCurrent("SSReflections").BindSRV(context, 2);
m_DepthOperationsPass.m_BilateralUpsampleOffsets.BindSRV(context, 10);
context.PixelShader.SetShaderResource(m_GIRenderer.m_GIVolumeR.m_ShaderResourceView, 5);
context.PixelShader.SetShaderResource(m_GIRenderer.m_GIVolumeG.m_ShaderResourceView, 6);
context.PixelShader.SetShaderResource(m_GIRenderer.m_GIVolumeB.m_ShaderResourceView, 7);
context.PixelShader.SetShaderResource(m_VolumetricFog.m_ScatteringTexture.m_ShaderResourceView, 8);
context.PixelShader.SetShaderResource(m_CubeObjectFiltered.m_ShaderResourceView, 11);
ContextHelper.SetDepthStencilState(context, ContextHelper.DepthConfigurationType.DepthCompare);
LightingLUTHelper.BindTextures(context);
// render triangles
m_SimpleSceneWrapper.Render(context);
// render sky
PostEffectHelper.RenderFullscreenTriangle(context, "Sky", true);
ContextHelper.SetDepthStencilState(context, ContextHelper.DepthConfigurationType.NoDepth);
RenderTargetSet.BindNull(context);
}
RenderTargetManager.ReleaseRenderTargetToPool(ssaoRT);
using (new GpuProfilePoint(context, "PostEffects"))
{
RenderTargetSet postEffectSurfacePong = RenderTargetManager.RequestRenderTargetFromPool(m_FullResDescriptor);
RenderTargetSet source, dest;
source = currentFrameMainBuffer;
dest = postEffectSurfacePong;
dynamic ppcb = m_PostEffectsConstantBuffer;
if (ppcb.g_DofCoCScale > 0.0f)
{
m_ScatterDOFPass.ExecutePass(context, dest, currentFrameMainBuffer, currentFrameMainBuffer);
PostEffectHelper.Swap(ref source, ref dest);
}
RenderTargetSet luminanceTexture = m_LuminanceCalculations.ExecutePass(context, source);
RenderTargetSet resolvedCurrent = TemporalSurfaceManager.GetRenderTargetCurrent("ResolvedColor");
RenderTargetSet resolvedHistory = TemporalSurfaceManager.GetRenderTargetHistory("ResolvedColor");
m_ResolveHDRPass.ExecutePass(context, resolvedCurrent, source, luminanceTexture);
DebugManager.RegisterDebug(context, "ResolvedNoTemporal", resolvedCurrent);
RenderTargetSet resolvedTemporal = RenderTargetManager.RequestRenderTargetFromPool(m_ResolvedColorDescriptor);
RenderTargetSet finalResolvedTarget = resolvedCurrent;
if (useTemporal)
{
m_ResolveTemporalPass.ExecutePass(context, resolvedTemporal, resolvedCurrent, resolvedHistory, motionVectorsSurface, motionVectorsSurfacePrevious, true);
finalResolvedTarget = resolvedTemporal;
}
DebugManager.RegisterDebug(context, "ResolvedNoFXAA", finalResolvedTarget);
m_FxaaPass.ExecutePass(context, targetRT, finalResolvedTarget);
RenderTargetManager.ReleaseRenderTargetToPool(resolvedTemporal);
RenderTargetManager.ReleaseRenderTargetToPool(postEffectSurfacePong);
}
}
