/// <summary>
/// Function to perform initialization of the view.
/// </summary>
protected override void OnInitialize()
{
D3D.DepthStencilViewDescription desc = default(D3D.DepthStencilViewDescription);
desc.Dimension = D3D.DepthStencilViewDimension.Unknown;
switch (Resource.ResourceType)
{
case ResourceType.Texture1D:
desc = GetDesc1D();
break;
case ResourceType.Texture2D:
desc = GetDesc2D();
break;
}
if (desc.Dimension == D3D.DepthStencilViewDimension.Unknown)
{
throw new GorgonException(GorgonResult.CannotCreate, Resources.GORGFX_VIEW_CANNOT_BIND_UNKNOWN_RESOURCE);
}
D3DView = new D3D.DepthStencilView(Resource.Graphics.D3DDevice, Resource.D3DResource, desc)
{
DebugName = string.Format("{0} '{1}' Depth Stencil View", Resource.ResourceType, Resource.Name)
};
}
private void PlatformConstruct(GraphicsDevice graphicsDevice, int width, int height, bool mipMap,
SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
{
// Setup the multisampling description.
var multisampleDesc = new SharpDX.DXGI.SampleDescription(1, 0);
if (preferredMultiSampleCount > 1)
{
multisampleDesc.Count = preferredMultiSampleCount;
multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
}
// Create a descriptor for the depth/stencil buffer.
// Allocate a 2-D surface as the depth/stencil buffer.
// Create a DepthStencil view on this surface to use on bind.
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, new Texture2DDescription
{
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = multisampleDesc,
BindFlags = BindFlags.DepthStencil,
}))
{
// Create the view for binding to the device.
_depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer, new DepthStencilViewDescription()
{
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
Dimension = DepthStencilViewDimension.Texture2D
});
}
}
/// <summary>
/// Resize backbuffer the specified width and height
/// </summary>
/// <param name="width">The width.</param>
/// <param name="height">The height.</param>
/// <exception cref="System.Exception">
/// </exception>
public void Resize(int width, int height)
{
if (d3dDevice == null || swapChain == null || d3dContext == null)
{
throw new Exception(MethodBase.GetCurrentMethod().Name + "Device, DeviceContext or SwapChain is null");
}
if (width <= 0 || height <= 0)
{
throw new Exception(MethodBase.GetCurrentMethod().Name + " Width or height less than or equal to zero");
}
this.width = width;
this.height = height;
if (d3dRenderTarget != null)
{
d3dContext.OutputMerger.SetRenderTargets(null, (D3D11.RenderTargetView)null);
d3dRenderTarget.Dispose();
d3dRenderTarget = null;
}
swapChain.ResizeBuffers(1,
width, height,
swapChain.Description.ModeDescription.Format,
swapChain.Description.Flags);
d3dRenderTarget = CreateRenderTarget();
d3dDepthStencil = CreateDepthStencil();
System.Diagnostics.Debug.WriteLine(MethodBase.GetCurrentMethod().Name + " Buffers resized " + width + ":" + height);
viewport = new Viewport(0, 0, width, height);
}
public DepthBuffer(Dx11ChainedDevice device, int width, int height)
{
try
{
_device = device;
_depthBuffer = new Texture2D(_device.Device, new Texture2DDescription
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
_depthView = new DepthStencilView(device.Device, _depthBuffer);
}
catch
{
Dispose();
throw;
}
}
/// <summary>
/// Инициализирует объекты связанные с графическим устройство - Девайс его контекст и Свапчейн
/// </summary>
private void InitializeDeviceResources()
{
//Создаем объектное преставление нашего GPU, его контекст и класс который будет менят местами буфферы в которые рисует наша GPU
DX11.Device.CreateWithSwapChain(
SharpDX.Direct3D.DriverType.Hardware,
DX11.DeviceCreationFlags.None | DX11.DeviceCreationFlags.BgraSupport,
new[] { SharpDX.Direct3D.FeatureLevel.Level_11_0 },
new SwapChainDescription()
{
ModeDescription = new ModeDescription(
_renderForm.ClientSize.Width,
_renderForm.ClientSize.Height,
new Rational(60, 1),
Format.R8G8B8A8_UNorm),
SampleDescription = new SampleDescription(4, 0),
Usage = Usage.BackBuffer | Usage.RenderTargetOutput,
BufferCount = 2,
OutputHandle = _renderForm.Handle,
IsWindowed = true,
SwapEffect = SwapEffect.Discard,
Flags = SwapChainFlags.None
},
out _dx11Device,
out _swapChain);
//Игноровать все события видновс
_factory = _swapChain.GetParent <Factory>();
_factory.MakeWindowAssociation(_renderForm.Handle, WindowAssociationFlags.IgnoreAll);
// Создаем буффер и вьюшку глубины
using (var _depthBuffer = new DX11.Texture2D(
_dx11Device,
new DX11.Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = _renderForm.ClientSize.Width,
Height = _renderForm.ClientSize.Height,
SampleDescription = _swapChain.Description.SampleDescription,
Usage = DX11.ResourceUsage.Default,
BindFlags = DX11.BindFlags.DepthStencil,
CpuAccessFlags = DX11.CpuAccessFlags.None,
OptionFlags = DX11.ResourceOptionFlags.None
}))
_depthView = new DX11.DepthStencilView(_dx11Device, _depthBuffer, new SharpDX.Direct3D11.DepthStencilViewDescription()
{
Dimension = (SwapChain.Description.SampleDescription.Count > 1 ||
SwapChain.Description.SampleDescription.Quality > 0) ?
DX11.DepthStencilViewDimension.Texture2DMultisampled :
DX11.DepthStencilViewDimension.Texture2D,
Flags = DX11.DepthStencilViewFlags.None
});
//Создаем буффер и вьюшку для рисования
using (DX11.Texture2D backBuffer = _swapChain.GetBackBuffer <DX11.Texture2D>(0))
_renderView = new DX11.RenderTargetView(_dx11Device, backBuffer);
//Создаем контекст нашего GPU
_dx11DeviceContext = _dx11Device.ImmediateContext;
//Устанавливаем размер конечной картинки
_dx11DeviceContext.Rasterizer.SetViewport(0, 0, _renderForm.ClientSize.Width, _renderForm.ClientSize.Height);
_dx11DeviceContext.OutputMerger.SetTargets(_depthView, _renderView);
}
/// <summary>
/// Initializes a new instance of the <see cref="RenderTargets"/> struct.
/// </summary>
/// <param name="colorBuffer">The color buffer.</param>
/// <param name="depthStencilBuffer">The depth stencil buffer.</param>
/// <param name="objectIDBuffer">The object identifier buffer.</param>
public RenderTargets(D3D11.RenderTargetView colorBuffer, D3D11.DepthStencilView depthStencilBuffer, D3D11.RenderTargetView objectIDBuffer)
{
this.ColorBuffer = colorBuffer;
this.DepthStencilBuffer = depthStencilBuffer;
this.ObjectIDBuffer = objectIDBuffer;
this.NormalDepthBuffer = null;
}
internal void Clear()
{
m_deviceContext.ClearState();
m_inputLayout = null;
m_primitiveTopology = PrimitiveTopology.Undefined;
m_indexBufferRef = null;
m_indexBufferFormat = 0;
m_indexBufferOffset = 0;
for (int i = 0; i < m_vertexBuffers.Length; i++)
m_vertexBuffers[i] = null;
for (int i = 0; i < m_vertexBuffersStrides.Length; i++)
m_vertexBuffersStrides[i] = 0;
m_blendState = null;
m_stencilRef = 0;
m_depthStencilState = null;
m_rtvsCount = 0;
for (int i = 0; i < m_rtvs.Length; i++)
m_rtvs[i] = null;
m_dsv = null;
m_rasterizerState = null;
m_scissorLeftTop = new Vector2I(-1, -1);
m_scissorRightBottom = new Vector2I(-1, -1);
m_viewport = default(RawViewportF);
m_targetBuffer = null;
m_targetOffsets = 0;
m_statistics.ClearStates++;
}
/// <summary>
/// Disposes all loaded view resources.
/// </summary>
private void OnRenderLoopDisposeViewResources(EngineDevice engineDevice)
{
m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth);
m_depthBuffer = GraphicsHelper.DisposeObject(m_depthBuffer);
m_renderTargetView = GraphicsHelper.DisposeObject(m_renderTargetView);
m_backBuffer = GraphicsHelper.DisposeObject(m_backBuffer);
}
public RenderViews(D3D11.RenderTargetView rtv, D3D11.DepthStencilView dsv,
D3D11.ShaderResourceView rtv_srvt, D3D11.ShaderResourceView dsv_srvt)
: this(rtv, dsv)
{
this.RT_SRVT = rtv_srvt;
this.DS_SRVT = dsv_srvt;
}
/// <summary>
/// Create all view resources.
/// </summary>
Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.Mathematics.Interop.RawViewportF, Size2, DpiScaling> IRenderLoopHost.OnRenderLoop_CreateViewResources(EngineDevice device)
{
//Get references to current render device
m_device = device.DeviceD3D11_1;
m_deviceContext = m_device.ImmediateContext;
// Create swapchain and dummy form
m_swapChain = GraphicsHelper.CreateSwapChainForFullScreen(
m_dummyForm,
m_targetOutput, m_targetOutputMode,
device, m_renderLoop.ViewConfiguration);
// Take width and height out of the render target
m_renderTarget = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(m_swapChain, 0);
m_renderTargetView = new D3D11.RenderTargetView(m_device, m_renderTarget);
//Create the depth buffer
m_renderTargetDepth = GraphicsHelper.CreateDepthBufferTexture(device, m_targetOutputMode.PixelWidth, m_targetOutputMode.PixelHeight, m_renderLoop.ViewConfiguration);
m_renderTargetDepthView = new D3D11.DepthStencilView(m_device, m_renderTargetDepth);
//Define the viewport for rendering
SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(m_targetOutputMode.PixelWidth, m_targetOutputMode.PixelHeight);
//Return all generated objects
return(Tuple.Create(m_renderTarget, m_renderTargetView, m_renderTargetDepth, m_renderTargetDepthView, viewPort, new Size2(m_targetOutputMode.PixelWidth, m_targetOutputMode.PixelHeight), DpiScaling.Default));
}
/// <summary>
///
/// </summary>
/// <param name="dsv"></param>
internal DepthStencilSurface ( DepthStencilView dsv, DepthFormat format, int width, int height, int sampleCount )
{
Width = width;
Height = height;
Format = format;
SampleCount = sampleCount;
DSV = dsv;
}
/// <summary>
/// Disposes all loaded view resources.
/// </summary>
void IRenderLoopHost.OnRenderLoop_DisposeViewResources(EngineDevice engineDevice)
{
m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth);
m_depthBuffer = GraphicsHelper.DisposeObject(m_depthBuffer);
m_renderTargetView = GraphicsHelper.DisposeObject(m_renderTargetView);
m_backBuffer = GraphicsHelper.DisposeObject(m_backBuffer);
m_backBufferMultisampled = GraphicsHelper.DisposeObject(m_backBufferMultisampled);
m_swapChain = GraphicsHelper.DisposeObject(m_swapChain);
}
public RenderTexture(Device device, Vector2I size)
{
var textureDesc = new Texture2DDescription
{
Width = size.X,
Height = size.Y,
MipLevels = 1,
ArraySize = 1,
Format = Format.R32G32B32A32_Float,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
_renderTargetTexture = new Texture2D(device, textureDesc);
_renderTargetView = new RenderTargetView(device, _renderTargetTexture,
new RenderTargetViewDescription
{
Format = textureDesc.Format,
Dimension = RenderTargetViewDimension.Texture2D,
Texture2D = { MipSlice = 0 },
});
// Create the render target view.
ShaderResourceView = new ShaderResourceView(device, _renderTargetTexture,
new ShaderResourceViewDescription
{
Format = textureDesc.Format,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = { MipLevels = 1, MostDetailedMip = 0 },
});
_depthStencilView = new DepthStencilView(device, new Texture2D(device, new Texture2DDescription
{
Width = size.X,
Height = size.Y,
MipLevels = 1,
ArraySize = 1,
Format = Format.D24_UNorm_S8_UInt,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
}), new DepthStencilViewDescription
{
Format = Format.D24_UNorm_S8_UInt,
Dimension = DepthStencilViewDimension.Texture2D,
Texture2D = new DepthStencilViewDescription.Texture2DResource { MipSlice = 0 }
});
}
public void ClearRenderTarget(DeviceContext context, DepthStencilView depthStencilView, float red, float green, float blue, float alpha)
{
// Setup the color the buffer to.
var color = new Color4(red, green, blue, alpha);
// Clear the back buffer.
context.ClearRenderTargetView(RenderTargetView, color);
// Clear the depth buffer.
context.ClearDepthStencilView(depthStencilView, DepthStencilClearFlags.Depth, 1.0f, 0);
}
/// <summary>
/// Disposes all loaded view resources.
/// </summary>
void IRenderLoopHost.OnRenderLoop_DisposeViewResources(EngineDevice device)
{
m_renderTargetDepthView = GraphicsHelper.DisposeObject(m_renderTargetDepthView);
m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth);
m_renderTargetView = GraphicsHelper.DisposeObject(m_renderTargetView);
m_renderTarget = GraphicsHelper.DisposeObject(m_renderTarget);
m_copyHelperTextureStaging = GraphicsHelper.DisposeObject(m_copyHelperTextureStaging);
m_device = null;
m_deviceContext = null;
}
public void CreateResources(D3D11.Device device, int sampleCount, int sampleQuality, int width, int height)
{
FieldOfView = width / (float)height;
// render target
D3D11.Texture2DDescription targetTextureDesc = new D3D11.Texture2DDescription()
{
Format = DXGI.Format.R8G8B8A8_UNorm,
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = new DXGI.SampleDescription(sampleCount, sampleQuality),
Usage = D3D11.ResourceUsage.Default,
BindFlags = D3D11.BindFlags.RenderTarget | D3D11.BindFlags.ShaderResource,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
OptionFlags = D3D11.ResourceOptionFlags.None
};
using (D3D11.Texture2D target = new D3D11.Texture2D(device, targetTextureDesc)) {
renderTargetResource = new D3D11.ShaderResourceView(device, target);
renderTargetView = new D3D11.RenderTargetView(device, target);
}
// depth buffer
D3D11.Texture2DDescription depthTextureDesc = new D3D11.Texture2DDescription()
{
Format = DXGI.Format.R32_Typeless,
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = new DXGI.SampleDescription(sampleCount, sampleQuality),
Usage = D3D11.ResourceUsage.Default,
BindFlags = D3D11.BindFlags.DepthStencil | D3D11.BindFlags.ShaderResource,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
OptionFlags = D3D11.ResourceOptionFlags.None
};
D3D11.DepthStencilViewDescription depthViewDesc = new D3D11.DepthStencilViewDescription()
{
Flags = D3D11.DepthStencilViewFlags.None,
Dimension = D3D11.DepthStencilViewDimension.Texture2D,
Format = DXGI.Format.D32_Float,
};
D3D11.ShaderResourceViewDescription depthResourceDesc = new D3D11.ShaderResourceViewDescription()
{
Format = DXGI.Format.R32_Float,
Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D
};
depthResourceDesc.Texture2D.MipLevels = 1;
using (D3D11.Texture2D depthTexture = new D3D11.Texture2D(device, depthTextureDesc)) {
depthStencilView = new D3D11.DepthStencilView(device, depthTexture, depthViewDesc);
depthStencilResource = new D3D11.ShaderResourceView(device, depthTexture, depthResourceDesc);
}
}
/// <summary>
/// Disposes all loaded view resources.
/// </summary>
void IRenderLoopHost.OnRenderLoop_DisposeViewResources(EngineDevice device)
{
m_factory = null;
m_renderDevice = null;
m_renderDeviceContext = null;
m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth);
m_depthBuffer = GraphicsHelper.DisposeObject(m_depthBuffer);
m_renderTarget = GraphicsHelper.DisposeObject(m_renderTarget);
m_backBuffer = GraphicsHelper.DisposeObject(m_backBuffer);
m_swapChain = GraphicsHelper.DisposeObject(m_swapChain);
}
/// <summary>
/// Function to perform initialization of the view.
/// </summary>
private protected override D3D11.ResourceView OnCreateNativeView()
{
D3D11.DepthStencilViewDescription desc = GetDesc2D();
Graphics.Log.Print($"'{Texture.Name}': Creating D3D11 depth/stencil view.", LoggingLevel.Simple);
Graphics.Log.Print($"Depth/Stencil View '{Texture.Name}': {Texture.ResourceType} -> Mip slice: {MipSlice}, Array Index: {ArrayIndex}, Array Count: {ArrayCount}",
LoggingLevel.Verbose);
Native = new D3D11.DepthStencilView(Texture.Graphics.D3DDevice, Texture.D3DResource, desc)
{
DebugName = $"'{Texture.Name}'_D3D11DepthStencilView1_2D"
};
return(Native);
}
// https://gamedev.stackexchange.com/questions/75461/how-do-i-set-up-a-depth-buffer-in-sharpdx
// https://docs.microsoft.com/en-us/windows/desktop/direct3d11/d3d10-graphics-programming-guide-depth-stencil
private void EnableDepthTest()
{
if (depthStencilView != null)
{
depthStencilView.Dispose();
}
if (depthStencilState != null)
{
depthStencilState.Dispose();
}
// Create the depth stencil description
depthTextureDesc = new D3D11.Texture2DDescription
{
Format = Format.D16_UNorm,
ArraySize = 1,
MipLevels = 1,
Width = this.Width,
Height = this.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = D3D11.ResourceUsage.Default,
BindFlags = D3D11.BindFlags.DepthStencil,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
OptionFlags = D3D11.ResourceOptionFlags.None
};
// Create the depth stencil view
using (var depthTex = new D3D11.Texture2D(d3dDevice, depthTextureDesc))
{
depthStencilView = new D3D11.DepthStencilView(d3dDevice, depthTex);
}
// Create the depth stencil state description
depthStencilStateDesc = new D3D11.DepthStencilStateDescription();
depthStencilStateDesc.IsDepthEnabled = true;
depthStencilStateDesc.DepthWriteMask = D3D11.DepthWriteMask.All;
depthStencilStateDesc.DepthComparison = D3D11.Comparison.Less;
depthStencilStateDesc.IsStencilEnabled = false;
// Create the depth stencil state
depthStencilState = new D3D11.DepthStencilState(d3dDevice, depthStencilStateDesc);
// Update the context
d3dDeviceContext.OutputMerger.SetTargets(depthStencilView, renderTargetView);
d3dDeviceContext.OutputMerger.SetDepthStencilState(depthStencilState);
}
public ShadowMap(Device device, int width, int height) {
_width = width;
_height = height;
_viewport = new Viewport(0, 0, _width, _height, 0, 1.0f);
var texDesc = new Texture2DDescription {
Width = _width,
Height = _height,
MipLevels = 1,
ArraySize = 1,
Format = Format.R24G8_Typeless,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
var depthMap = new Texture2D(device, texDesc) {
DebugName = "shadowmap depthmap"
};
var dsvDesc = new DepthStencilViewDescription {
Flags = DepthStencilViewFlags.None,
Format = Format.D24_UNorm_S8_UInt,
Dimension = DepthStencilViewDimension.Texture2D,
Texture2D = new DepthStencilViewDescription.Texture2DResource() {
MipSlice = 0
}
};
_depthMapDSV = new DepthStencilView(device, depthMap, dsvDesc);
var srvDesc = new ShaderResourceViewDescription {
Format = Format.R24_UNorm_X8_Typeless,
Dimension = ShaderResourceViewDimension.Texture2D,
Texture2D = new ShaderResourceViewDescription.Texture2DResource() {
MipLevels = texDesc.MipLevels,
MostDetailedMip = 0
}
};
DepthMapSRV = new ShaderResourceView(device, depthMap, srvDesc);
Utilities.Dispose(ref depthMap);
}
/// <summary>
/// Create all view resources.
/// </summary>
Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.Mathematics.Interop.RawViewportF, Size2, DpiScaling> IRenderLoopHost.OnRenderLoop_CreateViewResources(EngineDevice device)
{
int width = this.Width;
int height = this.Height;
if (width <= Constants.MIN_VIEW_WIDTH)
{
width = Constants.MIN_VIEW_WIDTH;
}
if (height <= Constants.MIN_VIEW_HEIGHT)
{
height = Constants.MIN_VIEW_HEIGHT;
}
//Get all factories
m_factory = device.FactoryDxgi;
//Get all devices
m_renderDevice = device.DeviceD3D11_1;
m_renderDeviceContext = m_renderDevice.ImmediateContext;
//Create the swap chain and the render target
m_swapChain = GraphicsHelper.CreateSwapChainForWinForms(this, device, m_renderLoop.ViewConfiguration);
m_backBuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(m_swapChain, 0);
m_renderTarget = new D3D11.RenderTargetView(m_renderDevice, m_backBuffer);
//Create the depth buffer
m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(device, width, height, m_renderLoop.ViewConfiguration);
m_renderTargetDepth = new D3D11.DepthStencilView(m_renderDevice, m_depthBuffer);
//Define the viewport for rendering
SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(width, height);
// Query for current dpi value
DpiScaling dpiScaling = DpiScaling.Default;
using (Graphics graphics = this.CreateGraphics())
{
dpiScaling.DpiX = graphics.DpiX;
dpiScaling.DpiY = graphics.DpiY;
}
//Return all generated objects
return(Tuple.Create(m_backBuffer, m_renderTarget, m_depthBuffer, m_renderTargetDepth, viewPort, new Size2(width, height), dpiScaling));
}
/// <summary>
/// Create all view resources.
/// </summary>
Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.Mathematics.Interop.RawViewportF, Size2, DpiScaling> IRenderLoopHost.OnRenderLoop_CreateViewResources(EngineDevice engineDevice)
{
// Calculate pixel with and high of this visual
Size pixelSize = this.GetPixelSize(new Size(100.0, 100.0));
int width = (int)pixelSize.Width;
int height = (int)pixelSize.Height;
//Get references to current render device
D3D11.Device renderDevice = engineDevice.DeviceD3D11_1;
D3D11.DeviceContext renderDeviceContext = renderDevice.ImmediateContext;
//Create the swap chain and the render target
m_backBufferD3D11 = GraphicsHelper.CreateRenderTargetTexture(engineDevice, width, height, m_renderLoop.ViewConfiguration);
m_backBufferForWpf = GraphicsHelper.CreateSharedTexture(engineDevice, width, height);
m_renderTarget = new D3D11.RenderTargetView(renderDevice, m_backBufferD3D11);
//Create the depth buffer
m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(engineDevice, width, height, m_renderLoop.ViewConfiguration);
m_renderTargetDepth = new D3D11.DepthStencilView(renderDevice, m_depthBuffer);
//Apply render target size values
m_renderTargetWidth = width;
m_renderTargetHeight = height;
//Define the viewport for rendering
SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(width, height);
//Apply new width and height values of the viewport
m_viewportWidth = width;
m_viewportHeight = height;
//Create and apply the image source object
m_d3dImageSource = new HigherD3DImageSource(engineDevice);
m_d3dImageSource.SetRenderTarget(m_backBufferForWpf);
if (this.Source == m_dummyBitmap)
{
this.Source = m_d3dImageSource;
}
m_lastRecreateWidth = width;
m_lastRecreateHeight = height;
//Return all generated objects
return(Tuple.Create(m_backBufferD3D11, m_renderTarget, m_depthBuffer, m_renderTargetDepth, viewPort, new Size2(width, height), GetDpiScaling()));
}
public RenderTarget3D(GraphicsDevice graphicsDevice, int width, int height, int depth, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage)
:base (graphicsDevice, width, height, depth, mipMap, preferredFormat, true)
{
DepthStencilFormat = preferredDepthFormat;
MultiSampleCount = preferredMultiSampleCount;
RenderTargetUsage = usage;
// If we don't need a depth buffer then we're done.
if (preferredDepthFormat == DepthFormat.None)
return;
#if DIRECTX
// Setup the multisampling description.
var multisampleDesc = new SharpDX.DXGI.SampleDescription(1, 0);
if ( preferredMultiSampleCount > 1 )
{
multisampleDesc.Count = preferredMultiSampleCount;
multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
}
// Create a descriptor for the depth/stencil buffer.
// Allocate a 2-D surface as the depth/stencil buffer.
// Create a DepthStencil view on this surface to use on bind.
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, new Texture2DDescription
{
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = multisampleDesc,
BindFlags = BindFlags.DepthStencil,
}))
{
// Create the view for binding to the device.
_depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer, new DepthStencilViewDescription()
{
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
Dimension = DepthStencilViewDimension.Texture2D
});
}
#endif // DIRECTX
}
public DXImageSource(GraphicsDevice graphics, int width, int height)
{
if (width < 10) width = 10;
if (height < 10) height = 10;
_renderTarget = RenderTarget2D.New(graphics, width, height, SharpDX.Toolkit.Graphics.PixelFormat.B8G8R8A8.UNorm);
_renderTargetView = new RenderTargetView(graphics, (SharpDX.Toolkit.Graphics.GraphicsResource)_renderTarget);
SharpDX.Direct3D11.Texture2D depthBuffer = new SharpDX.Direct3D11.Texture2D(graphics, new Texture2DDescription()
{
Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt,
ArraySize=1,
MipLevels=0,
Width = width,
Height = height,
SampleDescription = new SharpDX.DXGI.SampleDescription(1,0),
BindFlags = SharpDX.Direct3D11.BindFlags.DepthStencil
});
//_depthStencilBuffer = DepthStencilBuffer.New(graphics,width,height,DepthFormat.Depth24Stencil8);
_depthStencilView = new DepthStencilView(graphics, depthBuffer);
Texture2DDescription description = new Texture2DDescription()
{
Width = width,
Height = height,
MipLevels = 1,
ArraySize = 1,
Format = SharpDX.DXGI.Format.B8G8R8A8_UNorm,
BindFlags = BindFlags.None,
CpuAccessFlags = CpuAccessFlags.Read,
SampleDescription = new SharpDX.DXGI.SampleDescription()
{
Count = 1,
Quality = 0
},
Usage = ResourceUsage.Staging,
OptionFlags = ResourceOptionFlags.None
};
_stagingTexture = SharpDX.Toolkit.Graphics.Texture2D.New(graphics, description);
_buffer = new byte[width * height * 4];
_writeableBitmap = new WriteableBitmap(
width, height, 96, 96, PixelFormats.Bgr32, null);
}
protected override void OnLoad(EventArgs e)
{
base.OnLoad(e);
if (DesignMode)
return;
// create swap chain, rendertarget
var swapChainDesc = new SwapChainDescription()
{
BufferCount = 1,
Usage = Usage.RenderTargetOutput,
OutputHandle = videoPanel1.Handle,
IsWindowed = true,
ModeDescription = new ModeDescription(0, 0, new Rational(60, 1), Format.R8G8B8A8_UNorm),
Flags = SwapChainFlags.AllowModeSwitch,
SwapEffect = SwapEffect.Discard,
SampleDescription = new SampleDescription(1, 0),
};
swapChain = new SwapChain(factory, device, swapChainDesc);
// render target
renderTarget = Texture2D.FromSwapChain<Texture2D>(swapChain, 0);
renderTargetView = new RenderTargetView(device, renderTarget);
// depth buffer
var depthBufferDesc = new Texture2DDescription()
{
Width = videoPanel1.Width,
Height = videoPanel1.Height,
MipLevels = 1,
ArraySize = 1,
Format = Format.D32_Float, // necessary?
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None
};
depthStencil = new Texture2D(device, depthBufferDesc);
depthStencilView = new DepthStencilView(device, depthStencil);
// viewport
viewport = new Viewport(0, 0, videoPanel1.Width, videoPanel1.Height, 0f, 1f);
}
/// <summary>
/// Disposes all loaded view resources.
/// </summary>
void IRenderLoopHost.OnRenderLoop_DisposeViewResources(EngineDevice device)
{
// Switch to fullscreen
if (m_isInFullscreen)
{
m_isInFullscreen = false;
m_swapChain.SetFullscreenState(false, null);
}
m_renderTargetDepthView = GraphicsHelper.DisposeObject(m_renderTargetDepthView);
m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth);
m_renderTargetView = GraphicsHelper.DisposeObject(m_renderTargetView);
m_renderTarget = GraphicsHelper.DisposeObject(m_renderTarget);
m_swapChain = GraphicsHelper.DisposeObject(m_swapChain);
m_device = null;
m_deviceContext = null;
}
protected override void OnSurfaceInvalidated(object sender, EventArgs e) {
var swapChain = D3DApp11.I.SwapChain;
var clientSize = D3DApp11.I.ControlWindow.ClientSize;
var device = D3DApp11.I.D3DDevice;
var immediateContext = D3DApp11.I.ImmediateContext;
// Dispose all previous allocated resources
Utilities.Dispose(ref _backBuffer);
Utilities.Dispose(ref _renderView);
Utilities.Dispose(ref _depthBuffer);
Utilities.Dispose(ref _depthView);
// Resize the backbuffer
swapChain.ResizeBuffers(_swapChainDescription.BufferCount, clientSize.Width, clientSize.Height, Format.Unknown, SwapChainFlags.None);
// Get the backbuffer from the swapchain
_backBuffer = Resource.FromSwapChain<Texture2D>(swapChain, 0);
// Renderview on the backbuffer
_renderView = new RenderTargetView(device, _backBuffer);
// Create the depth buffer
_depthBuffer = new Texture2D(device, new Texture2DDescription() {
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = clientSize.Width,
Height = clientSize.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
// Create the depth buffer view
_depthView = new DepthStencilView(device, _depthBuffer);
// Setup targets and viewport for rendering
_viewport = new Viewport(0, 0, clientSize.Width, clientSize.Height, 0.0f, 1.0f);
immediateContext.Rasterizer.SetViewport(_viewport);
immediateContext.OutputMerger.SetTargets(_depthView, _renderView);
base.OnSurfaceInvalidated(sender, e);
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="device">Device</param>
/// <param name="size">Cube Size</param>
/// <param name="format">Color Format</param>
public SharpCubeTarget(SharpDevice device, int size, Format format)
{
Device = device;
Size = size;
Texture2D target = new Texture2D(device.Device, new Texture2DDescription()
{
Format = format,
Width = size,
Height = size,
ArraySize = 6,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.TextureCube,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
});
_target = new RenderTargetView(device.Device, target);
_resource = new ShaderResourceView(device.Device, target);
ComObject.Dispose(ref target);
var _zbufferTexture = new Texture2D(Device.Device, new Texture2DDescription()
{
Format = Format.D16_UNorm,
ArraySize = 6,
MipLevels = 1,
Width = size,
Height = size,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.TextureCube
});
// Create the depth buffer view
_zbuffer = new DepthStencilView(Device.Device, _zbufferTexture);
ComObject.Dispose(ref _zbufferTexture);
}
private void GenerateIfRequired()
{
if (_renderTargetView != null)
return;
// Create a view interface on the rendertarget to use on bind.
_renderTargetView = new RenderTargetView(GraphicsDevice._d3dDevice, GetTexture());
// If we don't need a depth buffer then we're done.
if (DepthStencilFormat == DepthFormat.None)
return;
// Setup the multisampling description.
var multisampleDesc = new SharpDX.DXGI.SampleDescription(1, 0);
if (MultiSampleCount > 1)
{
multisampleDesc.Count = MultiSampleCount;
multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
}
// Create a descriptor for the depth/stencil buffer.
// Allocate a 2-D surface as the depth/stencil buffer.
// Create a DepthStencil view on this surface to use on bind.
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(GraphicsDevice._d3dDevice, new Texture2DDescription
{
Format = SharpDXHelper.ToFormat(DepthStencilFormat),
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = multisampleDesc,
BindFlags = BindFlags.DepthStencil,
}))
{
// Create the view for binding to the device.
_depthStencilView = new DepthStencilView(GraphicsDevice._d3dDevice, depthBuffer,
new DepthStencilViewDescription()
{
Format = SharpDXHelper.ToFormat(DepthStencilFormat),
Dimension = DepthStencilViewDimension.Texture2D
});
}
}
/// <summary>
/// Create all view resources.
/// </summary>
private Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.ViewportF, Size2> OnRenderLoopCreateViewResources(EngineDevice engineDevice)
{
Size2 viewSize = GetTargetRenderPixelSize();
// Create the backbuffer
m_backBuffer = GraphicsHelper.CreateRenderTargetTexture(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
m_backBufferSynchronizing = GraphicsHelper.CreateRenderTargetTexture(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
m_renderTargetView = new D3D11.RenderTargetView(engineDevice.DeviceD3D11, m_backBuffer);
//Create the depth buffer
m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
m_renderTargetDepth = new D3D11.DepthStencilView(engineDevice.DeviceD3D11, m_depthBuffer);
//Define the viewport for rendering
SharpDX.ViewportF viewPort = GraphicsHelper.CreateDefaultViewport(viewSize.Width, viewSize.Height);
m_lastRefreshTargetSize = viewSize;
return(Tuple.Create(m_backBuffer, m_renderTargetView, m_depthBuffer, m_renderTargetDepth, viewPort, viewSize));
}
/// <summary>
/// Create all view resources.
/// </summary>
Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.ViewportF, Size2, DpiScaling> IRenderLoopHost.OnRenderLoop_CreateViewResources(EngineDevice engineDevice)
{
m_backBufferMultisampled = null;
Size2 viewSize = GetTargetRenderPixelSize();
// Create the SwapChain and associate it with the SwapChainBackgroundPanel
m_swapChain = GraphicsHelper.CreateSwapChainForComposition(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
m_targetPanel.SwapChain = m_swapChain;
m_compositionScaleChanged = true;
// Get the backbuffer from the SwapChain
m_backBuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(m_swapChain, 0);
// Define the render target (in case of multisample an own render target)
D3D11.Texture2D backBufferForRenderloop = null;
if (m_renderLoop.ViewConfiguration.AntialiasingEnabled)
{
m_backBufferMultisampled = GraphicsHelper.CreateRenderTargetTexture(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
m_renderTargetView = new D3D11.RenderTargetView(engineDevice.DeviceD3D11, m_backBufferMultisampled);
backBufferForRenderloop = m_backBufferMultisampled;
}
else
{
m_renderTargetView = new D3D11.RenderTargetView(engineDevice.DeviceD3D11, m_backBuffer);
backBufferForRenderloop = m_backBuffer;
}
//Create the depth buffer
m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(engineDevice, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
m_renderTargetDepth = new D3D11.DepthStencilView(engineDevice.DeviceD3D11, m_depthBuffer);
//Define the viewport for rendering
SharpDX.ViewportF viewPort = GraphicsHelper.CreateDefaultViewport(viewSize.Width, viewSize.Height);
m_lastRefreshTargetSize = new Size(viewSize.Width, viewSize.Height);
DpiScaling dpiScaling = new DpiScaling();
dpiScaling.DpiX = (float)(96.0 * m_targetPanel.CompositionScaleX);
dpiScaling.DpiY = (float)(96.0 * m_targetPanel.CompositionScaleY);
return(Tuple.Create(backBufferForRenderloop, m_renderTargetView, m_depthBuffer, m_renderTargetDepth, viewPort, viewSize, dpiScaling));
}
/// <summary>
/// Constructor
/// </summary>
/// <param name="device">Device</param>
/// <param name="width">Width</param>
/// <param name="height">Height</param>
/// <param name="format">Format</param>
public SharpRenderTarget(SharpDevice device, int width, int height, Format format)
{
Device = device;
Height = height;
Width = width;
Texture2D target = new Texture2D(device.Device, new Texture2DDescription()
{
Format = format,
Width = width,
Height = height,
ArraySize = 1,
BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource,
CpuAccessFlags = CpuAccessFlags.None,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
});
_target = new RenderTargetView(device.Device, target);
_resource = new ShaderResourceView(device.Device, target);
target.Dispose();
var _zbufferTexture = new Texture2D(Device.Device, new Texture2DDescription()
{
Format = Format.D16_UNorm,
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
// Create the depth buffer view
_zbuffer = new DepthStencilView(Device.Device, _zbufferTexture);
_zbufferTexture.Dispose();
}
public static D3D.Texture2D CreateDepthStencilBuffer(this D3D.Device device, int width, int height, DXGI.SampleDescription sampleDescription, out D3D.DepthStencilView view)
{
var desc = new D3D.Texture2DDescription
{
Width = width,
Height = height,
MipLevels = 1,
ArraySize = 1,
Format = DXGI.Format.D24_UNorm_S8_UInt,
SampleDescription = sampleDescription,
Usage = D3D.ResourceUsage.Default,
BindFlags = D3D.BindFlags.DepthStencil,
CpuAccessFlags = D3D.CpuAccessFlags.None,
OptionFlags = D3D.ResourceOptionFlags.None,
};
var depthStencilBuffer = new D3D.Texture2D(device, desc);
view = new D3D.DepthStencilView(device, depthStencilBuffer);
return(depthStencilBuffer);
}
/// <summary>
/// Disposes all loaded view resources.
/// </summary>
void IRenderLoopHost.OnRenderLoop_DisposeViewResources(EngineDevice engineDevice)
{
if (m_d3dImageSource != null)
{
this.Source = m_dummyBitmap;
// Dispose the render target
m_d3dImageSource.SetRenderTarget(null);
m_d3dImageSource.Dispose();
m_d3dImageSource = null;
}
// Dispose all other resources
m_renderTarget2DDxgi = GraphicsHelper.DisposeObject(m_renderTarget2DDxgi);
m_renderTargetDepth = GraphicsHelper.DisposeObject(m_renderTargetDepth);
m_depthBuffer = GraphicsHelper.DisposeObject(m_depthBuffer);
m_renderTarget = GraphicsHelper.DisposeObject(m_renderTarget);
m_backBufferForWpf = GraphicsHelper.DisposeObject(m_backBufferForWpf);
m_backBufferD3D11 = GraphicsHelper.DisposeObject(m_backBufferD3D11);
}
public Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SDM.RawViewportF, Size2, DpiScaling> OnRenderLoop_CreateViewResources(EngineDevice device)
{
// Get the pixel size of the screen
Size2 viewSize = GetTargetRenderPixelSize();
// Create the SwapChain and associate it with the SwapChainBackgroundPanel
using (SharpDX.ComObject targetWindowCom = new SharpDX.ComObject(m_targetWindow))
{
m_swapChain = GraphicsHelper.CreateSwapChainForCoreWindow(device, targetWindowCom, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
}
// Get the backbuffer from the SwapChain
m_backBuffer = D3D11.Texture2D.FromSwapChain <D3D11.Texture2D>(m_swapChain, 0);
// Define the render target (in case of multisample an own render target)
D3D11.Texture2D backBufferForRenderloop = null;
if (m_renderLoop.ViewConfiguration.AntialiasingEnabled)
{
m_backBufferMultisampled = GraphicsHelper.CreateRenderTargetTexture(device, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
m_renderTargetView = new D3D11.RenderTargetView(device.DeviceD3D11_1, m_backBufferMultisampled);
backBufferForRenderloop = m_backBufferMultisampled;
}
else
{
m_renderTargetView = new D3D11.RenderTargetView(device.DeviceD3D11_1, m_backBuffer);
backBufferForRenderloop = m_backBuffer;
}
//Create the depth buffer
m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(device, viewSize.Width, viewSize.Height, m_renderLoop.ViewConfiguration);
m_renderTargetDepth = new D3D11.DepthStencilView(device.DeviceD3D11_1, m_depthBuffer);
//Define the viewport for rendering
SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(viewSize.Width, viewSize.Height);
m_lastRefreshTargetSize = new Size(viewSize.Width, viewSize.Height);
return(Tuple.Create(backBufferForRenderloop, m_renderTargetView, m_depthBuffer, m_renderTargetDepth, viewPort, viewSize, m_dpiScaling));
}
/// <summary>
/// Create all view resources.
/// </summary>
Tuple <D3D11.Texture2D, D3D11.RenderTargetView, D3D11.Texture2D, D3D11.DepthStencilView, SharpDX.Mathematics.Interop.RawViewportF, Size2, DpiScaling> IRenderLoopHost.OnRenderLoop_CreateViewResources(EngineDevice device)
{
int width = m_pixelWidth;
int height = m_pixelHeight;
//Get references to current render device
m_device = device.DeviceD3D11_1;
m_deviceContext = m_device.ImmediateContext;
//Create the swap chain and the render target
m_renderTarget = GraphicsHelper.CreateRenderTargetTexture(device, width, height, m_renderLoop.ViewConfiguration);
m_renderTargetView = new D3D11.RenderTargetView(m_device, m_renderTarget);
//Create the depth buffer
m_renderTargetDepth = GraphicsHelper.CreateDepthBufferTexture(device, width, height, m_renderLoop.ViewConfiguration);
m_renderTargetDepthView = new D3D11.DepthStencilView(m_device, m_renderTargetDepth);
//Define the viewport for rendering
SharpDX.Mathematics.Interop.RawViewportF viewPort = GraphicsHelper.CreateDefaultViewport(width, height);
//Return all generated objects
return(Tuple.Create(m_renderTarget, m_renderTargetView, m_renderTargetDepth, m_renderTargetDepthView, viewPort, new Size2(width, height), DpiScaling.Default));
}
/// <summary>
/// Dispose contained fields.
/// </summary>
public void Dispose()
{
if (SwapTextureSet != null)
{
SwapTextureSet.Dispose();
SwapTextureSet = null;
}
if (Textures != null)
{
foreach (Texture2D texture in Textures)
texture.Dispose();
Textures = null;
}
if (RenderTargetViews != null)
{
foreach (RenderTargetView renderTargetView in RenderTargetViews)
renderTargetView.Dispose();
RenderTargetViews = null;
}
if (DepthBuffer != null)
{
DepthBuffer.Dispose();
DepthBuffer = null;
}
if (DepthStencilView != null)
{
DepthStencilView.Dispose();
DepthStencilView = null;
}
}
/// <summary>
/// Creates Direct3D11 Device, RenderTargetView, DepthStencilView, Viewport
/// </summary>
/// <param name="deviceDescription">The device description.</param>
/// <exception cref="System.Exception"></exception>
/// <exception cref="System.ComponentModel.InvalidEnumArgumentException">deviceDescription.MultiSampleCount</exception>
private void Initialize(DeviceDescription deviceDescription)
{
FeatureLevel[] levels = new FeatureLevel[] {
FeatureLevel.Level_10_0,
FeatureLevel.Level_10_1,
FeatureLevel.Level_11_0,
FeatureLevel.Level_11_1,
};
d3dDevice = new D3D11.Device(DriverType.Hardware, D3D11.DeviceCreationFlags.Debug, levels);
DXGI.ModeDescription backBufferDesc = new DXGI.ModeDescription()
{
Width = width,
Height = height,
Format = BackBufferFormat,
RefreshRate = new DXGI.Rational(60, 1),
Scaling = DXGI.DisplayModeScaling.Unspecified,
ScanlineOrdering = DXGI.DisplayModeScanlineOrder.Progressive,
};
DXGI.SwapChainDescription swapChainDesc = new DXGI.SwapChainDescription()
{
BufferCount = 1,
Flags = DXGI.SwapChainFlags.None,
IsWindowed = !deviceDescription.Fullcreen,
ModeDescription = backBufferDesc,
OutputHandle = renderControl.Handle,
SwapEffect = deviceDescription.SwapEffect,
Usage = DXGI.Usage.RenderTargetOutput,
};
switch (deviceDescription.MultiSampleCount)
{
case MultiSampleType.MSAA1:
swapChainDesc.SampleDescription = new DXGI.SampleDescription(1, deviceDescription.MultiSampleQuality);
break;
case MultiSampleType.MSAA2:
swapChainDesc.SampleDescription = new DXGI.SampleDescription(2, deviceDescription.MultiSampleQuality);
break;
case MultiSampleType.MSAA4:
swapChainDesc.SampleDescription = new DXGI.SampleDescription(4, deviceDescription.MultiSampleQuality);
break;
case MultiSampleType.MSAA8:
swapChainDesc.SampleDescription = new DXGI.SampleDescription(8, deviceDescription.MultiSampleQuality);
break;
case MultiSampleType.MSAA16:
swapChainDesc.SampleDescription = new DXGI.SampleDescription(16, deviceDescription.MultiSampleQuality);
break;
case MultiSampleType.Unknown:
var samples = SharpDXDevice.CheckMultiSample();
if (samples == null)
{
throw new Exception(MethodBase.GetCurrentMethod().Name +
" Because the MultiSampleCount parameter is [Unknown], the device could not determine the parameter automatically");
}
swapChainDesc.SampleDescription = samples.Last();
break;
default:
throw new System.ComponentModel.InvalidEnumArgumentException("deviceDescription.MultiSampleCount",
(int)deviceDescription.MultiSampleCount, typeof(MultiSampleType));
}
DXGI.Device device = d3dDevice.QueryInterface <DXGI.Device>();
DXGI.Adapter adapter = device.GetParent <DXGI.Adapter>();
DXGI.Factory factory = adapter.GetParent <DXGI.Factory>();
swapChain = new DXGI.SwapChain(factory, d3dDevice, swapChainDesc);
d3dContext = d3dDevice.ImmediateContext;
D3D11.RasterizerStateDescription rasterDesc = new D3D11.RasterizerStateDescription()
{
CullMode = D3D11.CullMode.Back,
FillMode = D3D11.FillMode.Solid,
IsAntialiasedLineEnabled = true,
IsMultisampleEnabled = true,
IsDepthClipEnabled = true,
};
viewport = new Viewport(0, 0, width, height);
this.SetRasterizerState(rasterDesc);
d3dRenderTarget = CreateRenderTarget();
d3dDepthStencil = CreateDepthStencil();
}
public RenderViews(D3D11.RenderTargetView rtv, D3D11.DepthStencilView dsv)
{
this.RTV = rtv;
this.DSV = dsv;
}
public RenderTarget2D (GraphicsDevice graphicsDevice, int width, int height, bool mipMap, SurfaceFormat preferredFormat, DepthFormat preferredDepthFormat, int preferredMultiSampleCount, RenderTargetUsage usage, bool shared)
:base (graphicsDevice, width, height, mipMap, preferredFormat, SurfaceType.RenderTarget, shared)
{
DepthStencilFormat = preferredDepthFormat;
MultiSampleCount = preferredMultiSampleCount;
RenderTargetUsage = usage;
#if DIRECTX
// Create a view interface on the rendertarget to use on bind.
_renderTargetView = new RenderTargetView(graphicsDevice._d3dDevice, _texture);
#elif PSM
_frameBuffer = new FrameBuffer();
_frameBuffer.SetColorTarget(_texture2D,0);
#endif
// If we don't need a depth buffer then we're done.
if (preferredDepthFormat == DepthFormat.None)
return;
#if DIRECTX
// Setup the multisampling description.
var multisampleDesc = new SharpDX.DXGI.SampleDescription(1, 0);
if ( preferredMultiSampleCount > 1 )
{
multisampleDesc.Count = preferredMultiSampleCount;
multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
}
// Create a descriptor for the depth/stencil buffer.
// Allocate a 2-D surface as the depth/stencil buffer.
// Create a DepthStencil view on this surface to use on bind.
using (var depthBuffer = new SharpDX.Direct3D11.Texture2D(graphicsDevice._d3dDevice, new Texture2DDescription
{
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
ArraySize = 1,
MipLevels = 1,
Width = width,
Height = height,
SampleDescription = multisampleDesc,
BindFlags = BindFlags.DepthStencil,
}))
{
// Create the view for binding to the device.
_depthStencilView = new DepthStencilView(graphicsDevice._d3dDevice, depthBuffer,
new DepthStencilViewDescription()
{
Format = SharpDXHelper.ToFormat(preferredDepthFormat),
Dimension = DepthStencilViewDimension.Texture2D
});
}
#elif PSM
throw new NotImplementedException();
#elif OPENGL
#if GLES
GL.GenRenderbuffers(1, ref glDepthStencilBuffer);
#else
GL.GenRenderbuffers(1, out glDepthStencilBuffer);
#endif
GraphicsExtensions.CheckGLError();
GL.BindRenderbuffer(RenderbufferTarget.Renderbuffer, this.glDepthStencilBuffer);
GraphicsExtensions.CheckGLError();
var glDepthStencilFormat = GLDepthComponent16;
switch (preferredDepthFormat)
{
case DepthFormat.Depth16: glDepthStencilFormat = GLDepthComponent16; break;
case DepthFormat.Depth24: glDepthStencilFormat = GLDepthComponent24; break;
case DepthFormat.Depth24Stencil8: glDepthStencilFormat = GLDepth24Stencil8; break;
}
GL.RenderbufferStorage(GLRenderbuffer, glDepthStencilFormat, this.width, this.height);
GraphicsExtensions.CheckGLError();
#endif
}
protected override void Dispose(bool disposing)
{
if (!IsDisposed)
{
#if DIRECTX
if (disposing)
{
if (_renderTargetView != null)
{
_renderTargetView.Dispose();
_renderTargetView = null;
}
if (_depthStencilView != null)
{
_depthStencilView.Dispose();
_depthStencilView = null;
}
}
#elif PSM
_frameBuffer.Dispose();
#elif OPENGL
GraphicsDevice.AddDisposeAction(() =>
{
GL.DeleteRenderbuffers(1, ref this.glDepthStencilBuffer);
GraphicsExtensions.CheckGLError();
});
#endif
}
base.Dispose(disposing);
}
public void Run()
{
if (_userResized)
{
Utilities.Dispose(ref _backBuffer);
Utilities.Dispose(ref _renderView);
Utilities.Dispose(ref _depthBuffer);
Utilities.Dispose(ref _depthView);
_swapChain.ResizeBuffers(_swapChainDescription.BufferCount, _form.ClientSize.Width, _form.ClientSize.Height, Format.Unknown, SwapChainFlags.None);
_backBuffer = D3D11.Resource.FromSwapChain <D3D11.Texture2D>(_swapChain, 0);
_renderView = new D3D11.RenderTargetView(_device, _backBuffer);
_depthBuffer = new D3D11.Texture2D(_device, new D3D11.Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = _form.ClientSize.Width,
Height = _form.ClientSize.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = D3D11.ResourceUsage.Default,
BindFlags = D3D11.BindFlags.DepthStencil,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
OptionFlags = D3D11.ResourceOptionFlags.None
});
_depthView = new D3D11.DepthStencilView(_device, _depthBuffer);
_context.Rasterizer.SetViewport(new Viewport(0, 0, _form.ClientSize.Width, _form.ClientSize.Height, 0.0f, 1.0f));
_context.Rasterizer.State = new D3D11.RasterizerState(_device, new D3D11.RasterizerStateDescription
{
FillMode = D3D11.FillMode.Solid,
CullMode = D3D11.CullMode.Front,
IsFrontCounterClockwise = false,
});
_context.OutputMerger.SetTargets(_depthView, _renderView);
const float rads = (60.0f / 360.0f) * (float)Math.PI * 2.0f;
_proj = Matrix.PerspectiveFovLH(rads, _form.ClientSize.Width / (float)_form.ClientSize.Height, 0.1f, 1000.0f);
_userResized = false;
}
var time = _clock.ElapsedMilliseconds / 1000.0f;
var dt = time - lastTime;
if (key == Keys.W)
{
camera.goForward(dt);
}
if (key == Keys.S)
{
camera.goBack(dt);
}
lastTime = time;
var point = new System.Drawing.Point(_form.Location.X + (_form.Size.Width / 2), _form.Location.Y + (_form.Size.Height / 2));
//Cursor.Position = point;
var modelMatrix = Matrix.RotationX(time) * Matrix.RotationY(time) * Matrix.RotationZ(time) * Matrix.Translation(_primordialObject.Position);
var worldViewProj = modelMatrix * camera.ViewProjectionMatrix;
modelMatrix.Transpose();
worldViewProj.Transpose();
var modelMatrixArray = modelMatrix.ToArray();
var MVPMatrix = worldViewProj.ToArray();
var modelInverse = modelMatrix;
modelInverse.Invert();
//modelInverse.Transpose();
//_primordialObject.Position = new Vector3((float)Math.Cos(time * 2), (float)Math.Sin(time*2), (float)Math.Sin(time * 2)* (float)Math.Cos(time * 2));
var renderTime = _clock.ElapsedMilliseconds;
_context.ClearDepthStencilView(_depthView, D3D11.DepthStencilClearFlags.Depth, 1.0f, 0);
_context.ClearRenderTargetView(_renderView, SharpDX.Color.Black);
_context.UpdateSubresource(MVPMatrix, _contantBuffer);
_context.UpdateSubresource(modelMatrixArray, _contantBuffer2);
_context.UpdateSubresource(modelInverse.ToArray(), _contantBuffer3);
var frameTime = _clock.ElapsedMilliseconds;
_context.Draw(_primordialObject.VertexData.Length, 0);
_swapChain.Present(0, PresentFlags.None);
if ((_clock.ElapsedMilliseconds - frameTime) > 15)
{
File.AppendAllText(fileTitle + ".txt", (_clock.ElapsedMilliseconds - frameTime).ToString() + "\n");
count++;
}
// if(count > 1)
//_form.Close();
if (_clock.Elapsed.TotalSeconds > 105)
{
// _form.Close();
}
}
private void ClearDepth(D3D11.DepthStencilView depthStencilView)
{
deviceResources.DeviceContext.ClearDepthStencilView(depthStencilView, D3D11.DepthStencilClearFlags.Depth, 1.0f, 0);
//deviceResources.DeviceContext.ClearDepthStencilView(depthStencilView, D3D11.DepthStencilClearFlags.Stencil, 1.0f, 0);
}
// Constructor - Must be initialized before the assets.
public Pipeline(Program program, String title, int initialWidth, int initialHeight)
{
// Set program reference.
this.program = program;
// Set dimentions.
this.width = initialWidth;
this.height = initialHeight;
// Create Windows form.
form = program.ToDispose(new RenderForm(title));
form.ClientSize = new System.Drawing.Size(width, height);
// Create SwapChain description
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new ModeDescription(width, height,
new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput,
};
// Create Device, SwapChain and DeviceContext.
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, desc, out device, out swapChain);
program.ToDispose(device);
program.ToDispose(swapChain);
context = program.ToDispose(device.ImmediateContext);
// Create the RenderView.
var backBuffer = program.ToDispose(Texture2D.FromSwapChain<Texture2D>(swapChain, 0));
renderView = program.ToDispose(new RenderTargetView(device, backBuffer));
// Create the DepthStencilView.
var depthBuffer = program.ToDispose(new Texture2D(device, new Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = form.ClientSize.Width,
Height = form.ClientSize.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
}));
depthView = program.ToDispose(new DepthStencilView(device, depthBuffer));
// Create the texture sampler.
sampler = program.ToDispose(new SamplerState(device, new SamplerStateDescription()
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = Colors.Black,
ComparisonFunction = Comparison.Never,
MaximumAnisotropy = 16,
MipLodBias = 0,
MinimumLod = 0,
MaximumLod = 16,
}));
context.PixelShader.SetSampler(0, sampler);
// Initialise the transformation matrices.
world = Matrix.Identity;
view = Matrix.Identity;
proj = Matrix.Identity;
worldViewProj = Matrix.Identity;
// Create the Constant Buffer.
constantBuffer = program.ToDispose(new Buffer(device, Utilities.SizeOf<Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0));
context.VertexShader.SetConstantBuffer(0, constantBuffer);
// Set the view port.
context.Rasterizer.SetViewports(new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height, 0.0f, 1.0f));
// Set the output target.
context.OutputMerger.SetTargets(depthView, renderView);
}
internal override void Cleanup()
{
base.Cleanup();
DSV = null;
RTV = null;
}
public void Initialize(int width, int height, List <PrimordialObject> primordialObject, string fileTitle)
{
this.fileTitle = fileTitle;
_clock = new Stopwatch();
_clock.Start();
_form = new RenderForm("PrimordialEngine");
_form.FormBorderStyle = FormBorderStyle.None;
_form.MouseMove += mouseMove;
var userControl = new UserControl();
_form.Controls.Add(userControl);
_form.ClientSize = new System.Drawing.Size(width, height);
camera = new Camera(60, width / (float)height);
userControl.Size = new Size(0, 0);
userControl.KeyDown += keyDown;
userControl.MouseMove += mouseMove;
userControl.KeyUp += KeyUpEvent;
var point = new System.Drawing.Point(_form.Location.X + (_form.Size.Width / 2), _form.Location.Y + (_form.Size.Height / 2));
//Cursor.Position = point;
_primordialObject = primordialObject[0];
_swapChainDescription = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription = new ModeDescription(_form.ClientSize.Width, _form.ClientSize.Height, new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = _form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
D3D11.Device.CreateWithSwapChain(DriverType.Hardware, D3D11.DeviceCreationFlags.None, _swapChainDescription, out _device, out _swapChain);
_context = _device.ImmediateContext;
_factory = _swapChain.GetParent <Factory>();
_factory.MakeWindowAssociation(_form.Handle, WindowAssociationFlags.IgnoreAll);
var shaderName = "DirectXRenderer\\MiniCube.hlsl";
//var shaderName = @"DirectXRenderer\MiniCubeNoFrag.hlsl";
//var shaderName = "DirectXRenderer\\MiniCubeNoShader.hlsl";
//for(int i = 0; i < 100; i++) {
//var shaderTime = _clock.ElapsedMilliseconds;
_vertexShaderByteCode = ShaderBytecode.CompileFromFile(shaderName, "VS", "vs_4_0");
_vertexShader = new D3D11.VertexShader(_device, _vertexShaderByteCode);
_pixelShaderByteCode = ShaderBytecode.CompileFromFile(shaderName, "PS", "ps_4_0");
_pixelShader = new D3D11.PixelShader(_device, _pixelShaderByteCode);
// File.AppendAllText(fileTitle + "Shader.txt", (_clock.ElapsedMilliseconds - shaderTime).ToString() + "\n");
// _vertexShaderByteCode?.Dispose();
//_vertexShader?.Dispose();
// _pixelShaderByteCode?.Dispose();
// _pixelShader?.Dispose();
//}
_shaderSignature = ShaderSignature.GetInputSignature(_vertexShaderByteCode);
_inputLayout = new D3D11.InputLayout(_device, _shaderSignature, new[]
{
new D3D11.InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new D3D11.InputElement("COLOR", 0, Format.R32G32B32A32_Float, 16, 0),
new D3D11.InputElement("NORMAL", 0, Format.R32G32B32A32_Float, 32, 0)
});
// for(int i = 0; i<100; i++) {
// var sendDataTime = _clock.ElapsedMilliseconds;
_verticesBuffer = D3D11.Buffer.Create(_device, D3D11.BindFlags.VertexBuffer, _primordialObject.VertexData);
// File.AppendAllText(fileTitle + "Data.txt", (_clock.ElapsedMilliseconds - sendDataTime).ToString() + "\n");
// _verticesBuffer?.Dispose();
// _verticesBuffer = null;
// }
_contantBuffer = new D3D11.Buffer(_device, Utilities.SizeOf <Matrix>(), D3D11.ResourceUsage.Default, D3D11.BindFlags.ConstantBuffer, D3D11.CpuAccessFlags.None, D3D11.ResourceOptionFlags.None, 0);
_contantBuffer2 = new D3D11.Buffer(_device, Utilities.SizeOf <Matrix>(), D3D11.ResourceUsage.Default, D3D11.BindFlags.ConstantBuffer, D3D11.CpuAccessFlags.None, D3D11.ResourceOptionFlags.None, 0);
_contantBuffer3 = new D3D11.Buffer(_device, Utilities.SizeOf <Matrix>(), D3D11.ResourceUsage.Default, D3D11.BindFlags.ConstantBuffer, D3D11.CpuAccessFlags.None, D3D11.ResourceOptionFlags.None, 0);
_context.InputAssembler.InputLayout = _inputLayout;
_context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
_context.InputAssembler.SetVertexBuffers(0, new D3D11.VertexBufferBinding(_verticesBuffer, Utilities.SizeOf <VertexDataStruct>(), 0));
_context.VertexShader.SetConstantBuffer(0, _contantBuffer);
_context.VertexShader.SetConstantBuffer(1, _contantBuffer2);
_context.VertexShader.SetConstantBuffer(2, _contantBuffer3);
_context.VertexShader.Set(_vertexShader);
_context.PixelShader.Set(_pixelShader);
_view = Matrix.LookAtLH(new Vector3(0, 0, 0), new Vector3(0, 0, -5), Vector3.UnitY);
_backBuffer = null;
_renderView = null;
_depthBuffer = null;
_depthView = null;
_form.UserResized += (sender, args) => _userResized = true;
_form.KeyUp += (sender, args) =>
{
if (args.KeyCode == Keys.F5)
{
_swapChain.SetFullscreenState(true, null);
}
else if (args.KeyCode == Keys.F4)
{
_swapChain.SetFullscreenState(false, null);
}
//else if (args.KeyCode == Keys.Escape)
// _form.Close();
};
}
internal MyDepthStencil(int width, int height,
int sampleCount, int sampleQuality)
{
m_resolution = new Vector2I(width, height);
m_samples = new Vector2I(sampleCount, sampleQuality);
m_depthSubresource = new MyDepthView(this);
m_stencilSubresource = new MyStencilView(this);
Texture2DDescription desc = new Texture2DDescription();
desc.Width = width;
desc.Height = height;
desc.Format = Depth32F ? Format.R32G8X24_Typeless : Format.R24G8_Typeless;
desc.ArraySize = 1;
desc.MipLevels = 1;
desc.BindFlags = BindFlags.DepthStencil | BindFlags.ShaderResource;
desc.Usage = ResourceUsage.Default;
desc.CpuAccessFlags = 0;
desc.SampleDescription.Count = sampleCount;
desc.SampleDescription.Quality = sampleQuality;
desc.OptionFlags = 0;
m_resource = new Texture2D(MyRender11.Device, desc);
DepthStencilViewDescription dsvDesc = new DepthStencilViewDescription();
dsvDesc.Format = Depth32F ? Format.D32_Float_S8X24_UInt : Format.D24_UNorm_S8_UInt;
if (sampleCount == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Flags = DepthStencilViewFlags.None;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
dsvDesc.Flags = DepthStencilViewFlags.None;
}
m_DSV = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc);
if (sampleCount == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyDepth;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyDepth;
}
m_DSV_roDepth = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc);
if (sampleCount == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil;
}
m_DSV_roStencil = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc);
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil | DepthStencilViewFlags.ReadOnlyDepth;
if (sampleCount == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
}
m_DSV_ro = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc);
ShaderResourceViewDescription srvDesc = new ShaderResourceViewDescription();
srvDesc.Format = Depth32F ? Format.R32_Float_X8X24_Typeless : Format.R24_UNorm_X8_Typeless;
if (sampleCount == 1)
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
}
else
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2DMultisampled;
}
m_SRV_depth = new ShaderResourceView(MyRender11.Device, m_resource, srvDesc);
srvDesc.Format = Depth32F ? Format.X32_Typeless_G8X24_UInt : Format.X24_Typeless_G8_UInt;
if (sampleCount == 1)
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
}
else
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2DMultisampled;
}
m_SRV_stencil = new ShaderResourceView(MyRender11.Device, m_resource, srvDesc);
}
/// <summary>
/// Creates render target
/// </summary>
/// <param name="rs"></param>
/// <param name="width"></param>
/// <param name="height"></param>
/// <param name="format"></param>
public DepthStencilCube ( GraphicsDevice device, DepthFormat format, int size, int samples, string debugName = "" ) : base ( device )
{
bool msaa = samples > 1;
CheckSamplesCount( samples );
SampleCount = samples;
Format = format;
SampleCount = samples;
Width = size;
Height = size;
Depth = 1;
var texDesc = new Texture2DDescription();
texDesc.Width = Width;
texDesc.Height = Height;
texDesc.ArraySize = 6;
texDesc.BindFlags = BindFlags.RenderTarget | BindFlags.ShaderResource;
texDesc.CpuAccessFlags = CpuAccessFlags.None;
texDesc.Format = Converter.ConvertToTex( format );
texDesc.MipLevels = 1;
texDesc.OptionFlags = ResourceOptionFlags.TextureCube;
texDesc.SampleDescription = new DXGI.SampleDescription(samples, 0);
texDesc.Usage = ResourceUsage.Default;
texCube = new D3D.Texture2D( device.Device, texDesc );
var srvDesc = new ShaderResourceViewDescription();
srvDesc.Dimension = samples > 1 ? ShaderResourceViewDimension.Texture2DMultisampled : ShaderResourceViewDimension.Texture2D;
srvDesc.Format = Converter.ConvertToSRV( format );
srvDesc.Texture2D.MostDetailedMip = 0;
srvDesc.Texture2D.MipLevels = 1;
SRV = new ShaderResourceView( device.Device, texCube );
//
// Create surfaces :
//
surfaces = new DepthStencilSurface[ 6 ];
for ( int face=0; face<6; face++) {
var rtvDesc = new DepthStencilViewDescription();
rtvDesc.Texture2DArray.MipSlice = 0;
rtvDesc.Texture2DArray.FirstArraySlice = face;
rtvDesc.Texture2DArray.ArraySize = 1;
rtvDesc.Dimension = msaa ? DepthStencilViewDimension.Texture2DMultisampledArray : DepthStencilViewDimension.Texture2DArray;
rtvDesc.Format = Converter.ConvertToDSV( format );
var dsv = new DepthStencilView( device.Device, texCube, rtvDesc );
int subResId = Resource.CalculateSubResourceIndex( 0, face, 1 );
surfaces[face] = new DepthStencilSurface( dsv, format, Width, Height, SampleCount );
}
}
public void Render(DeviceContext deviceContext, ShaderResourceView depthImageTextureRV, ShaderResourceView colorImageTextureRV, SharpDX.Direct3D11.Buffer vertexBuffer, RenderTargetView renderTargetView, DepthStencilView depthStencilView, Viewport viewport)
{
//bilateralFilter.Render(deviceContext, depthImageTextureRV, filteredRenderTargetView2);
//bilateralFilter.Render(deviceContext, filteredDepthImageSRV2, filteredRenderTargetView);
//bilateralFilter.Render(deviceContext, filteredDepthImageSRV, filteredRenderTargetView2);
//bilateralFilter.Render(deviceContext, filteredDepthImageSRV2, filteredRenderTargetView);
deviceContext.InputAssembler.InputLayout = vertexInputLayout;
deviceContext.InputAssembler.PrimitiveTopology = SharpDX.Direct3D.PrimitiveTopology.TriangleList;
deviceContext.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertexBuffer, VertexPosition.SizeInBytes, 0)); // bytes per vertex
deviceContext.Rasterizer.State = rasterizerState;
deviceContext.Rasterizer.SetViewport(viewport);
deviceContext.VertexShader.Set(depthAndColorVS);
deviceContext.VertexShader.SetShaderResource(0, depthImageTextureRV);
//deviceContext.VertexShader.SetShaderResource(0, depthAndMaskRV);
//deviceContext.VertexShader.SetShaderResource(0, filteredDepthImageSRV);
deviceContext.VertexShader.SetConstantBuffer(0, constantBuffer);
deviceContext.GeometryShader.Set(depthAndColorGS);
deviceContext.PixelShader.Set(depthAndColorPS);
deviceContext.PixelShader.SetShaderResource(0, colorImageTextureRV);
deviceContext.PixelShader.SetSampler(0, colorSamplerState);
deviceContext.OutputMerger.SetTargets(depthStencilView, renderTargetView);
deviceContext.OutputMerger.DepthStencilState = depthStencilState;
deviceContext.Draw((Kinect2Calibration.depthImageWidth - 1) * (Kinect2Calibration.depthImageHeight - 1) * 6, 0);
}
/// <summary>
/// Applies the given size.
/// </summary>
/// <param name="renderState">The render state used for creating all resources.</param>
public void ApplySize(RenderState renderState)
{
ViewInformation viewInfo = renderState.ViewInformation;
GraphicsViewConfiguration viewConfig = viewInfo.ViewConfiguration;
// Get current view size and antialiasing settings
Size2 currentViewSize = viewInfo.CurrentViewSize;
bool currentAntialiasingEnabled = viewConfig.AntialiasingEnabled;
AntialiasingQualityLevel currentAntialiasingQuality = viewConfig.AntialiasingQuality;
if ((m_width != currentViewSize.Width) ||
(m_heigth != currentViewSize.Height) ||
(m_antialiasingEnabled != currentAntialiasingEnabled) ||
(m_antialiasingQuality != currentAntialiasingQuality))
{
// Dispose color-buffer resources
GraphicsHelper.SafeDispose(ref m_colorBuffer);
GraphicsHelper.SafeDispose(ref m_colorBufferRenderTargetView);
GraphicsHelper.SafeDispose(ref m_colorBufferShaderResourceView);
if (m_shaderResourceCreated)
{
GraphicsHelper.SafeDispose(ref m_colorBufferShaderResource);
}
// Dispose depth-buffer resources
GraphicsHelper.SafeDispose(ref m_depthBufferView);
GraphicsHelper.SafeDispose(ref m_depthBuffer);
// Dispose object-id buffer
GraphicsHelper.SafeDispose(ref m_objectIDBufferRenderTargetView);
GraphicsHelper.SafeDispose(ref m_objectIDBuffer);
// Dispose normal-depth resources
GraphicsHelper.SafeDispose(ref m_normalDepthBuffer);
GraphicsHelper.SafeDispose(ref m_normalDepthBufferRenderTargetView);
GraphicsHelper.SafeDispose(ref m_normalDepthBufferShaderResourceView);
if (m_shaderResourceCreated)
{
GraphicsHelper.SafeDispose(ref m_normalDepthBufferShaderResource);
}
// Create color-buffer resources
if (m_creationMode.HasFlag(RenderTargetCreationMode.Color))
{
m_colorBuffer = GraphicsHelper.CreateRenderTargetTexture(
renderState.Device, currentViewSize.Width, currentViewSize.Height, renderState.ViewInformation.ViewConfiguration);
m_colorBufferShaderResource = m_colorBuffer;
if (renderState.ViewInformation.ViewConfiguration.AntialiasingEnabled)
{
m_colorBufferShaderResource = GraphicsHelper.CreateTexture(renderState.Device, currentViewSize.Width, currentViewSize.Height);
m_shaderResourceCreated = true;
}
else
{
m_shaderResourceCreated = false;
}
m_colorBufferRenderTargetView = new D3D11.RenderTargetView(renderState.Device.DeviceD3D11_1, m_colorBuffer);
m_colorBufferShaderResourceView = new D3D11.ShaderResourceView(renderState.Device.DeviceD3D11_1, m_colorBufferShaderResource);
}
// Create depth-buffer resources
if (m_creationMode.HasFlag(RenderTargetCreationMode.Depth))
{
m_depthBuffer = GraphicsHelper.CreateDepthBufferTexture(
renderState.Device, currentViewSize.Width, currentViewSize.Height, renderState.ViewInformation.ViewConfiguration);
m_depthBufferView = GraphicsHelper.CreateDepthBufferView(renderState.Device, m_depthBuffer);
}
// Create object-id resources
if (m_creationMode.HasFlag(RenderTargetCreationMode.ObjectID))
{
m_objectIDBuffer = GraphicsHelper.CreateRenderTargetTextureObjectIDs(
renderState.Device, currentViewSize.Width, currentViewSize.Height, renderState.ViewInformation.ViewConfiguration);
m_objectIDBufferRenderTargetView = new D3D11.RenderTargetView(renderState.Device.DeviceD3D11_1, m_objectIDBuffer);
}
// Create normal-depth buffer resources
if (m_creationMode.HasFlag(RenderTargetCreationMode.NormalDepth))
{
m_normalDepthBuffer = GraphicsHelper.CreateRenderTargetTextureNormalDepth(
renderState.Device, currentViewSize.Width, currentViewSize.Height, renderState.ViewInformation.ViewConfiguration);
m_normalDepthBufferShaderResource = m_normalDepthBuffer;
if (m_shaderResourceCreated)
{
m_normalDepthBufferShaderResource = GraphicsHelper.CreateTexture(
renderState.Device, currentViewSize.Width, currentViewSize.Height, GraphicsHelper.DEFAULT_TEXTURE_FORMAT_NORMAL_DEPTH);
}
m_normalDepthBufferRenderTargetView = new D3D11.RenderTargetView(renderState.Device.DeviceD3D11_1, m_normalDepthBuffer);
m_normalDepthBufferShaderResourceView = new D3D11.ShaderResourceView(renderState.Device.DeviceD3D11_1, m_normalDepthBufferShaderResource);
}
// Remember values
m_width = currentViewSize.Width;
m_heigth = currentViewSize.Height;
m_antialiasingEnabled = currentAntialiasingEnabled;
m_antialiasingQuality = currentAntialiasingQuality;
m_viewportF = renderState.Viewport;
}
}
private void SwapChainPanel_OnLoaded(object sender, RoutedEventArgs e)
{
using (var defDevice = new D3D.Device(DriverType.Hardware, D3D.DeviceCreationFlags.Debug))
{
_device = defDevice.QueryInterface <D3D.Device3>();
}
_context = _device.ImmediateContext3;
var pixelScale = DisplayInformation.GetForCurrentView().LogicalDpi / 96.0f;
var swapChainDesc = new DXGI.SwapChainDescription1()
{
AlphaMode = DXGI.AlphaMode.Premultiplied,
BufferCount = 2,
Flags = DXGI.SwapChainFlags.None,
Format = DXGI.Format.B8G8R8A8_UNorm,
Width = (int)(panel.RenderSize.Width * pixelScale),
Height = (int)(panel.RenderSize.Height * pixelScale),
SampleDescription = new DXGI.SampleDescription(1, 0),
Scaling = DXGI.Scaling.Stretch,
Stereo = false,
SwapEffect = DXGI.SwapEffect.FlipSequential,
Usage = DXGI.Usage.BackBuffer | DXGI.Usage.RenderTargetOutput
};
using (var dxgiDevice = _device.QueryInterface <DXGI.Device3>())
{
var factory = dxgiDevice.Adapter.GetParent <DXGI.Factory4>();
using (var tmpSwapChain = new DXGI.SwapChain1(factory, _device, ref swapChainDesc))
{
_swapChain = tmpSwapChain.QueryInterface <DXGI.SwapChain3>();
}
}
using (var nativeObject = ComObject.As <DXGI.ISwapChainPanelNative>(panel))
{
nativeObject.SwapChain = _swapChain;
}
using (var depthBuffer = new D3D.Texture2D(_device, new D3D.Texture2DDescription()
{
Format = DXGI.Format.D24_UNorm_S8_UInt,
ArraySize = 1,
MipLevels = 1,
Width = swapChainDesc.Width,
Height = swapChainDesc.Height,
SampleDescription = new DXGI.SampleDescription(1, 0),
BindFlags = D3D.BindFlags.DepthStencil,
}))
{
_depthStencilView = new D3D.DepthStencilView(_device, depthBuffer, new D3D.DepthStencilViewDescription()
{
Dimension = D3D.DepthStencilViewDimension.Texture2D
});
}
_backBuffer = D3D.Resource.FromSwapChain <D3D.Texture2D>(_swapChain, 0);
_renderView = new D3D.RenderTargetView1(_device, _backBuffer);
var viewport = new ViewportF(0, 0, (float)panel.RenderSize.Width, (float)panel.RenderSize.Height, 0.0f, 1.0f);
_context.Rasterizer.SetViewport(viewport);
ShaderBytecode shaderBytecode;
using (shaderBytecode = ShaderBytecode.CompileFromFile("shaders.hlsl", "vs", "vs_5_0", ShaderFlags.Debug))
{
_vertexShader = new D3D.VertexShader(_device, shaderBytecode);
}
using (var byteCode = ShaderBytecode.CompileFromFile(@"shaders.hlsl", "ps", "ps_5_0", ShaderFlags.Debug))
{
_pixelShader = new D3D.PixelShader(_device, byteCode);
}
D3D.InputElement[] inputElements =
{
new D3D.InputElement("POSITION", 0, DXGI.Format.R32G32B32A32_Float, 0, 0),
};
_inputLayout = new D3D.InputLayout(_device, shaderBytecode, inputElements);
_vertices = new[]
{
new Vector4(-0.5f, 0.0f, 0.5f, 1.0f),
new Vector4(0.0f, 0.5f, 0.5f, 1.0f),
new Vector4(0.5f, 0.0f, 0.5f, 1.0f),
};
_vertexBuffer = D3D.Buffer.Create(_device, D3D.BindFlags.VertexBuffer, _vertices);
_vertexBinding = new D3D.VertexBufferBinding(_vertexBuffer, Utilities.SizeOf <Vector4>(), 0);
_constantBuffer = new SharpDX.Direct3D11.Buffer(
_device,
Utilities.SizeOf <SharpDX.Matrix>(),
D3D.ResourceUsage.Default,
D3D.BindFlags.ConstantBuffer,
D3D.CpuAccessFlags.None,
D3D.ResourceOptionFlags.None,
0);
_timer = new Stopwatch();
_timer.Start();
CompositionTarget.Rendering += CompositionTarget_Rendering;
}
public SwapChainRenderTarget( GraphicsDevice graphicsDevice,
IntPtr windowHandle,
int width,
int height,
bool mipMap,
SurfaceFormat surfaceFormat,
DepthFormat depthFormat,
int preferredMultiSampleCount,
RenderTargetUsage usage,
PresentInterval presentInterval)
: base(
graphicsDevice,
width,
height,
mipMap,
surfaceFormat,
depthFormat,
preferredMultiSampleCount,
usage,
SurfaceType.SwapChainRenderTarget)
{
var dxgiFormat = surfaceFormat == SurfaceFormat.Color
? SharpDX.DXGI.Format.B8G8R8A8_UNorm
: SharpDXHelper.ToFormat(surfaceFormat);
var multisampleDesc = new SampleDescription(1, 0);
if (preferredMultiSampleCount > 1)
{
multisampleDesc.Count = preferredMultiSampleCount;
multisampleDesc.Quality = (int)StandardMultisampleQualityLevels.StandardMultisamplePattern;
}
var desc = new SwapChainDescription()
{
ModeDescription =
{
Format = dxgiFormat,
Scaling = DisplayModeScaling.Stretched,
Width = width,
Height = height,
},
OutputHandle = windowHandle,
SampleDescription = multisampleDesc,
Usage = Usage.RenderTargetOutput,
BufferCount = 2,
SwapEffect = SharpDXHelper.ToSwapEffect(presentInterval),
IsWindowed = true,
};
PresentInterval = presentInterval;
// Once the desired swap chain description is configured, it must
// be created on the same adapter as our D3D Device
var d3dDevice = graphicsDevice._d3dDevice;
// First, retrieve the underlying DXGI Device from the D3D Device.
// Creates the swap chain
using (var dxgiDevice = d3dDevice.QueryInterface<Device1>())
using (var dxgiAdapter = dxgiDevice.Adapter)
using (var dxgiFactory = dxgiAdapter.GetParent<Factory1>())
{
_swapChain = new SwapChain(dxgiFactory, dxgiDevice, desc);
}
// Obtain the backbuffer for this window which will be the final 3D rendertarget.
var backBuffer = SharpDX.Direct3D11.Resource.FromSwapChain<SharpDX.Direct3D11.Texture2D>(_swapChain, 0);
// Create a view interface on the rendertarget to use on bind.
_renderTargetViews = new[] { new RenderTargetView(d3dDevice, backBuffer) };
// Get the rendertarget dimensions for later.
var backBufferDesc = backBuffer.Description;
var targetSize = new Point(backBufferDesc.Width, backBufferDesc.Height);
_texture = backBuffer;
// Create the depth buffer if we need it.
if (depthFormat != DepthFormat.None)
{
dxgiFormat = SharpDXHelper.ToFormat(depthFormat);
// Allocate a 2-D surface as the depth/stencil buffer.
using (
var depthBuffer = new SharpDX.Direct3D11.Texture2D(d3dDevice,
new Texture2DDescription()
{
Format = dxgiFormat,
ArraySize = 1,
MipLevels = 1,
Width = targetSize.X,
Height = targetSize.Y,
SampleDescription = multisampleDesc,
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
}))
// Create a DepthStencil view on this surface to use on bind.
_depthStencilView = new DepthStencilView(d3dDevice, depthBuffer);
}
}
internal override void Release()
{
if (m_SRV_depth != null)
{
m_SRV_depth.Dispose();
m_SRV_depth = null;
}
if (m_SRV_stencil != null)
{
m_SRV_stencil.Dispose();
m_SRV_stencil = null;
}
if (m_DSV != null)
{
m_DSV.Dispose();
m_DSV = null;
}
if (m_DSV_roDepth != null)
{
m_DSV_roDepth.Dispose();
m_DSV_roDepth = null;
}
if (m_DSV_roStencil != null)
{
m_DSV_roStencil.Dispose();
m_DSV_roStencil = null;
}
if (m_DSV_ro != null)
{
m_DSV_ro.Dispose();
m_DSV_ro = null;
}
base.Release();
}
private void InitializeDeviceResources(DXGI.SwapChain swapChain)
{
backbufferTexture = swapChain.GetBackBuffer <D3D11.Texture2D>(0);
backbufferRTV = new D3D11.RenderTargetView(device, backbufferTexture);
width = backbufferTexture.Description.Width;
height = backbufferTexture.Description.Height;
D3D11.Texture2DDescription sceneTextureDesc = new D3D11.Texture2DDescription
{
CpuAccessFlags = D3D11.CpuAccessFlags.None,
BindFlags = D3D11.BindFlags.RenderTarget | D3D11.BindFlags.ShaderResource,
Format = DXGI.Format.R8G8B8A8_UNorm,
Width = width,
Height = height,
OptionFlags = D3D11.ResourceOptionFlags.None,
MipLevels = 1,
ArraySize = 1,
SampleDescription = { Count = 1, Quality = 0 },
Usage = D3D11.ResourceUsage.Default
};
sceneTexture = new D3D11.Texture2D(device, sceneTextureDesc);
sceneRTV = new D3D11.RenderTargetView(device, sceneTexture);
sceneSRV = new D3D11.ShaderResourceView(device, sceneTexture);
var depthBufferDesc = new D3D11.Texture2DDescription()
{
Width = width,
Height = height,
MipLevels = 1,
ArraySize = 1,
Format = DXGI.Format.R32_Typeless,
SampleDescription = { Count = 1, Quality = 0 },
Usage = D3D11.ResourceUsage.Default,
BindFlags = D3D11.BindFlags.DepthStencil | D3D11.BindFlags.ShaderResource,
CpuAccessFlags = D3D11.CpuAccessFlags.None,
OptionFlags = D3D11.ResourceOptionFlags.None
};
using (var depthStencilBufferTexture = new D3D11.Texture2D(device, depthBufferDesc))
{
var depthStencilViewDesc = new D3D11.DepthStencilViewDescription()
{
Format = DXGI.Format.D32_Float,
Dimension = D3D11.DepthStencilViewDimension.Texture2D,
Texture2D = { MipSlice = 0 }
};
depthDSV = new D3D11.DepthStencilView(device, depthStencilBufferTexture, depthStencilViewDesc);
var shaderResourceViewDesc = new D3D11.ShaderResourceViewDescription()
{
Format = DXGI.Format.R32_Float,
Dimension = SharpDX.Direct3D.ShaderResourceViewDimension.Texture2D,
Texture2D = { MipLevels = 1, MostDetailedMip = 0 }
};
depthSRV = new D3D11.ShaderResourceView(device, depthStencilBufferTexture, shaderResourceViewDesc);
}
var depthStencilDesc = new D3D11.DepthStencilStateDescription()
{
IsDepthEnabled = true,
DepthWriteMask = D3D11.DepthWriteMask.All,
DepthComparison = D3D11.Comparison.Less,
IsStencilEnabled = false,
StencilReadMask = 0xFF,
StencilWriteMask = 0xFF,
FrontFace = new D3D11.DepthStencilOperationDescription()
{
FailOperation = D3D11.StencilOperation.Keep,
DepthFailOperation = D3D11.StencilOperation.Keep,
PassOperation = D3D11.StencilOperation.Keep,
Comparison = D3D11.Comparison.Always
},
BackFace = new D3D11.DepthStencilOperationDescription()
{
FailOperation = D3D11.StencilOperation.Keep,
DepthFailOperation = D3D11.StencilOperation.Keep,
PassOperation = D3D11.StencilOperation.Keep,
Comparison = D3D11.Comparison.Always
}
};
depthStencilState = new D3D11.DepthStencilState(device, depthStencilDesc);
var rasterDesc = new D3D11.RasterizerStateDescription()
{
IsAntialiasedLineEnabled = false,
CullMode = D3D11.CullMode.Back,
DepthBias = 0,
DepthBiasClamp = 0.0f,
IsDepthClipEnabled = true,
FillMode = D3D11.FillMode.Solid,
IsFrontCounterClockwise = false,
IsMultisampleEnabled = false,
IsScissorEnabled = false,
SlopeScaledDepthBias = 0.0f
};
rasterizerState = new D3D11.RasterizerState(device, rasterDesc);
}
// ReSharper disable once FunctionComplexityOverflow
public void Resize(int width, int height, bool bgra)
{
if (Texture != null)
Texture.Dispose();
if (Native != null)
Native.Dispose();
var texDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.RenderTarget,
CpuAccessFlags = CpuAccessFlags.None,
Format = bgra ? SharpDX.DXGI.Format.B8G8R8A8_UNorm : SharpDX.DXGI.Format.R8G8B8A8_UNorm,
Height = height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = mContext.Multisampling,
Usage = ResourceUsage.Default,
Width = width
};
Texture = new Texture2D(mContext.Device, texDesc);
var rtvd = new RenderTargetViewDescription
{
Dimension = RenderTargetViewDimension.Texture2DMultisampled,
Format = texDesc.Format,
Texture2DMS = new RenderTargetViewDescription.Texture2DMultisampledResource()
};
Native = new RenderTargetView(mContext.Device, Texture, rtvd);
if (mDepthTexture != null)
mDepthTexture.Dispose();
if (mDepthView != null)
mDepthView.Dispose();
texDesc = new Texture2DDescription
{
ArraySize = 1,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt,
Height = height,
MipLevels = 1,
OptionFlags = ResourceOptionFlags.None,
SampleDescription = mContext.Multisampling,
Usage = ResourceUsage.Default,
Width = width
};
mDepthTexture = new Texture2D(mContext.Device, texDesc);
var dsvd = new DepthStencilViewDescription
{
Dimension = DepthStencilViewDimension.Texture2DMultisampled,
Flags = DepthStencilViewFlags.None,
Format = SharpDX.DXGI.Format.D24_UNorm_S8_UInt,
Texture2DMS = new DepthStencilViewDescription.Texture2DMultisampledResource()
};
mDepthView = new DepthStencilView(mContext.Device, mDepthTexture, dsvd);
}
internal override void Cleanup()
{
base.Cleanup();
DSV = null;
DefaultRasterizer = null;
}
public void OnDeviceInit()
{
Texture2DDescription desc = new Texture2DDescription();
desc.Width = Size.X;
desc.Height = Size.Y;
desc.Format = m_resourceFormat;
desc.ArraySize = 1;
desc.MipLevels = 1;
desc.BindFlags = BindFlags.ShaderResource | BindFlags.DepthStencil;
desc.Usage = ResourceUsage.Default;
desc.CpuAccessFlags = 0;
desc.SampleDescription.Count = m_samplesCount;
desc.SampleDescription.Quality = m_samplesQuality;
desc.OptionFlags = 0;
m_resource = new Texture2D(MyRender11.Device, desc);
m_resource.DebugName = Name;
DepthStencilViewDescription dsvDesc = new DepthStencilViewDescription();
dsvDesc.Format = m_dsvFormat;
if (m_samplesCount == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Flags = DepthStencilViewFlags.None;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
dsvDesc.Flags = DepthStencilViewFlags.None;
}
m_dsv = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc);
if (m_samplesCount == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyDepth;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyDepth;
}
m_dsv_roDepth = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc);
if (m_samplesCount == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil;
}
m_dsv_roStencil = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc);
dsvDesc.Flags = DepthStencilViewFlags.ReadOnlyStencil | DepthStencilViewFlags.ReadOnlyDepth;
if (m_samplesCount == 1)
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2D;
dsvDesc.Texture2D.MipSlice = 0;
}
else
{
dsvDesc.Dimension = DepthStencilViewDimension.Texture2DMultisampled;
}
m_dsv_ro = new DepthStencilView(MyRender11.Device, m_resource, dsvDesc);
ShaderResourceViewDescription srvDesc = new ShaderResourceViewDescription();
srvDesc.Format = m_srvDepthFormat;
if (m_samplesCount == 1)
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
}
else
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2DMultisampled;
}
m_srvDepth.OnDeviceInit(this, srvDesc);
srvDesc.Format = m_srvStencilFormat;
if (m_samplesCount == 1)
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2D;
srvDesc.Texture2D.MipLevels = -1;
srvDesc.Texture2D.MostDetailedMip = 0;
}
else
{
srvDesc.Dimension = ShaderResourceViewDimension.Texture2DMultisampled;
}
m_srvStencil.OnDeviceInit(this, srvDesc);
}
void ResizeBuffers()
{
// Dispose all previous allocated resources
Utilities.Dispose(ref _backbufferView);
Utilities.Dispose(ref _zbufferView);
if (RenderViewSize.Width == 0 || RenderViewSize.Height == 0)
return;
// Resize the backbuffer
SwapChain.ResizeBuffers(1, RenderViewSize.Width, RenderViewSize.Height, Format.R8G8B8A8_UNorm, SwapChainFlags.AllowModeSwitch);
// Get the backbuffer from the swapchain
var _backBufferTexture = SwapChain.GetBackBuffer<Texture2D>(0);
_backBufferTexture.DebugName = "Lilium BackBuffer";
// Backbuffer
_backbufferView = new RenderTargetView(Device, _backBufferTexture);
_backbufferView.DebugName = "Lilium BackBuffer View";
_backBufferTexture.Dispose();
// Depth buffer
var _zbufferTexture = new Texture2D(Device, new Texture2DDescription()
{
Format = Format.D24_UNorm_S8_UInt,
ArraySize = 1,
MipLevels = 1,
Width = RenderViewSize.Width,
Height = RenderViewSize.Height,
SampleDescription = new SampleDescription(Config.MSAASampleCount, Config.MSAAQuality),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
_zbufferTexture.DebugName = "Lilium DepthStencilBuffer";
// Create the depth buffer view
_zbufferView = new DepthStencilView(Device, _zbufferTexture);
_zbufferView.DebugName = "Lilium DepthStencilBuffer View";
_zbufferTexture.Dispose();
DeviceContext.Rasterizer.SetViewport(0, 0, RenderViewSize.Width, RenderViewSize.Height);
DeviceContext.OutputMerger.SetTargets(_zbufferView, _backbufferView);
// Resize UI Surface
if(mUISurface != null)
mUISurface.SetDesignHeight(RenderViewSize.Height);
needResize = false;
}
public bool Initialize(SystemConfiguration configuration, IntPtr windowHandle)
{
try
{
#region Environment Configuration
// Store the vsync setting.
VerticalSyncEnabled = SystemConfiguration.VerticalSyncEnabled;
// Create a DirectX graphics interface factory.
var factory = new Factory();
// Use the factory to create an adapter for the primary graphics interface (video card).
var adapter = factory.GetAdapter(0);
// Get the primary adapter output (monitor).
var monitor = adapter.GetOutput(0);
// Get modes that fit the DXGI_FORMAT_R8G8B8A8_UNORM display format for the adapter output (monitor).
var modes = monitor.GetDisplayModeList(Format.R8G8B8A8_UNorm, DisplayModeEnumerationFlags.Interlaced);
// Now go through all the display modes and find the one that matches the screen width and height.
// When a match is found store the the refresh rate for that monitor, if vertical sync is enabled.
// Otherwise we use maximum refresh rate.
var rational = new Rational(0, 1);
if (VerticalSyncEnabled)
{
foreach (var mode in modes)
{
if (mode.Width == configuration.Width && mode.Height == configuration.Height)
{
rational = new Rational(mode.RefreshRate.Numerator, mode.RefreshRate.Denominator);
break;
}
}
}
// Get the adapter (video card) description.
var adapterDescription = adapter.Description;
// Store the dedicated video card memory in megabytes.
VideoCardMemory = adapterDescription.DedicatedVideoMemory >> 10 >> 10;
// Convert the name of the video card to a character array and store it.
VideoCardDescription = adapterDescription.Description;
// Release the adapter output.
monitor.Dispose();
// Release the adapter.
adapter.Dispose();
// Release the factory.
factory.Dispose();
#endregion
#region Initialize swap chain and d3d device
// Initialize the swap chain description.
var swapChainDesc = new SwapChainDescription()
{
// Set to a single back buffer.
BufferCount = 1,
// Set the width and height of the back buffer.
ModeDescription = new ModeDescription(configuration.Width, configuration.Height, rational, Format.R8G8B8A8_UNorm),
// Set the usage of the back buffer.
Usage = Usage.RenderTargetOutput,
// Set the handle for the window to render to.
OutputHandle = windowHandle,
// Turn multisampling off.
SampleDescription = new SampleDescription(1, 0),
// Set to full screen or windowed mode.
IsWindowed = !SystemConfiguration.FullScreen,
// Don't set the advanced flags.
Flags = SwapChainFlags.None,
// Discard the back buffer content after presenting.
SwapEffect = SwapEffect.Discard
};
// Create the swap chain, Direct3D device, and Direct3D device context.
Device device;
SwapChain swapChain;
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.None, swapChainDesc, out device, out swapChain);
Device = device;
SwapChain = swapChain;
DeviceContext = device.ImmediateContext;
#endregion
#region Initialize buffers
// Get the pointer to the back buffer.
var backBuffer = Texture2D.FromSwapChain<Texture2D>(SwapChain, 0);
// Create the render target view with the back buffer pointer.
RenderTargetView = new RenderTargetView(device, backBuffer);
// Release pointer to the back buffer as we no longer need it.
backBuffer.Dispose();
// Initialize and set up the description of the depth buffer.
var depthBufferDesc = new Texture2DDescription()
{
Width = configuration.Width,
Height = configuration.Height,
MipLevels = 1,
ArraySize = 1,
Format = Format.D24_UNorm_S8_UInt,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
};
// Create the texture for the depth buffer using the filled out description.
DepthStencilBuffer = new Texture2D(device, depthBufferDesc);
#endregion
#region Initialize Depth Enabled Stencil
// Initialize and set up the description of the stencil state.
var depthStencilDesc = new DepthStencilStateDescription()
{
IsDepthEnabled = true,
DepthWriteMask = DepthWriteMask.All,
DepthComparison = Comparison.Less,
IsStencilEnabled = true,
StencilReadMask = 0xFF,
StencilWriteMask = 0xFF,
// Stencil operation if pixel front-facing.
FrontFace = new DepthStencilOperationDescription()
{
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Increment,
PassOperation = StencilOperation.Keep,
Comparison = Comparison.Always
},
// Stencil operation if pixel is back-facing.
BackFace = new DepthStencilOperationDescription()
{
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Decrement,
PassOperation = StencilOperation.Keep,
Comparison = Comparison.Always
}
};
// Create the depth stencil state.
DepthStencilState = new DepthStencilState(Device, depthStencilDesc);
#endregion
#region Initialize Output Merger
// Set the depth stencil state.
DeviceContext.OutputMerger.SetDepthStencilState(DepthStencilState, 1);
// Initialize and set up the depth stencil view.
var depthStencilViewDesc = new DepthStencilViewDescription()
{
Format = Format.D24_UNorm_S8_UInt,
Dimension = DepthStencilViewDimension.Texture2D,
Texture2D = new DepthStencilViewDescription.Texture2DResource()
{
MipSlice = 0
}
};
// Create the depth stencil view.
DepthStencilView = new DepthStencilView(Device, DepthStencilBuffer, depthStencilViewDesc);
// Bind the render target view and depth stencil buffer to the output render pipeline.
DeviceContext.OutputMerger.SetTargets(DepthStencilView, RenderTargetView);
#endregion
#region Initialize Raster State
// Setup the raster description which will determine how and what polygon will be drawn.
var rasterDesc = new RasterizerStateDescription()
{
IsAntialiasedLineEnabled = false,
CullMode = CullMode.Back,
DepthBias = 0,
DepthBiasClamp = .0f,
IsDepthClipEnabled = true,
FillMode = FillMode.Solid,
IsFrontCounterClockwise = false,
IsMultisampleEnabled = false,
IsScissorEnabled = false,
SlopeScaledDepthBias = .0f
};
// Create the rasterizer state from the description we just filled out.
RasterState = new RasterizerState(Device, rasterDesc);
#endregion
#region Initialize Rasterizer
// Now set the rasterizer state.
DeviceContext.Rasterizer.State = RasterState;
// Setup and create the viewport for rendering.
DeviceContext.Rasterizer.SetViewport(0, 0, configuration.Width, configuration.Height, 0, 1);
#endregion
#region Initialize matrices
// Setup and create the projection matrix.
ProjectionMatrix = Matrix.PerspectiveFovLH((float)(Math.PI / 4f), ((float)configuration.Width / configuration.Height), SystemConfiguration.ScreenNear, SystemConfiguration.ScreenDepth);
// Initialize the world matrix to the identity matrix.
WorldMatrix = Matrix.Identity;
// Create an orthographic projection matrix for 2D rendering.
OrthoMatrix = Matrix.OrthoLH(configuration.Width, configuration.Height, SystemConfiguration.ScreenNear, SystemConfiguration.ScreenDepth);
#endregion
#region Initialize Depth Disabled Stencil
// Now create a second depth stencil state which turns off the Z buffer for 2D rendering.
// The difference is that DepthEnable is set to false.
// All other parameters are the same as the other depth stencil state.
var depthDisabledStencilDesc = new DepthStencilStateDescription()
{
IsDepthEnabled = false,
DepthWriteMask = DepthWriteMask.All,
DepthComparison = Comparison.Less,
IsStencilEnabled = true,
StencilReadMask = 0xFF,
StencilWriteMask = 0xFF,
// Stencil operation if pixel front-facing.
FrontFace = new DepthStencilOperationDescription()
{
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Increment,
PassOperation = StencilOperation.Keep,
Comparison = Comparison.Always
},
// Stencil operation if pixel is back-facing.
BackFace = new DepthStencilOperationDescription()
{
FailOperation = StencilOperation.Keep,
DepthFailOperation = StencilOperation.Decrement,
PassOperation = StencilOperation.Keep,
Comparison = Comparison.Always
}
};
// Create the depth stencil state.
DepthDisabledStencilState = new DepthStencilState(Device, depthDisabledStencilDesc);
#endregion
#region Initialize Blend States
// Create an alpha enabled blend state description.
var blendStateDesc = new BlendStateDescription();
blendStateDesc.RenderTarget[0].IsBlendEnabled = true;
blendStateDesc.RenderTarget[0].SourceBlend = BlendOption.One;
blendStateDesc.RenderTarget[0].DestinationBlend = BlendOption.InverseSourceAlpha;
blendStateDesc.RenderTarget[0].BlendOperation = BlendOperation.Add;
blendStateDesc.RenderTarget[0].SourceAlphaBlend = BlendOption.One;
blendStateDesc.RenderTarget[0].DestinationAlphaBlend = BlendOption.Zero;
blendStateDesc.RenderTarget[0].AlphaBlendOperation = BlendOperation.Add;
blendStateDesc.RenderTarget[0].RenderTargetWriteMask = ColorWriteMaskFlags.All;
// Create the blend state using the description.
AlphaEnableBlendingState = new BlendState(device, blendStateDesc);
// Modify the description to create an disabled blend state description.
blendStateDesc.RenderTarget[0].IsBlendEnabled = false;
// Create the blend state using the description.
AlphaDisableBlendingState = new BlendState(device, blendStateDesc);
#endregion
return true;
}
catch (Exception)
{
return false;
}
}
private static void Main()
{
var form = new RenderForm("SharpDX - MiniCubeTexture Direct3D11 Sample");
// SwapChain description
var desc = new SwapChainDescription()
{
BufferCount = 1,
ModeDescription =
new ModeDescription(form.ClientSize.Width, form.ClientSize.Height,
new Rational(60, 1), Format.R8G8B8A8_UNorm),
IsWindowed = true,
OutputHandle = form.Handle,
SampleDescription = new SampleDescription(1, 0),
SwapEffect = SwapEffect.Discard,
Usage = Usage.RenderTargetOutput
};
// Create Device and SwapChain
Device device;
SwapChain swapChain;
Device.CreateWithSwapChain(DriverType.Hardware, DeviceCreationFlags.Debug, desc, out device, out swapChain);
var context = device.ImmediateContext;
// Ignore all windows events
var factory = swapChain.GetParent<Factory>();
factory.MakeWindowAssociation(form.Handle, WindowAssociationFlags.IgnoreAll);
// New RenderTargetView from the backbuffer
var backBuffer = Texture2D.FromSwapChain<Texture2D>(swapChain, 0);
var renderView = new RenderTargetView(device, backBuffer);
// Compile Vertex and Pixel shaders
var vertexShaderByteCode = ShaderBytecode.CompileFromFile("MiniCubeTexture.fx", "VS", "vs_4_0");
var vertexShader = new VertexShader(device, vertexShaderByteCode);
var pixelShaderByteCode = ShaderBytecode.CompileFromFile("MiniCubeTexture.fx", "PS", "ps_4_0");
var pixelShader = new PixelShader(device, pixelShaderByteCode);
// Layout from VertexShader input signature
var layout = new InputLayout(device, ShaderSignature.GetInputSignature(vertexShaderByteCode), new[]
{
new InputElement("POSITION", 0, Format.R32G32B32A32_Float, 0, 0),
new InputElement("TEXCOORD", 0, Format.R32G32_Float, 16, 0)
});
// Instantiate Vertex buiffer from vertex data
var vertices = Buffer.Create(device, BindFlags.VertexBuffer, new[]
{
// 3D coordinates UV Texture coordinates
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, // Front
-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 0.0f, // BACK
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
-1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f, // Top
-1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f,
-1.0f,-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, // Bottom
1.0f,-1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-1.0f,-1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
-1.0f,-1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
1.0f,-1.0f, -1.0f, 1.0f, 0.0f, 0.0f,
1.0f,-1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f, // Left
-1.0f, -1.0f, 1.0f, 1.0f, 0.0f, 0.0f,
-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-1.0f, -1.0f, -1.0f, 1.0f, 0.0f, 1.0f,
-1.0f, 1.0f, 1.0f, 1.0f, 1.0f, 0.0f,
-1.0f, 1.0f, -1.0f, 1.0f, 1.0f, 1.0f,
1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 0.0f, // Right
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
1.0f, -1.0f, 1.0f, 1.0f, 1.0f, 1.0f,
1.0f, -1.0f, -1.0f, 1.0f, 1.0f, 0.0f,
1.0f, 1.0f, -1.0f, 1.0f, 0.0f, 0.0f,
1.0f, 1.0f, 1.0f, 1.0f, 0.0f, 1.0f,
});
// Create Constant Buffer
var contantBuffer = new Buffer(device, Utilities.SizeOf<Matrix>(), ResourceUsage.Default, BindFlags.ConstantBuffer, CpuAccessFlags.None, ResourceOptionFlags.None, 0);
// Create Depth Buffer & View
var depthBuffer = new Texture2D(device, new Texture2DDescription()
{
Format = Format.D32_Float_S8X24_UInt,
ArraySize = 1,
MipLevels = 1,
Width = form.ClientSize.Width,
Height = form.ClientSize.Height,
SampleDescription = new SampleDescription(1, 0),
Usage = ResourceUsage.Default,
BindFlags = BindFlags.DepthStencil,
CpuAccessFlags = CpuAccessFlags.None,
OptionFlags = ResourceOptionFlags.None
});
var depthView = new DepthStencilView(device, depthBuffer);
// Load texture and create sampler
var texture = Texture2D.FromFile<Texture2D>(device, "GeneticaMortarlessBlocks.jpg");
var textureView = new ShaderResourceView(device, texture);
var sampler = new SamplerState(device, new SamplerStateDescription()
{
Filter = Filter.MinMagMipLinear,
AddressU = TextureAddressMode.Wrap,
AddressV = TextureAddressMode.Wrap,
AddressW = TextureAddressMode.Wrap,
BorderColor = Color.Black,
ComparisonFunction = Comparison.Never,
MaximumAnisotropy = 16,
MipLodBias = 0,
MinimumLod = 0,
MaximumLod = 16,
});
// Prepare All the stages
context.InputAssembler.InputLayout = layout;
context.InputAssembler.PrimitiveTopology = PrimitiveTopology.TriangleList;
context.InputAssembler.SetVertexBuffers(0, new VertexBufferBinding(vertices, Utilities.SizeOf<Vector4>() + Utilities.SizeOf<Vector2>(), 0));
context.VertexShader.SetConstantBuffer(0, contantBuffer);
context.VertexShader.Set(vertexShader);
context.Rasterizer.SetViewports(new Viewport(0, 0, form.ClientSize.Width, form.ClientSize.Height, 0.0f, 1.0f));
context.PixelShader.Set(pixelShader);
context.PixelShader.SetSampler(0, sampler);
context.PixelShader.SetShaderResource(0, textureView);
context.OutputMerger.SetTargets(depthView, renderView);
// Prepare matrices
var view = Matrix.LookAtLH(new Vector3(0, 0, -5), new Vector3(0, 0, 0), Vector3.UnitY);
var proj = Matrix.PerspectiveFovLH((float)Math.PI / 4.0f, form.ClientSize.Width / (float)form.ClientSize.Height, 0.1f, 100.0f);
var viewProj = Matrix.Multiply(view, proj);
// Use clock
var clock = new Stopwatch();
clock.Start();
// Main loop
RenderLoop.Run(form, () =>
{
var time = clock.ElapsedMilliseconds / 1000.0f;
// Clear views
context.ClearDepthStencilView(depthView, DepthStencilClearFlags.Depth, 1.0f, 0);
context.ClearRenderTargetView(renderView, Color.Black);
// Update WorldViewProj Matrix
var worldViewProj = Matrix.RotationX(time) * Matrix.RotationY(time * 2) * Matrix.RotationZ(time * .7f) * viewProj;
worldViewProj.Transpose();
context.UpdateSubresource(ref worldViewProj, contantBuffer);
// Draw the cube
context.Draw(36, 0);
// Present!
swapChain.Present(0, PresentFlags.None);
});
// Release all resources
vertexShaderByteCode.Dispose();
vertexShader.Dispose();
pixelShaderByteCode.Dispose();
pixelShader.Dispose();
vertices.Dispose();
layout.Dispose();
renderView.Dispose();
backBuffer.Dispose();
context.ClearState();
context.Flush();
device.Dispose();
context.Dispose();
swapChain.Dispose();
factory.Dispose();
}
