public CommandBufferD3D12(CommandQueueD3D12 queue, CommandListType type)
: base(queue)
{
var d3d12Device = ((D3D12GraphicsDevice)queue.Device).D3D12Device;
_commandAllocator = d3d12Device.CreateCommandAllocator(type);
CommandList = d3d12Device.CreateCommandList(type, _commandAllocator, null);
_type = type;
}
public void Reset()
{
ID3D12CommandAllocator commandAllocator = GetCommandAllocator();
currentCommandList.NativeCommandAllocator = commandAllocator;
currentCommandList.NativeCommandList.Reset(currentCommandList.NativeCommandAllocator, null);
SetDescriptorHeaps(GraphicsDevice.ShaderVisibleShaderResourceViewAllocator, GraphicsDevice.ShaderVisibleSamplerAllocator);
}
private void Initialize()
{
commandAllocator = GraphicsDevice.NativeDevice.CreateCommandAllocator <ID3D12CommandAllocator>(Vortice.Direct3D12.CommandListType.Direct);
fenceValue = 0;
fence = new Fence(GraphicsDevice, fenceValue);
nativeCommandList = GraphicsDevice.NativeDevice.CreateCommandList <ID3D12GraphicsCommandList>(0, Vortice.Direct3D12.CommandListType.Direct, commandAllocator, null);
// We close it as it starts in open state
nativeCommandList.Close();
}
public CommandList(GraphicsDevice device, CommandListType commandListType)
{
GraphicsDevice = device;
CommandListType = commandListType;
ID3D12CommandAllocator commandAllocator = GetCommandAllocator();
ID3D12GraphicsCommandList nativeCommandList = GraphicsDevice.NativeDevice.CreateCommandList((Vortice.Direct3D12.CommandListType)CommandListType, commandAllocator, null);
currentCommandList = new CompiledCommandList(this, commandAllocator, nativeCommandList);
SetDescriptorHeaps(GraphicsDevice.ShaderVisibleShaderResourceViewAllocator, GraphicsDevice.ShaderVisibleSamplerAllocator);
}
internal CompiledCommandList(CommandList builder, ID3D12CommandAllocator nativeCommandAllocator, ID3D12GraphicsCommandList nativeCommandList)
{
Builder = builder;
NativeCommandAllocator = nativeCommandAllocator;
NativeCommandList = nativeCommandList;
}
public ID3D12GraphicsCommandList CreateCommandList(int nodeMask, CommandListType type, ID3D12CommandAllocator commandAllocator, ID3D12PipelineState initialState = null)
{
Guard.NotNull(commandAllocator, nameof(commandAllocator));
var nativePtr = CreateCommandList(nodeMask, type, commandAllocator, initialState, typeof(ID3D12GraphicsCommandList).GUID);
return(new ID3D12GraphicsCommandList(nativePtr));
}
public ID3D12GraphicsCommandList CreateCommandList(CommandListType type, ID3D12CommandAllocator commandAllocator, ID3D12PipelineState initialState = null)
{
return(CreateCommandList(0, type, commandAllocator, initialState));
}
public void Reset(ID3D12CommandAllocator commandAllocator)
{
Guard.NotNull(commandAllocator, nameof(commandAllocator));
Reset(commandAllocator, null);
}
public HelloDml()
{
if (!IsSupported())
{
throw new InvalidOperationException("Direct3D12 is not supported on current OS");
}
bool validation = false;
#if DEBUG
if (D3D12.D3D12GetDebugInterface(out ID3D12Debug? debug).Success)
{
debug !.EnableDebugLayer();
debug !.Dispose();
validation = true;
}
#endif
DXGIFactory = DXGI.CreateDXGIFactory2 <IDXGIFactory4>(validation);
ID3D12Device2?device = default;
for (int adapterIndex = 0; DXGIFactory.EnumAdapters1(adapterIndex, out IDXGIAdapter1 adapter).Success; adapterIndex++)
{
AdapterDescription1 desc = adapter.Description1;
// Don't select the Basic Render Driver adapter.
if ((desc.Flags & AdapterFlags.Software) != AdapterFlags.None)
{
adapter.Dispose();
continue;
}
if (D3D12.D3D12CreateDevice(adapter, Vortice.Direct3D.FeatureLevel.Level_11_0, out device).Success)
{
adapter.Dispose();
break;
}
}
if (device == null)
{
throw new InvalidOperationException("Direct3D12 device could not be created");
}
D3D12Device = device !;
CommandQueueDescription commandQueueDesc = new()
{
Type = CommandListType.Direct,
Flags = CommandQueueFlags.None,
};
D3D12CommandQueue = D3D12Device.CreateCommandQueue(commandQueueDesc);
D3D12CommandAllocator = D3D12Device.CreateCommandAllocator(CommandListType.Direct);
D3D12CommandList = D3D12Device.CreateCommandList <ID3D12GraphicsCommandList4>(CommandListType.Direct, D3D12CommandAllocator);
var createFlags = CreateDeviceFlags.None;
#if DEBUG
createFlags |= CreateDeviceFlags.Debug;
#endif
DMLDevice = DMLCreateDevice(D3D12Device, createFlags);
Console.WriteLine($"Highest supported feature level: {DMLDevice.HighestFeatureLevel}");
}
protected Application(bool useDirect3D12)
{
_wndProc = ProcessWindowMessage;
var wndClassEx = new WNDCLASSEX
{
Size = Unsafe.SizeOf <WNDCLASSEX>(),
Styles = WindowClassStyles.CS_HREDRAW | WindowClassStyles.CS_VREDRAW | WindowClassStyles.CS_OWNDC,
WindowProc = _wndProc,
InstanceHandle = HInstance,
CursorHandle = LoadCursor(IntPtr.Zero, SystemCursor.IDC_ARROW),
BackgroundBrushHandle = IntPtr.Zero,
IconHandle = IntPtr.Zero,
ClassName = WndClassName,
};
var atom = RegisterClassEx(ref wndClassEx);
if (atom == 0)
{
throw new InvalidOperationException(
$"Failed to register window class. Error: {Marshal.GetLastWin32Error()}"
);
}
Window = new Window("Vortice", 800, 600);
if (useDirect3D12 &&
!ID3D12Device.IsSupported(null, FeatureLevel.Level_11_0))
{
useDirect3D12 = false;
}
var debugFactory = false;
#if DEBUG
if (useDirect3D12)
{
if (D3D12GetDebugInterface <ID3D12Debug>(out var debug).Success)
{
debug.EnableDebugLayer();
debugFactory = true;
}
}
#endif
if (useDirect3D12)
{
if (CreateDXGIFactory2(debugFactory, out IDXGIFactory4 dxgiFactory4).Failure)
{
throw new InvalidOperationException("Cannot create IDXGIFactory4");
}
_dxgiFactory = dxgiFactory4;
}
else
{
if (CreateDXGIFactory2(debugFactory, out _dxgiFactory).Failure)
{
throw new InvalidOperationException("Cannot create IDXGIFactory4");
}
}
if (useDirect3D12)
{
Debug.Assert(D3D12CreateDevice(null, FeatureLevel.Level_11_0, out _d3d12Device).Success);
_d3d12CommandQueue = _d3d12Device.CreateCommandQueue(new CommandQueueDescription(CommandListType.Direct, CommandQueuePriority.Normal));
}
else
{
var featureLevels = new FeatureLevel[]
{
FeatureLevel.Level_11_1,
FeatureLevel.Level_11_0
};
Debug.Assert(ID3D11Device.TryCreate(
null,
DriverType.Hardware,
DeviceCreationFlags.BgraSupport,
featureLevels,
out _d3d11Device,
out _d3d11DeviceContext).Success);
}
var swapChainDesc = new SwapChainDescription1
{
BufferCount = FrameCount,
Width = Window.Width,
Height = Window.Height,
Format = Format.B8G8R8A8_UNorm,
Usage = Vortice.Usage.RenderTargetOutput,
SwapEffect = SwapEffect.FlipDiscard,
SampleDescription = new SampleDescription(1, 0)
};
SwapChain = DXGIFactory.CreateSwapChainForHwnd(_d3d12CommandQueue, Window.Handle, swapChainDesc);
DXGIFactory.MakeWindowAssociation(Window.Handle, WindowAssociationFlags.IgnoreAltEnter);
if (useDirect3D12)
{
SwapChain3 = SwapChain.QueryInterface <IDXGISwapChain3>();
_frameIndex = SwapChain3.GetCurrentBackBufferIndex();
}
_rtvHeap = _d3d12Device.CreateDescriptorHeap(new DescriptorHeapDescription(DescriptorHeapType.RenderTargetView, FrameCount));
_rtvDescriptorSize = _d3d12Device.GetDescriptorHandleIncrementSize(DescriptorHeapType.RenderTargetView);
// Create frame resources.
{
var rtvHandle = _rtvHeap.GetCPUDescriptorHandleForHeapStart();
// Create a RTV for each frame.
_renderTargets = new ID3D12Resource[FrameCount];
for (var i = 0; i < FrameCount; i++)
{
_renderTargets[i] = SwapChain.GetBuffer <ID3D12Resource>(i);
_d3d12Device.CreateRenderTargetView(_renderTargets[i], null, rtvHandle);
rtvHandle += _rtvDescriptorSize;
}
}
_commandAllocator = _d3d12Device.CreateCommandAllocator(CommandListType.Direct);
_commandList = _d3d12Device.CreateCommandList(CommandListType.Direct, _commandAllocator);
_commandList.Close();
// Create synchronization objects.
_d3d12Fence = _d3d12Device.CreateFence(0);
_fenceValue = 1;
_fenceEvent = new AutoResetEvent(false);
}