public Device(ref Descriptor desc, FeatureLevel featureLevel = FeatureLevel.Level_12_0)
: base(ref desc)
{
if (desc.DebugDevice)
{
var debugInterface = SharpDX.Direct3D12.DebugInterface.Get();
if (debugInterface != null)
{
debugInterface.EnableDebugLayer();
}
else
{
Log.Error("Failed to obtain DX12 debug layer.");
}
}
// Use first adapter that is supported.
using (SharpDX.DXGI.Factory dxgiFactory = new Factory4())
{
for (int adapterIndex = 0;; ++adapterIndex)
{
var adapter = dxgiFactory.GetAdapter(adapterIndex);
if (adapter == null)
{
// TODO: Throw exception
return;
}
try
{
DeviceD3D12 = new SharpDX.Direct3D12.Device(adapter, (SharpDX.Direct3D.FeatureLevel) featureLevel);
Adapter = adapter;
break;
}
catch (Exception)
{
DeviceD3D12 = null;
adapter.Dispose();
}
}
}
// Get Resource handle increment sizes.
descriptorHandleIncrementSize[(int)DescriptorHeap.Descriptor.ResourceDescriptorType.Sampler] = DeviceD3D12.GetDescriptorHandleIncrementSize(DescriptorHeapType.Sampler);
descriptorHandleIncrementSize[(int)DescriptorHeap.Descriptor.ResourceDescriptorType.DepthStencil] = DeviceD3D12.GetDescriptorHandleIncrementSize(DescriptorHeapType.DepthStencilView);
descriptorHandleIncrementSize[(int)DescriptorHeap.Descriptor.ResourceDescriptorType.RenderTarget] = DeviceD3D12.GetDescriptorHandleIncrementSize(DescriptorHeapType.RenderTargetView);
descriptorHandleIncrementSize[(int)DescriptorHeap.Descriptor.ResourceDescriptorType.ShaderResource] = DeviceD3D12.GetDescriptorHandleIncrementSize(DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
Memory.Enums.InitLookupTables();
Log.Info("Successfully created a DX12 device with adapter \"{0}\"", Adapter.Description.Description);
}
private void CreateCommandObjects()
{
var queueDesc = new CommandQueueDescription(CommandListType.Direct);
CommandQueue = Device.CreateCommandQueue(queueDesc);
DirectCmdListAlloc = Device.CreateCommandAllocator(CommandListType.Direct);
CommandList = Device.CreateCommandList(
0,
CommandListType.Direct,
DirectCmdListAlloc, // Associated command allocator.
null); // Initial PipelineStateObject.
// Start off in a closed state. This is because the first time we refer
// to the command list we will Reset it, and it needs to be closed before
// calling Reset.
CommandList.Close();
}
public static List <Mesh> New(Device device,
GraphicsCommandList commandList,
PrimitiveTopology primitiveTopology,
ref int index, Vector3 start, Vector3 stop)
{
var meshes = new List <Mesh>();
var radius = 2;
var x = new Cylinder(device, commandList, primitiveTopology, start, new Vector3(stop.X, start.Y, start.Z), radius, radius, 10, 10, Color.Red, ref index);
meshes.Add(x);
x = new Cylinder(device, commandList, primitiveTopology, new Vector3(stop.X, start.Y, start.Z), stop, radius, radius, 10, 10, Color.Red, ref index);
meshes.Add(x);
x = new Cylinder(device, commandList, primitiveTopology, stop, new Vector3(start.X, stop.Y, stop.Z), radius, radius, 10, 10, Color.Red, ref index);
meshes.Add(x);
x = new Cylinder(device, commandList, primitiveTopology, new Vector3(start.X, stop.Y, stop.Z), start, radius, radius, 10, 10, Color.Red, ref index);
meshes.Add(x);
return(meshes);
}
/// <summary>
/// Gets the maximum multisample count for a particular <see cref="PixelFormat" />.
/// </summary>
/// <param name="device">The device.</param>
/// <param name="pixelFormat">The pixelFormat.</param>
/// <returns>The maximum multisample count for this pixel pixelFormat</returns>
private static MultisampleCount GetMaximumMultisampleCount(SharpDX.Direct3D12.Device device, SharpDX.DXGI.Format pixelFormat)
{
SharpDX.Direct3D12.FeatureDataMultisampleQualityLevels qualityLevels;
qualityLevels.Format = pixelFormat;
qualityLevels.Flags = MultisampleQualityLevelFlags.None;
qualityLevels.QualityLevelCount = 0;
int maxCount = 1;
for (int i = 8; i >= 1; i /= 2)
{
qualityLevels.SampleCount = i;
if (device.CheckFeatureSupport(SharpDX.Direct3D12.Feature.MultisampleQualityLevels, ref qualityLevels))
{
maxCount = i;
break;
}
}
return((MultisampleCount)maxCount);
}
/// <summary>
/// Creates the rendering pipeline.
/// </summary>
void LoadPipeline()
{
// create swap chain descriptor
var swapChainDescription1 = new SwapChainDescription1()
{
AlphaMode = AlphaMode.Unspecified,
BufferCount = SwapBufferCount,
Usage = Usage.RenderTargetOutput,
SwapEffect = SwapEffect.FlipSequential,
SampleDescription = new SampleDescription(1, 0),
Format = Format.R8G8B8A8_UNorm,
Width = width,
Height = height
};
// enable debug layer
using (var debugInterface = DebugInterface.Get())
debugInterface.EnableDebugLayer();
// create device
using (var factory = new Factory4())
{
#if USE_WARP
using (var warpAdapter = factory.GetWarpAdapter())
{
device = Collect(new Device(warpAdapter, FeatureLevel.Level_12_0));
}
#else
using (var adapter = factory.Adapters[1])
{
device = Collect(new Device(adapter, FeatureLevel.Level_11_0));
}
#endif
commandQueue = Collect(device.CreateCommandQueue(new CommandQueueDescription(CommandListType.Direct)));
CreateSwapChain(ref swapChainDescription1, factory);
}
// create command queue and allocator objects
commandListAllocator = Collect(device.CreateCommandAllocator(CommandListType.Direct));
}
// Below are helper factory methods in order to make use generic type inference.
// Note that constructors do not support such inference.
public static MeshGeometry New <TVertex, TIndex>(
Device device,
GraphicsCommandList commandList,
IEnumerable <TVertex> vertices,
IEnumerable <TIndex> indices,
string name = "Default")
where TVertex : struct
where TIndex : struct
{
TVertex[] vertexArray = vertices.ToArray();
TIndex[] indexArray = indices.ToArray();
int vertexBufferByteSize = Utilities.SizeOf(vertexArray);
Resource vertexBufferUploader;
Resource vertexBuffer = D3DUtil.CreateDefaultBuffer(device, commandList, vertexArray, vertexBufferByteSize, out vertexBufferUploader);
int indexBufferByteSize = Utilities.SizeOf(indexArray);
Resource indexBufferUploader;
Resource indexBuffer = D3DUtil.CreateDefaultBuffer(device, commandList, indexArray, indexBufferByteSize, out indexBufferUploader);
return(new MeshGeometry
{
Name = name,
VertexByteStride = Utilities.SizeOf <TVertex>(),
VertexBufferByteSize = vertexBufferByteSize,
VertexBufferGPU = vertexBuffer,
VertexBufferCPU = vertexArray,
IndexCount = indexArray.Length,
IndexFormat = GetIndexFormat <TIndex>(),
IndexBufferByteSize = indexBufferByteSize,
IndexBufferGPU = indexBuffer,
IndexBufferCPU = indexArray,
_toDispose =
{
vertexBuffer, vertexBufferUploader,
indexBuffer, indexBufferUploader
}
});
}
protected void Initialize(Device device, ref int index, IEnumerable <TVertex> vertices = null,
IEnumerable <TIndex> indices = null)
{
this.meshIndex = index;
index++;
var vertexArray = vertices?.ToArray();
var indexArray = indices?.ToArray();
var vertexBufferByteSize = Utilities.SizeOf(vertexArray);
Resource vertexBufferUploader;
var vertexBuffer = BufferHelper.CreateDefaultBuffer(device, CommandList, vertexArray, vertexBufferByteSize,
out vertexBufferUploader);
var indexBufferByteSize = Utilities.SizeOf(indexArray);
Resource indexBufferUploader;
var indexBuffer = BufferHelper.CreateDefaultBuffer(device, CommandList, indexArray, indexBufferByteSize,
out indexBufferUploader);
this.VertexByteStride = Utilities.SizeOf <TVertex>();
this.VertexBufferByteSize = vertexBufferByteSize;
this.VertexBufferGpu = vertexBuffer;
if (indexArray != null)
{
this.IndexCount = indexArray.Length;
this.IndexFormat = GetIndexFormat();
this.IndexBufferByteSize = indexBufferByteSize;
this.IndexBufferGpu = indexBuffer;
}
this.toDispose = new List <IDisposable>
{
vertexBuffer,
vertexBufferUploader,
indexBuffer,
indexBufferUploader
};
}
public static Resource CreateDefaultBuffer <T>(
Device device,
GraphicsCommandList cmdList,
T[] initData,
long byteSize,
out Resource uploadBuffer) where T : struct
{
// Create the actual default buffer resource.
Resource defaultBuffer = device.CreateCommittedResource(
new HeapProperties(HeapType.Default),
HeapFlags.None,
ResourceDescription.Buffer(byteSize),
ResourceStates.Common);
// In order to copy CPU memory data into our default buffer, we need to create
// an intermediate upload heap.
uploadBuffer = device.CreateCommittedResource(
new HeapProperties(HeapType.Upload),
HeapFlags.None,
ResourceDescription.Buffer(byteSize),
ResourceStates.GenericRead);
// Copy the data to the upload buffer.
IntPtr ptr = uploadBuffer.Map(0);
Utilities.Write(ptr, initData, 0, initData.Length);
uploadBuffer.Unmap(0);
// Schedule to copy the data to the default buffer resource.
cmdList.ResourceBarrierTransition(defaultBuffer, ResourceStates.Common, ResourceStates.CopyDestination);
cmdList.CopyResource(defaultBuffer, uploadBuffer);
cmdList.ResourceBarrierTransition(defaultBuffer, ResourceStates.CopyDestination, ResourceStates.GenericRead);
// Note: uploadBuffer has to be kept alive after the above function calls because
// the command list has not been executed yet that performs the actual copy.
// The caller can Release the uploadBuffer after it knows the copy has been executed.
return(defaultBuffer);
}
protected virtual void Dispose(bool disposing)
{
// Implements the basic dispose pattern.
// Ref: https://msdn.microsoft.com/en-us/library/b1yfkh5e(v=vs.110).aspx
if (disposing)
{
FlushCommandQueue();
RtvHeap?.Dispose();
DsvHeap?.Dispose();
SwapChain?.Dispose();
foreach (Resource buffer in _swapChainBuffers)
{
buffer?.Dispose();
}
DepthStencilBuffer?.Dispose();
CommandList?.Dispose();
DirectCmdListAlloc?.Dispose();
CommandQueue?.Dispose();
Fence?.Dispose();
Device?.Dispose();
}
}
/// <summary>
/// Create texture from bmp
/// </summary>
/// <param name="device">Device</param>
/// <param name="filename">Filename</param>
/// <returns></returns>
public static Resource CreateTextureFromBitmap(Device device, string filename)
{
System.Drawing.Bitmap bitmap = new System.Drawing.Bitmap(filename);
int width = bitmap.Width;
int height = bitmap.Height;
// Describe and create a Texture2D.
ResourceDescription textureDesc = new ResourceDescription()
{
MipLevels = 1,
Format = Format.B8G8R8A8_UNorm,
Width = width,
Height = height,
Flags = ResourceFlags.None,
DepthOrArraySize = 1,
SampleDescription = new SampleDescription(1, 0),
Dimension = ResourceDimension.Texture2D,
};
var buffer = device.CreateCommittedResource(new HeapProperties(HeapType.Upload), HeapFlags.None, textureDesc, ResourceStates.GenericRead);
System.Drawing.Imaging.BitmapData data = bitmap.LockBits(new System.Drawing.Rectangle(0, 0, bitmap.Width, bitmap.Height), System.Drawing.Imaging.ImageLockMode.ReadOnly, System.Drawing.Imaging.PixelFormat.Format32bppArgb);
buffer.WriteToSubresource(0, new ResourceRegion()
{
Back = 1,
Bottom = height,
Right = width
}, data.Scan0, 4 * width, 4 * width * height);
int bufferSize = data.Height * data.Stride;
bitmap.UnlockBits(data);
return(buffer);
}
internal CommandQueue(ref Descriptor desc, Device device, string label)
: base(ref desc, device, label)
{
}
protected virtual void OnResize()
{
Debug.Assert(Device != null);
Debug.Assert(SwapChain != null);
Debug.Assert(DirectCmdListAlloc != null);
// Flush before changing any resources.
FlushCommandQueue();
CommandList.Reset(DirectCmdListAlloc, null);
// Release the previous resources we will be recreating.
foreach (Resource buffer in _swapChainBuffers)
{
buffer?.Dispose();
}
DepthStencilBuffer?.Dispose();
// Resize the swap chain.
SwapChain.ResizeBuffers(
SwapChainBufferCount,
ClientWidth, ClientHeight,
BackBufferFormat,
SwapChainFlags.AllowModeSwitch);
CpuDescriptorHandle rtvHeapHandle = RtvHeap.CPUDescriptorHandleForHeapStart;
for (int i = 0; i < SwapChainBufferCount; i++)
{
Resource backBuffer = SwapChain.GetBackBuffer <Resource>(i);
_swapChainBuffers[i] = backBuffer;
Device.CreateRenderTargetView(backBuffer, null, rtvHeapHandle);
rtvHeapHandle += RtvDescriptorSize;
}
// Create the depth/stencil buffer and view.
var depthStencilDesc = new ResourceDescription
{
Dimension = ResourceDimension.Texture2D,
Alignment = 0,
Width = ClientWidth,
Height = ClientHeight,
DepthOrArraySize = 1,
MipLevels = 1,
Format = Format.R24G8_Typeless,
SampleDescription = new SampleDescription
{
Count = MsaaCount,
Quality = MsaaQuality
},
Layout = TextureLayout.Unknown,
Flags = ResourceFlags.AllowDepthStencil
};
var optClear = new ClearValue
{
Format = DepthStencilFormat,
DepthStencil = new DepthStencilValue
{
Depth = 1.0f,
Stencil = 0
}
};
DepthStencilBuffer = Device.CreateCommittedResource(
new HeapProperties(HeapType.Default),
HeapFlags.None,
depthStencilDesc,
ResourceStates.Common,
optClear);
var depthStencilViewDesc = new DepthStencilViewDescription
{
Dimension = DepthStencilViewDimension.Texture2D,
Format = DepthStencilFormat
};
// Create descriptor to mip level 0 of entire resource using a depth stencil format.
CpuDescriptorHandle dsvHeapHandle = DsvHeap.CPUDescriptorHandleForHeapStart;
Device.CreateDepthStencilView(DepthStencilBuffer, depthStencilViewDesc, dsvHeapHandle);
// Transition the resource from its initial state to be used as a depth buffer.
CommandList.ResourceBarrierTransition(DepthStencilBuffer, ResourceStates.Common, ResourceStates.DepthWrite);
// Execute the resize commands.
CommandList.Close();
CommandQueue.ExecuteCommandList(CommandList);
// Wait until resize is complete.
FlushCommandQueue();
Viewport = new ViewportF(0, 0, ClientWidth, ClientHeight, 0.0f, 1.0f);
ScissorRectangle = new RectangleF(0, 0, ClientWidth, ClientHeight);
}
/// <summary>
/// Initializes the specified device.
/// </summary>
/// <param name="graphicsProfiles">The graphics profiles.</param>
/// <param name="deviceCreationFlags">The device creation flags.</param>
/// <param name="windowHandle">The window handle.</param>
private void InitializePlatformDevice(GraphicsProfile[] graphicsProfiles, DeviceCreationFlags deviceCreationFlags, object windowHandle)
{
if (nativeDevice != null)
{
// Destroy previous device
ReleaseDevice();
}
rendererName = Adapter.NativeAdapter.Description.Description;
// Profiling is supported through pix markers
IsProfilingSupported = true;
if ((deviceCreationFlags & DeviceCreationFlags.Debug) != 0)
{
SharpDX.Direct3D12.DebugInterface.Get().EnableDebugLayer();
}
// Default fallback
if (graphicsProfiles.Length == 0)
{
graphicsProfiles = new[] { GraphicsProfile.Level_11_0 }
}
;
// Create Device D3D12 with feature Level based on profile
for (int index = 0; index < graphicsProfiles.Length; index++)
{
var graphicsProfile = graphicsProfiles[index];
try
{
// D3D12 supports only feature level 11+
var level = graphicsProfile.ToFeatureLevel();
if (level < SharpDX.Direct3D.FeatureLevel.Level_11_0)
{
level = SharpDX.Direct3D.FeatureLevel.Level_11_0;
}
nativeDevice = new SharpDX.Direct3D12.Device(Adapter.NativeAdapter, level);
RequestedProfile = graphicsProfile;
CurrentFeatureLevel = level;
break;
}
catch (Exception)
{
if (index == graphicsProfiles.Length - 1)
{
throw;
}
}
}
// Describe and create the command queue.
var queueDesc = new SharpDX.Direct3D12.CommandQueueDescription(SharpDX.Direct3D12.CommandListType.Direct);
NativeCommandQueue = nativeDevice.CreateCommandQueue(queueDesc);
//queueDesc.Type = CommandListType.Copy;
NativeCopyCommandQueue = nativeDevice.CreateCommandQueue(queueDesc);
SrvHandleIncrementSize = NativeDevice.GetDescriptorHandleIncrementSize(DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
SamplerHandleIncrementSize = NativeDevice.GetDescriptorHandleIncrementSize(DescriptorHeapType.Sampler);
// Prepare pools
CommandAllocators = new CommandAllocatorPool(this);
SrvHeaps = new HeapPool(this, SrvHeapSize, DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
SamplerHeaps = new HeapPool(this, SamplerHeapSize, DescriptorHeapType.Sampler);
// Prepare descriptor allocators
SamplerAllocator = new DescriptorAllocator(this, DescriptorHeapType.Sampler);
ShaderResourceViewAllocator = new DescriptorAllocator(this, DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
DepthStencilViewAllocator = new DescriptorAllocator(this, DescriptorHeapType.DepthStencilView);
RenderTargetViewAllocator = new DescriptorAllocator(this, DescriptorHeapType.RenderTargetView);
// Prepare copy command list (start it closed, so that every new use start with a Reset)
NativeCopyCommandAllocator = NativeDevice.CreateCommandAllocator(CommandListType.Direct);
NativeCopyCommandList = NativeDevice.CreateCommandList(CommandListType.Direct, NativeCopyCommandAllocator, null);
NativeCopyCommandList.Close();
// Fence for next frame and resource cleaning
nativeFence = NativeDevice.CreateFence(0, FenceFlags.None);
nativeCopyFence = NativeDevice.CreateFence(0, FenceFlags.None);
}
public GraphicsHost(RenderForm window, bool hidden = false)
{
if (window == null)
{
throw new ArgumentNullException(nameof(window));
}
this.window = window;
if (!hidden)
{
this.window.Visible = true;
}
#if DEBUG
Configuration.EnableObjectTracking = true;
Configuration.ThrowOnShaderCompileError = false;
#endif
var swapChainDescription = new SwapChainDescription()
{
BufferCount = SwapBufferCount,
ModeDescription = new ModeDescription(Format.R8G8B8A8_UNorm),
Usage = Usage.RenderTargetOutput,
OutputHandle = window.Handle,
SwapEffect = SwapEffect.FlipDiscard,
SampleDescription = new SampleDescription(1, 0),
IsWindowed = true
};
#if DEBUG
// Enable the D3D12 debug layer.
// DebugInterface.Get().EnableDebugLayer();
#endif
try
{
// null == DriverType.Hardware
device = new Device(null, FeatureLevel.Level_11_0);
commandQueue = device.CreateCommandQueue(new CommandQueueDescription(CommandListType.Direct));
}
catch (SharpDXException)
{
using (var factory = new Factory4())
{
device = new Device(factory.GetWarpAdapter(), FeatureLevel.Level_11_0);
commandQueue = device.CreateCommandQueue(new CommandQueueDescription(CommandListType.Direct));
}
}
using (var factory = new Factory1())
swapChain = new SwapChain(factory, commandQueue, swapChainDescription);
commandListAllocator = device.CreateCommandAllocator(CommandListType.Direct);
descriptorHeap = device.CreateDescriptorHeap(new DescriptorHeapDescription()
{
Type = DescriptorHeapType.RenderTargetView,
DescriptorCount = 1
});
commandList = device.CreateCommandList(CommandListType.Direct, commandListAllocator, null);
renderTarget = swapChain.GetBackBuffer <Resource>(0);
device.CreateRenderTargetView(renderTarget, null, descriptorHeap.CPUDescriptorHandleForHeapStart);
viewport = new ViewportF(0, 0, this.Width, this.Height);
scissorRectangle = new Rectangle(0, 0, this.Width, this.Height);
fence = device.CreateFence(0, FenceFlags.None);
currentFence = 1;
commandList.Close();
eventHandle = new AutoResetEvent(false);
WaitForPrevFrame();
}
static Resource CreateTextureFromDDS(Device d3dDevice, DDS_HEADER header, DDS_HEADER_DXT10?header10, byte[] bitData, int offset, int maxsize, out bool isCubeMap)
{
int width = header.width;
int height = header.height;
int depth = header.depth;
ResourceDimension resDim = ResourceDimension.Unknown;
int arraySize = 1;
Format format = Format.Unknown;
isCubeMap = false;
int mipCount = header.mipMapCount;
if (0 == mipCount)
{
mipCount = 1;
}
if (((header.ddspf.flags & DDS_FOURCC) > 0) && (MAKEFOURCC('D', 'X', '1', '0') == header.ddspf.fourCC))
{
DDS_HEADER_DXT10 d3d10ext = header10.Value;
arraySize = d3d10ext.arraySize;
if (arraySize == 0)
{
throw new Exception();
}
if (BitsPerPixel(d3d10ext.dxgiFormat) == 0)
{
throw new Exception();
}
format = d3d10ext.dxgiFormat;
switch ((ResourceDimension)d3d10ext.resourceDimension)
{
case ResourceDimension.Texture1D:
// D3DX writes 1D textures with a fixed Height of 1
if ((header.flags & DDS_HEIGHT) > 0 && height != 1)
{
throw new Exception();
}
height = depth = 1;
break;
case ResourceDimension.Texture2D:
//D3D11_RESOURCE_MISC_TEXTURECUBE
if ((d3d10ext.miscFlag & 0x4) > 0)
{
arraySize *= 6;
isCubeMap = true;
}
depth = 1;
break;
case ResourceDimension.Texture3D:
if (!((header.flags & DDS_HEADER_FLAGS_VOLUME) > 0))
{
throw new Exception();
}
if (arraySize > 1)
{
throw new Exception();
}
break;
default:
throw new Exception();
}
resDim = (ResourceDimension)d3d10ext.resourceDimension;
}
else
{
format = GetDXGIFormat(header.ddspf);
if (format == Format.Unknown)
{
throw new Exception();
}
if ((header.flags & DDS_HEADER_FLAGS_VOLUME) > 0)
{
resDim = ResourceDimension.Texture3D;
}
else
{
if ((header.caps2 & DDS_CUBEMAP) > 0)
{
// We require all six faces to be defined
if ((header.caps2 & DDS_CUBEMAP_ALLFACES) != DDS_CUBEMAP_ALLFACES)
{
throw new Exception();
}
arraySize = 6;
isCubeMap = true;
}
depth = 1;
resDim = ResourceDimension.Texture2D;
}
}
var resource = d3dDevice.CreateCommittedResource(new HeapProperties(CpuPageProperty.WriteBack, MemoryPool.L0), HeapFlags.None,
new ResourceDescription()
{
//Alignment = -1,
Dimension = resDim,
DepthOrArraySize = (short)arraySize,
Flags = ResourceFlags.None,
Format = format,
Height = height,
Layout = TextureLayout.Unknown,
MipLevels = (short)mipCount,
SampleDescription = new SampleDescription(1, 0),
Width = width,
},
ResourceStates.GenericRead);
FillInitData(resource, width, height, depth, mipCount, arraySize, format, 0, 0, bitData, offset);
return(resource);
}
public Cylinder(Device device,
GraphicsCommandList commandList,
PrimitiveTopology primitiveTopology,
Vector3 startPoint,
Vector3 endPoint,
float bottomRadius,
float topRadius,
int sliceCount,
int stackCount,
Color color,
ref int index,
string name = "Default")
{
base.CommandList = commandList;
base.PrimitiveTopology = primitiveTopology;
base.Name = name;
var vertices = new List <Vertex>();
var indices = new List <short>();
var height = MathHelper.DistanceBetweenVector(startPoint, endPoint);
var stackHeight = height / stackCount;
var radiusStep = (topRadius - bottomRadius) / stackCount;
var ringCount = stackCount + 1;
for (int i = 0; i < ringCount; i++)
{
var y = -0.5f * height + i * stackHeight;
var r = bottomRadius + i * radiusStep;
var dTheta = 2.0f * MathUtil.Pi / sliceCount;
for (var j = 0; j <= sliceCount; j++)
{
var c = MathHelper.Cosf(j * dTheta);
var s = MathHelper.Sinf(j * dTheta);
var pos = new Vector3(r * c, y, r * s);
var uv = new Vector2((float)j / sliceCount, 1f - (float)i / stackCount);
var tangent = new Vector3(-s, 0.0f, c);
var dr = bottomRadius - topRadius;
var bitangent = new Vector3(dr * c, -height, dr * s);
var normal = Vector3.Cross(tangent, bitangent);
normal.Normalize();
vertices.Add(new Vertex {
Position = pos, Color = color.ToColor4()
});
}
}
var ringVertexCount = sliceCount + 1;
for (var i = 0; i < stackCount; i++)
{
for (var j = 0; j < sliceCount; j++)
{
indices.Add((short)(i * ringVertexCount + j));
indices.Add((short)((i + 1) * ringVertexCount + j));
indices.Add((short)((i + 1) * ringVertexCount + j + 1));
indices.Add((short)(i * ringVertexCount + j));
indices.Add((short)((i + 1) * ringVertexCount + j + 1));
indices.Add((short)(i * ringVertexCount + j + 1));
}
}
var baseIndex = vertices.Count;
var dtheta = 2.0f * MathUtil.Pi / sliceCount;
for (var i = 0; i <= sliceCount; i++)
{
var x = topRadius * MathHelper.Cosf(i * dtheta);
var z = topRadius * MathHelper.Sinf(i * dtheta);
var u = x / height + 0.5f;
var v = z / height + 0.5f;
vertices.Add(new Vertex {
Position = new Vector3(x, 0.5f * height, z), Color = color.ToColor4()
});
}
vertices.Add(new Vertex {
Position = new Vector3(0, 0.5f * height, 0), Color = color.ToColor4()
});
var centerIndex = vertices.Count - 1;
for (int i = 0; i < sliceCount; i++)
{
indices.Add((short)centerIndex);
indices.Add((short)(baseIndex + i + 1));
indices.Add((short)(baseIndex + i));
}
baseIndex = vertices.Count;
for (var i = 0; i <= sliceCount; i++)
{
var x = bottomRadius * MathHelper.Cosf(i * dtheta);
var z = bottomRadius * MathHelper.Sinf(i * dtheta);
var u = x / height + 0.5f;
var v = z / height + 0.5f;
vertices.Add(new Vertex {
Position = new Vector3(x, -0.5f * height, z), Color = color.ToColor4()
});
}
vertices.Add(new Vertex {
Position = new Vector3(0, -0.5f * height, 0), Color = color.ToColor4()
});
centerIndex = vertices.Count - 1;
for (var i = 0; i < sliceCount; i++)
{
indices.Add((short)centerIndex);
indices.Add((short)(baseIndex + i + 1));
indices.Add((short)(baseIndex + i));
}
var vz = new Vector3(0, 1, 0);
var p = startPoint - endPoint;
p.Normalize();
var t = Vector3.Cross(vz, p);
var angle = 180 / Math.PI * Math.Acos(Vector3.Dot(vz, p) / p.Length());
var middle = MathHelper.Middle2Vector(startPoint, endPoint);
World = Matrix.RotationAxis(new Vector3(t.X, t.Y, t.Z), MathHelper.DegreeToRadian((float)angle)) *
Matrix.Translation(middle);
this.Initialize(device, ref index, vertices, indices);
}
public static RootSignature New(Device device)
{
var rootSigDesc = BuildRootSignatureDescription();
return(device.CreateRootSignature(rootSigDesc.Serialize()));
}
private List<IntPtr> GetProcAddress()
{
var address = new List<IntPtr>();
_device12 = new SharpDX.Direct3D12.Device(null, SharpDX.Direct3D.FeatureLevel.Level_11_0);
using (var renderForm = new Form())
{
using (var factory = new SharpDX.DXGI.Factory4())
{
_commandQueue
= _device12.CreateCommandQueue(new SharpDX.Direct3D12.CommandQueueDescription(SharpDX.Direct3D12.CommandListType.Direct));
_commandAllocator
= _device12.CreateCommandAllocator(CommandListType.Direct);
_commandList
= _device12.CreateCommandList(CommandListType.Direct, _commandAllocator, null);
var swapChainDesc = new SharpDX.DXGI.SwapChainDescription()
{
BufferCount = 2,
ModeDescription = new SharpDX.DXGI.ModeDescription(100, 100, new SharpDX.DXGI.Rational(60, 1), SharpDX.DXGI.Format.R8G8B8A8_UNorm),
Usage = SharpDX.DXGI.Usage.RenderTargetOutput,
SwapEffect = SharpDX.DXGI.SwapEffect.FlipDiscard,
OutputHandle = renderForm.Handle,
Flags = SwapChainFlags.AllowModeSwitch,
SampleDescription = new SharpDX.DXGI.SampleDescription(1, 0),
IsWindowed = true
};
var tempSwapChain = new SharpDX.DXGI.SwapChain(factory, _commandQueue, swapChainDesc);
_swapChain = tempSwapChain.QueryInterface<SharpDX.DXGI.SwapChain3>();
tempSwapChain.Dispose();
}
if (_device12 != null && _swapChain != null)
{
address.AddRange(GetVTblAddresses(_device12.NativePointer, 44));
address.AddRange(GetVTblAddresses(_commandQueue.NativePointer, 19));
address.AddRange(GetVTblAddresses(_commandAllocator.NativePointer, 9));
address.AddRange(GetVTblAddresses(_commandList.NativePointer, 60));
address.AddRange(GetVTblAddresses(_swapChain.NativePointer, 18));
_device12.Dispose();
_device12 = null;
_commandQueue.Dispose();
_commandQueue = null;
_commandAllocator.Dispose();
_commandAllocator = null;
_commandList.Dispose();
_commandList = null;
_swapChain.Dispose();
_swapChain = null;
}
}
return address;
}
protected void InitDirect3D()
{
#if DEBUG
// The Direct3D 12 debug layer may or may not be installed. It's installation can be
// managed through settings page "Manage optional features" with a feature called
// "Graphics Tools".
// There may be a better solution to check for it instead of try/catch. If you happen
// to know, please consider opening an issue or PR in the repo.
try
{
DebugInterface.Get().EnableDebugLayer();
}
catch (SharpDXException ex) when(ex.Descriptor.NativeApiCode == "DXGI_ERROR_SDK_COMPONENT_MISSING")
{
Debug.WriteLine("Failed to enable debug layer. Please ensure \"Graphics Tools\" feature is enabled in Windows \"Manage optional feature\" settings page");
}
#endif
_factory = new Factory4();
try
{
// Try to create hardware device.
// Pass NULL to use the default adapter which is the first adapter that is enumerated by Factory.Adapters.
// Ref: https://msdn.microsoft.com/en-us/library/windows/desktop/dn770336(v=vs.85).aspx
Device = new Device(null, FeatureLevel.Level_11_0);
}
catch (SharpDXException)
{
// Fallback to WARP device.
Adapter warpAdapter = _factory.GetWarpAdapter();
Device = new Device(warpAdapter, FeatureLevel.Level_11_0);
}
Fence = Device.CreateFence(0, FenceFlags.None);
_fenceEvent = new AutoResetEvent(false);
RtvDescriptorSize = Device.GetDescriptorHandleIncrementSize(DescriptorHeapType.RenderTargetView);
DsvDescriptorSize = Device.GetDescriptorHandleIncrementSize(DescriptorHeapType.DepthStencilView);
CbvSrvUavDescriptorSize = Device.GetDescriptorHandleIncrementSize(
DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
// Check 4X MSAA quality support for our back buffer format.
// All Direct3D 11 capable devices support 4X MSAA for all render
// target formats, so we only need to check quality support.
FeatureDataMultisampleQualityLevels msQualityLevels;
msQualityLevels.Format = BackBufferFormat;
msQualityLevels.SampleCount = 4;
msQualityLevels.Flags = MultisampleQualityLevelFlags.None;
msQualityLevels.QualityLevelCount = 0;
Debug.Assert(Device.CheckFeatureSupport(Feature.MultisampleQualityLevels, ref msQualityLevels));
_m4xMsaaQuality = msQualityLevels.QualityLevelCount;
#if DEBUG
LogAdapters();
#endif
CreateCommandObjects();
CreateSwapChain();
CreateRtvAndDsvDescriptorHeaps();
}
/// <summary>
/// Load texture from DDS file
/// </summary>
/// <param name="device">Device</param>
/// <param name="filename">Filename</param>
/// <returns></returns>
public static Resource CreateTextureFromDDS(Device device, string filename)
{
bool isCube;
return(CreateTextureFromDDS(device, System.IO.File.ReadAllBytes(filename), out isCube));
}
/// <summary>
/// Initializes the specified device.
/// </summary>
/// <param name="graphicsProfiles">The graphics profiles.</param>
/// <param name="deviceCreationFlags">The device creation flags.</param>
/// <param name="windowHandle">The window handle.</param>
private void InitializePlatformDevice(GraphicsProfile[] graphicsProfiles, DeviceCreationFlags deviceCreationFlags, object windowHandle)
{
if (nativeDevice != null)
{
// Destroy previous device
ReleaseDevice();
}
rendererName = Adapter.NativeAdapter.Description.Description;
// Profiling is supported through pix markers
IsProfilingSupported = true;
// Command lists are thread-safe and execute deferred
IsDeferred = true;
bool isDebug = (deviceCreationFlags & DeviceCreationFlags.Debug) != 0;
if (isDebug)
{
SharpDX.Direct3D12.DebugInterface.Get().EnableDebugLayer();
}
// Create Device D3D12 with feature Level based on profile
for (int index = 0; index < graphicsProfiles.Length; index++)
{
var graphicsProfile = graphicsProfiles[index];
try
{
// D3D12 supports only feature level 11+
var level = graphicsProfile.ToFeatureLevel();
if (level < SharpDX.Direct3D.FeatureLevel.Level_11_0)
{
level = SharpDX.Direct3D.FeatureLevel.Level_11_0;
}
nativeDevice = new SharpDX.Direct3D12.Device(Adapter.NativeAdapter, level);
RequestedProfile = graphicsProfile;
CurrentFeatureLevel = level;
break;
}
catch (Exception)
{
if (index == graphicsProfiles.Length - 1)
{
throw;
}
}
}
// Describe and create the command queue.
var queueDesc = new SharpDX.Direct3D12.CommandQueueDescription(SharpDX.Direct3D12.CommandListType.Direct);
NativeCommandQueue = nativeDevice.CreateCommandQueue(queueDesc);
//queueDesc.Type = CommandListType.Copy;
NativeCopyCommandQueue = nativeDevice.CreateCommandQueue(queueDesc);
TimestampFrequency = NativeCommandQueue.TimestampFrequency;
SrvHandleIncrementSize = NativeDevice.GetDescriptorHandleIncrementSize(DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
SamplerHandleIncrementSize = NativeDevice.GetDescriptorHandleIncrementSize(DescriptorHeapType.Sampler);
if (isDebug)
{
var debugDevice = nativeDevice.QueryInterfaceOrNull <DebugDevice>();
if (debugDevice != null)
{
var infoQueue = debugDevice.QueryInterfaceOrNull <InfoQueue>();
if (infoQueue != null)
{
MessageId[] disabledMessages =
{
// This happens when render target or depth stencil clear value is diffrent
// than provided during resource allocation.
MessageId.CleardepthstencilviewMismatchingclearvalue,
MessageId.ClearrendertargetviewMismatchingclearvalue,
// This occurs when there are uninitialized descriptors in a descriptor table,
// even when a shader does not access the missing descriptors.
MessageId.InvalidDescriptorHandle,
// These happen when capturing with VS diagnostics
MessageId.MapInvalidNullRange,
MessageId.UnmapInvalidNullRange,
};
// Disable irrelevant debug layer warnings
InfoQueueFilter filter = new InfoQueueFilter
{
DenyList = new InfoQueueFilterDescription
{
Ids = disabledMessages
}
};
infoQueue.AddStorageFilterEntries(filter);
//infoQueue.SetBreakOnSeverity(MessageSeverity.Error, true);
//infoQueue.SetBreakOnSeverity(MessageSeverity.Warning, true);
infoQueue.Dispose();
}
debugDevice.Dispose();
}
}
// Prepare pools
CommandAllocators = new CommandAllocatorPool(this);
SrvHeaps = new HeapPool(this, SrvHeapSize, DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
SamplerHeaps = new HeapPool(this, SamplerHeapSize, DescriptorHeapType.Sampler);
// Prepare descriptor allocators
SamplerAllocator = new DescriptorAllocator(this, DescriptorHeapType.Sampler);
ShaderResourceViewAllocator = new DescriptorAllocator(this, DescriptorHeapType.ConstantBufferViewShaderResourceViewUnorderedAccessView);
DepthStencilViewAllocator = new DescriptorAllocator(this, DescriptorHeapType.DepthStencilView);
RenderTargetViewAllocator = new DescriptorAllocator(this, DescriptorHeapType.RenderTargetView);
// Prepare copy command list (start it closed, so that every new use start with a Reset)
NativeCopyCommandAllocator = NativeDevice.CreateCommandAllocator(CommandListType.Direct);
NativeCopyCommandList = NativeDevice.CreateCommandList(CommandListType.Direct, NativeCopyCommandAllocator, null);
NativeCopyCommandList.Close();
// Fence for next frame and resource cleaning
nativeFence = NativeDevice.CreateFence(0, FenceFlags.None);
nativeCopyFence = NativeDevice.CreateFence(0, FenceFlags.None);
}
private void LoadPipeline(RenderForm form)
{
SharpDX.RawInput.Device.RegisterDevice(UsagePage.Generic, UsageId.GenericMouse, DeviceFlags.None);
SharpDX.RawInput.Device.MouseInput += MouseEvent;
SharpDX.RawInput.Device.RegisterDevice(UsagePage.Generic, UsageId.GenericKeyboard, DeviceFlags.None);
SharpDX.RawInput.Device.KeyboardInput += KeyboardEvent;
label = new Label()
{
Text = "Text", Location = new System.Drawing.Point(16, 16)
};
form.Controls.Add(label);
int width = form.ClientSize.Width;
int height = form.ClientSize.Height;
viewport.Width = width;
viewport.Height = height;
viewport.MaxDepth = 1.0f;
scissorRect.Right = width;
scissorRect.Bottom = height;
#if DEBUG
// Enable the D3D12 debug layer.
{
DebugInterface.Get().EnableDebugLayer();
}
#endif
device = new SharpDX.Direct3D12.Device(null, SharpDX.Direct3D.FeatureLevel.Level_11_0);
using (var factory = new Factory4())
{
// Describe and create the command queue.
var queueDesc = new CommandQueueDescription(CommandListType.Direct);
commandQueue = device.CreateCommandQueue(queueDesc);
// Describe and create the swap chain.
var swapChainDesc = new SwapChainDescription()
{
BufferCount = FrameCount,
ModeDescription = new ModeDescription(width, height, new Rational(60, 1), Format.R8G8B8A8_UNorm),
Usage = Usage.RenderTargetOutput,
SwapEffect = SwapEffect.FlipDiscard,
OutputHandle = form.Handle,
//Flags = SwapChainFlags.None,
SampleDescription = new SampleDescription(1, 0),
IsWindowed = true
};
var tempSwapChain = new SwapChain(factory, commandQueue, swapChainDesc);
swapChain = tempSwapChain.QueryInterface <SwapChain3>();
tempSwapChain.Dispose();
frameIndex = swapChain.CurrentBackBufferIndex;
}
// Create descriptor heaps.
// Describe and create a render target view (RTV) descriptor heap.
var rtvHeapDesc = new DescriptorHeapDescription()
{
DescriptorCount = FrameCount,
Flags = DescriptorHeapFlags.None,
Type = DescriptorHeapType.RenderTargetView
};
renderTargetViewHeap = device.CreateDescriptorHeap(rtvHeapDesc);
rtvDescriptorSize = device.GetDescriptorHandleIncrementSize(DescriptorHeapType.RenderTargetView);
// Create frame resources.
var rtvHandle = renderTargetViewHeap.CPUDescriptorHandleForHeapStart;
for (int n = 0; n < FrameCount; n++)
{
renderTargets[n] = swapChain.GetBackBuffer <Resource>(n);
device.CreateRenderTargetView(renderTargets[n], null, rtvHandle);
rtvHandle += rtvDescriptorSize;
}
commandAllocator = device.CreateCommandAllocator(CommandListType.Direct);
}