public void Render()
{
var device = this.deviceResources.D3DDevice;
var context = this.deviceResources.D3DContext;
float[] ClearColor = new float[] { 0.0f, 0.55f, 0.55f, 1.0f };
D3D11RenderTargetView pRTV = this.deviceResources.D3DRenderTargetView;
D3D11DepthStencilView pDSV = this.deviceResources.D3DDepthStencilView;
context.ClearRenderTargetView(pRTV, ClearColor);
context.ClearDepthStencilView(pDSV, D3D11ClearOptions.Depth, 1.0f, 0);
this.cascadedShadow.InitFrame(device, this.selectedMesh);
this.cascadedShadow.RenderShadowsForAllCascades(device, context, this.selectedMesh);
D3D11Viewport vp = new D3D11Viewport(
0.0f,
0.0f,
this.deviceResources.BackBufferWidth,
this.deviceResources.BackBufferHeight,
0.0f,
1.0f);
this.cascadedShadow.RenderScene(context, pRTV, pDSV, this.selectedMesh, vp, this.VisualizeCascades);
context.RasterizerStageSetViewports(new D3D11Viewport[] { vp });
context.OutputMergerSetRenderTargets(new[] { pRTV }, pDSV);
}
public IDisplay Create(string title, int width, int height, IAdapter adapter)
{
const uint defaultRefreshRate = 144;
const bool debug = true;
var window = _windowCreator.CreateWindow(new CreateWindowArguments(title, width, height));
// Create device
var d3D11Device = _d3D11DeviceFactory.Create(new CreateDeviceArguments(window, defaultRefreshRate, adapter?.Handle ?? IntPtr.Zero, debug));
// Created the backbuffer and the RenderTargetView
using var backBuffer = d3D11Device.SwapChain.GetBuffer(0, D3D11Resources.D3D11Resource);
var renderTarget = d3D11Device.CreateRenderTargetView(backBuffer);
D3D11Texture2DDesc sTarget = default;
sTarget.Height = (uint)window.Height;
sTarget.Width = (uint)window.Width;
sTarget.MipLevels = 1u;
sTarget.ArraySize = 1u;
sTarget.Format = DxgiFormat.R8G8B8A8Unorm;
sTarget.SampleDesc.Count = 1;
sTarget.SampleDesc.Quality = 0;
sTarget.Usage = D3D11Usage.Default;
sTarget.BindFlags = D3D11BindFlag.RenderTarget;
//var d3D11Texture2D = d3D11Device.CreateTexture2D(sTarget); // TODO: this is getting leaked
//var secondRenderTarget = d3D11Device.CreateRenderTargetView(d3D11Texture2D); // TODO: this is getting leaked
// Create the DepthStencilView (z-buffering)
D3D11DepthStencilDesc depthDesc = default;
depthDesc.DepthEnable = true;
//depthDesc.DepthWriteMask = D3D11DepthWriteMask.Zero;
//depthDesc.DepthFunc = D3D11ComparisonFunc.LessEqual; // this is needed to add alpha-blending to sprites, not sure why.
depthDesc.DepthWriteMask = D3D11DepthWriteMask.All;
depthDesc.DepthFunc = D3D11ComparisonFunc.LessEqual; // this is needed to add alpha-blending to sprites, not sure why.
using var depthStencilState = d3D11Device.CreateDepthStencilState(depthDesc);
d3D11Device.Context.OMSetDepthStencilState(depthStencilState, 1u);
D3D11Texture2DDesc texture2DDesc = default;
texture2DDesc.Height = (uint)window.Height;
texture2DDesc.Width = (uint)window.Width;
texture2DDesc.MipLevels = 1u;
texture2DDesc.ArraySize = 1u;
texture2DDesc.Format = DxgiFormat.D32Float;
//texture2DDesc.SampleDesc.Count = 4u; // AA
texture2DDesc.SampleDesc.Count = 1;
texture2DDesc.SampleDesc.Quality = 0;
texture2DDesc.Usage = D3D11Usage.Default;
texture2DDesc.BindFlags = D3D11BindFlag.DepthStencil;
using var depthStencil = d3D11Device.CreateTexture2D(texture2DDesc);
D3D11DepthStencilViewDesc viewDesc = default;
viewDesc.Format = DxgiFormat.D32Float;
viewDesc.ViewDimension = D3D11DsvDimension.Texture2D;
//viewDesc.ViewDimension = D3D11DsvDimension.Texture2Dms; // AA
viewDesc.Texture2D.MipSlice = 0u;
var depthStencilView = d3D11Device.CreateDepthStencilView(depthStencil, viewDesc);
// Set the render target view and depthStencil
unsafe
{
var renderTargets = stackalloc IntPtr[1];
renderTargets[0] = renderTarget.Handle;
d3D11Device.Context.OMSetRenderTargets(renderTargets, 1, depthStencilView.Handle);
}
// Set the default viewport
D3D11Viewport viewport = default;
viewport.Width = window.Width;
viewport.Height = window.Height;
viewport.MinDepth = 0;
viewport.MaxDepth = 1;
d3D11Device.Context.SetViewport(viewport);
// Create the device abstraction
var device = new Device(d3D11Device, renderTarget, depthStencilView, _compiler);
return(new Display(device, window));
}
private void CreateWindowSizeDependentResources()
{
this.d3dContext.OutputMergerSetRenderTargets(new D3D11RenderTargetView[] { null }, null);
D3D11Utils.DisposeAndNull(ref this.backBuffer);
D3D11Utils.DisposeAndNull(ref this.offscreenBuffer);
D3D11Utils.DisposeAndNull(ref this.d3dRenderTargetView);
D3D11Utils.DisposeAndNull(ref this.d3dDepthStencilView);
D2D1Utils.DisposeAndNull(ref this.d2dRenderTarget);
this.d3dContext.Flush();
var createdBackBuffer = this.OnCreateBackBuffer();
if (createdBackBuffer == null)
{
return;
}
this.backBuffer = createdBackBuffer;
var backBufferDesc = this.backBuffer.Description;
this.backBufferWidth = backBufferDesc.Width;
this.backBufferHeight = backBufferDesc.Height;
if (this.d3dSampleDesc.Count > 1)
{
D3D11Texture2DDesc desc = new D3D11Texture2DDesc(
DxgiFormat.B8G8R8A8UNorm,
this.backBufferWidth,
this.backBufferHeight,
1,
1,
D3D11BindOptions.RenderTarget,
D3D11Usage.Default,
D3D11CpuAccessOptions.None,
this.d3dSampleDesc.Count,
this.d3dSampleDesc.Quality,
D3D11ResourceMiscOptions.None);
this.offscreenBuffer = this.D3DDevice.CreateTexture2D(desc);
}
if (this.d3dSampleDesc.Count > 1)
{
D3D11RenderTargetViewDesc renderTargetViewDesc = new D3D11RenderTargetViewDesc(D3D11RtvDimension.Texture2DMs);
this.d3dRenderTargetView = this.d3dDevice.CreateRenderTargetView(this.offscreenBuffer, renderTargetViewDesc);
}
else
{
D3D11RenderTargetViewDesc renderTargetViewDesc = new D3D11RenderTargetViewDesc(D3D11RtvDimension.Texture2D);
this.d3dRenderTargetView = this.d3dDevice.CreateRenderTargetView(this.backBuffer, renderTargetViewDesc);
}
D3D11Texture2DDesc depthStencilDesc = new D3D11Texture2DDesc
{
Width = this.backBufferWidth,
Height = this.backBufferHeight,
MipLevels = 1,
ArraySize = 1,
Format = DxgiFormat.D24UNormS8UInt,
SampleDesc = this.d3dSampleDesc,
Usage = D3D11Usage.Default,
BindOptions = D3D11BindOptions.DepthStencil,
CpuAccessOptions = D3D11CpuAccessOptions.None,
MiscOptions = D3D11ResourceMiscOptions.None
};
using (var depthStencil = this.d3dDevice.CreateTexture2D(depthStencilDesc))
{
D3D11DepthStencilViewDesc depthStencilViewDesc = new D3D11DepthStencilViewDesc(this.d3dSampleDesc.Count > 1 ? D3D11DsvDimension.Texture2DMs : D3D11DsvDimension.Texture2D);
this.d3dDepthStencilView = this.d3dDevice.CreateDepthStencilView(depthStencil, depthStencilViewDesc);
}
this.screenViewport = new D3D11Viewport
{
TopLeftX = 0,
TopLeftY = 0,
Width = this.backBufferWidth,
Height = this.backBufferHeight,
MinDepth = 0.0f,
MaxDepth = 1.0f
};
this.d3dContext.RasterizerStageSetViewports(new[] { this.screenViewport });
using (var surface = new DxgiSurface2(this.d3dSampleDesc.Count > 1 ? this.offscreenBuffer.Handle : this.backBuffer.Handle))
{
float dpiX;
float dpiY;
this.d2dFactory.GetDesktopDpi(out dpiX, out dpiY);
var properties = new D2D1RenderTargetProperties(
D2D1RenderTargetType.Default,
new D2D1PixelFormat(DxgiFormat.B8G8R8A8UNorm, D2D1AlphaMode.Premultiplied),
dpiX,
dpiY,
D2D1RenderTargetUsages.None,
D2D1FeatureLevel.Default);
this.d2dRenderTarget = this.d2dFactory.CreateDxgiSurfaceRenderTarget(surface, properties);
}
this.d2dRenderTarget.AntialiasMode = D2D1AntialiasMode.PerPrimitive;
this.d2dRenderTarget.TextAntialiasMode = D2D1TextAntialiasMode.Grayscale;
D3D11RasterizerDesc rasterizerStateDesc = new D3D11RasterizerDesc(D3D11FillMode.Solid, D3D11CullMode.Back, false, 0, 0.0f, 0.0f, true, false, true, false);
using (var rasterizerState = this.d3dDevice.CreateRasterizerState(rasterizerStateDesc))
{
this.d3dContext.RasterizerStageSetState(rasterizerState);
}
}
private void RenderShadowMap(out XMFloat4X4 mViewProjLight, out XMFloat3 vLightDir)
{
var context = this.deviceResources.D3DContext;
D3D11Rect[] oldRects = context.RasterizerStageGetScissorRects();
D3D11Viewport[] oldVp = context.RasterizerStageGetViewports();
D3D11Rect[] rects = new D3D11Rect[1] {
new D3D11Rect(0, (int)g_fShadowMapWidth, 0, (int)g_fShadowMapHeight)
};
context.RasterizerStageSetScissorRects(rects);
D3D11Viewport[] vp = new D3D11Viewport[1] {
new D3D11Viewport(0, 0, g_fShadowMapWidth, g_fShadowMapHeight, 0.0f, 1.0f)
};
context.RasterizerStageSetViewports(vp);
// Set our scene render target & keep original depth buffer
D3D11RenderTargetView[] pRTVs = new D3D11RenderTargetView[2];
context.OutputMergerSetRenderTargets(pRTVs, this.g_pDepthStencilTextureDSV);
// Clear the render target
context.ClearDepthStencilView(this.g_pDepthStencilTextureDSV, D3D11ClearOptions.Depth | D3D11ClearOptions.Stencil, 1.0f, 0);
// Get the projection & view matrix from the camera class
XMFloat3 up = new XMFloat3(0, 1, 0);
XMFloat4 vLight = new XMFloat4(0.0f, 0.0f, 0.0f, 1.0f);
XMFloat4 vLightLookAt = new XMFloat4(0.0f, -0.5f, 1.0f, 0.0f);
vLightLookAt = vLight.ToVector() + vLightLookAt.ToVector();
vLight = XMVector4.Transform(vLight, this.LightWorldMatrix);
vLightLookAt = XMVector4.Transform(vLightLookAt, this.LightWorldMatrix);
vLightDir = XMVector.Subtract(vLightLookAt, vLight);
XMMatrix mProj = XMMatrix.OrthographicOffCenterLH(-8.5f, 9, -15, 11, -20, 20);
XMMatrix mView = XMMatrix.LookAtLH(vLight, vLightLookAt, up);
mViewProjLight = mView * mProj;
// Setup the constant buffer for the scene vertex shader
ConstantBufferConstants pConstants = new ConstantBufferConstants
{
WorldViewProjection = mViewProjLight.ToMatrix().Transpose(),
WorldViewProjLight = mViewProjLight.ToMatrix().Transpose(),
ShadowMapDimensions = new XMFloat4(
g_fShadowMapWidth,
g_fShadowMapHeight,
1.0f / g_fShadowMapWidth,
1.0f / g_fShadowMapHeight),
LightDir = new XMFloat4(vLightDir.X, vLightDir.Y, vLightDir.Z, 0.0f),
SunWidth = this.SunWidth
};
context.UpdateSubresource(this.g_pcbConstants, 0, null, pConstants, 0, 0);
context.VertexShaderSetConstantBuffers(g_iConstantsConstantBufferBind, new[] { this.g_pcbConstants });
context.PixelShaderSetConstantBuffers(g_iConstantsConstantBufferBind, new[] { this.g_pcbConstants });
// Set the shaders
context.VertexShaderSetShader(this.g_pShadowMapVS, null);
context.PixelShaderSetShader(null, null);
// Set the vertex buffer format
context.InputAssemblerSetInputLayout(this.g_pSceneVertexLayout);
// Render the scene
this.g_Poles.Render(0, -1, -1);
// reset the old viewport etc.
context.RasterizerStageSetScissorRects(oldRects);
context.RasterizerStageSetViewports(oldVp);
}