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);
}
}
public void CreateDeviceDependentResources(DeviceResources resources)
{
this.deviceResources = resources;
byte[] renderSceneVertexShaderBytecode = File.ReadAllBytes("RenderSceneVertexShader.cso");
this.g_pSceneVS = this.deviceResources.D3DDevice.CreateVertexShader(renderSceneVertexShaderBytecode, null);
D3D11InputElementDesc[] layoutDesc = new D3D11InputElementDesc[]
{
new D3D11InputElementDesc
{
SemanticName = "POSITION",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 0,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new D3D11InputElementDesc
{
SemanticName = "NORMAL",
SemanticIndex = 0,
Format = DxgiFormat.R32G32B32Float,
InputSlot = 0,
AlignedByteOffset = 12,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
},
new D3D11InputElementDesc
{
SemanticName = "TEXTURE",
SemanticIndex = 0,
Format = DxgiFormat.R32G32Float,
InputSlot = 0,
AlignedByteOffset = 24,
InputSlotClass = D3D11InputClassification.PerVertexData,
InstanceDataStepRate = 0
}
};
this.g_pSceneVertexLayout = this.deviceResources.D3DDevice.CreateInputLayout(layoutDesc, renderSceneVertexShaderBytecode);
byte[] renderScenePixelShaderBytecode = File.ReadAllBytes("RenderScenePixelShader.cso");
this.g_pScenePS = this.deviceResources.D3DDevice.CreatePixelShader(renderScenePixelShaderBytecode, null);
byte[] renderSceneShadowMapVertexShaderBytecode = File.ReadAllBytes("RenderSceneShadowMapVertexShader.cso");
this.g_pShadowMapVS = this.deviceResources.D3DDevice.CreateVertexShader(renderSceneShadowMapVertexShaderBytecode, null);
this.g_SceneMesh = SdkMeshFile.FromFile(this.deviceResources.D3DDevice, this.deviceResources.D3DContext, @"ColumnScene\scene.sdkmesh");
this.g_Poles = SdkMeshFile.FromFile(this.deviceResources.D3DDevice, this.deviceResources.D3DContext, @"ColumnScene\poles.sdkmesh");
this.g_pcbConstants = this.deviceResources.D3DDevice.CreateBuffer(
new D3D11BufferDesc(ConstantBufferConstants.Size, D3D11BindOptions.ConstantBuffer));
D3D11SamplerDesc samplerDesc = new D3D11SamplerDesc(
D3D11Filter.ComparisonMinMagMipPoint,
D3D11TextureAddressMode.Border,
D3D11TextureAddressMode.Border,
D3D11TextureAddressMode.Border,
0.0f,
1,
D3D11ComparisonFunction.LessEqual,
new float[] { 1.0f, 1.0f, 1.0f, 1.0f },
0.0f,
float.MaxValue);
// PointCmp
this.g_pSamplePointCmp = this.deviceResources.D3DDevice.CreateSamplerState(samplerDesc);
// Point
samplerDesc.Filter = D3D11Filter.MinMagMipPoint;
samplerDesc.ComparisonFunction = D3D11ComparisonFunction.Always;
this.g_pSamplePoint = this.deviceResources.D3DDevice.CreateSamplerState(samplerDesc);
// Linear
samplerDesc.Filter = D3D11Filter.MinMagMipLinear;
samplerDesc.AddressU = D3D11TextureAddressMode.Wrap;
samplerDesc.AddressV = D3D11TextureAddressMode.Wrap;
samplerDesc.AddressW = D3D11TextureAddressMode.Wrap;
this.g_pSampleLinear = this.deviceResources.D3DDevice.CreateSamplerState(samplerDesc);
// Create a blend state to disable alpha blending
D3D11BlendDesc blendDesc = D3D11BlendDesc.Default;
blendDesc.IsIndependentBlendEnabled = false;
D3D11RenderTargetBlendDesc[] blendDescRenderTargets = blendDesc.GetRenderTargets();
blendDescRenderTargets[0].IsBlendEnabled = false;
blendDescRenderTargets[0].RenderTargetWriteMask = D3D11ColorWriteEnables.All;
blendDesc.SetRenderTargets(blendDescRenderTargets);
this.g_pBlendStateNoBlend = this.deviceResources.D3DDevice.CreateBlendState(blendDesc);
blendDescRenderTargets[0].RenderTargetWriteMask = D3D11ColorWriteEnables.None;
blendDesc.SetRenderTargets(blendDescRenderTargets);
this.g_pBlendStateColorWritesOff = this.deviceResources.D3DDevice.CreateBlendState(blendDesc);
// textures / rts
D3D11Texture2DDesc TDesc = new D3D11Texture2DDesc(
DxgiFormat.R16Typeless,
(uint)g_fShadowMapWidth,
(uint)g_fShadowMapHeight,
1,
1,
D3D11BindOptions.DepthStencil | D3D11BindOptions.ShaderResource);
this.g_pShadowMapDepthStencilTexture = this.deviceResources.D3DDevice.CreateTexture2D(TDesc);
D3D11ShaderResourceViewDesc SRVDesc = new D3D11ShaderResourceViewDesc
{
Format = DxgiFormat.R16UNorm,
ViewDimension = D3D11SrvDimension.Texture2D,
Texture2D = new D3D11Texture2DSrv
{
MipLevels = 1,
MostDetailedMip = 0
}
};
this.g_pDepthTextureSRV = this.deviceResources.D3DDevice.CreateShaderResourceView(this.g_pShadowMapDepthStencilTexture, SRVDesc);
D3D11DepthStencilViewDesc DSVDesc = new D3D11DepthStencilViewDesc
{
Format = DxgiFormat.D16UNorm,
ViewDimension = D3D11DsvDimension.Texture2D,
Options = D3D11DepthStencilViewOptions.None,
Texture2D = new D3D11Texture2DDsv
{
MipSlice = 0
}
};
this.g_pDepthStencilTextureDSV = this.deviceResources.D3DDevice.CreateDepthStencilView(this.g_pShadowMapDepthStencilTexture, DSVDesc);
XMFloat3 vecEye = new XMFloat3(0.95f, 5.83f, -14.48f);
XMFloat3 vecAt = new XMFloat3(0.90f, 5.44f, -13.56f);
XMFloat3 vecUp = new XMFloat3(0.0f, 1.0f, 0.0f);
this.ViewMatrix = XMMatrix.LookAtLH(vecEye, vecAt, vecUp);
this.WorldMatrix = XMMatrix.Identity;
XMFloat3 vecEyeL = new XMFloat3(0, 0, 0);
XMFloat3 vecAtL = new XMFloat3(0, -0.5f, 1);
XMFloat3 vecUUpL = new XMFloat3(0.0f, 1.0f, 0.0f);
this.LightViewMatrix = XMMatrix.LookAtLH(vecEyeL, vecAtL, vecUUpL);
this.LightWorldMatrix = XMMatrix.Identity;
}
