Exemplo n.º 1
0
        public CommandQueueD3D12(D3D12GraphicsDevice device, CommandQueueType queueType)
            : base(device, queueType)
        {
            switch (queueType)
            {
            case CommandQueueType.Graphics:
                CommandListType = CommandListType.Direct;
                break;

            case CommandQueueType.Compute:
                CommandListType = CommandListType.Compute;
                break;

            case CommandQueueType.Copy:
                CommandListType = CommandListType.Copy;
                break;

            default:
                CommandListType = CommandListType.Bundle;
                break;
            }

            D3D12CommandQueue = device.D3D12Device.CreateCommandQueue(CommandListType);
            D3D12CommandQueue.SetName($"{CommandListType} Command Queue");
        }
Exemplo n.º 2
0
        public D3D12GraphicsDevice(IDXGIFactory4 factory)
        {
            DXGIFactory = factory;

            var adapters = DXGIFactory.EnumAdapters1();

            for (var i = 0; i < adapters.Length; i++)
            {
                var adapter = adapters[i];
                var desc    = adapter.Description1;

                // Don't select the Basic Render Driver adapter.
                if ((desc.Flags & AdapterFlags.Software) != AdapterFlags.None)
                {
                    continue;
                }

                if (D3D12CreateDevice(adapter, FeatureLevel.Level_11_0, out var device).Success)
                {
                    DXGIAdapter = adapter;
                    D3D12Device = device;
                }
            }

            if (D3D12Device == null)
            {
                // Create the Direct3D 12 with WARP adapter.
                DXGIAdapter = DXGIFactory.GetWarpAdapter <IDXGIAdapter1>();

                if (D3D12CreateDevice(DXGIAdapter, FeatureLevel.Level_11_0, out D3D12Device).Failure)
                {
                    throw new GraphicsException("Cannot create D3D12 device");
                }
            }

            if (Validation)
            {
                var infoQueue = D3D12Device.QueryInterfaceOrNull <ID3D12InfoQueue>();
                if (infoQueue != null)
                {
#if DEBUG
                    infoQueue.SetBreakOnSeverity(MessageSeverity.Corruption, true);
                    infoQueue.SetBreakOnSeverity(MessageSeverity.Error, true);
#endif

                    infoQueue.AddStorageFilterEntries(new DirectX.Direct3D12.Debug.InfoQueueFilter
                    {
                        DenyList = new DirectX.Direct3D12.Debug.InfoQueueFilterDescription
                        {
                            Ids = new[]
                            {
                                MessageId.ClearRenderTargetViewMismatchingClearValue,

                                // These happen when capturing with VS diagnostics
                                MessageId.MapInvalidNullRange,
                                MessageId.UnmapInvalidNullRange,
                            }
                        }
                    });
                    infoQueue.Dispose();
                }
            }

            // Init device features.
            InitializeFeatures();

            // Create command queue's.
            _graphicsCommandQueue = new CommandQueueD3D12(this, CommandQueueType.Graphics);
            _computeCommandQueue  = new CommandQueueD3D12(this, CommandQueueType.Compute);
            _copyCommandQueue     = new CommandQueueD3D12(this, CommandQueueType.Copy);

            // Create main graphics command queue.
            GraphicsQueue = D3D12Device.CreateCommandQueue(new CommandQueueDescription(CommandListType.Direct));
            GraphicsQueue.SetName("Main GraphicsQueue");

            // Create ImmediateContext.
            for (int i = 0; i < RenderLatency; i++)
            {
                _deferredReleases[i] = new List <IUnknown>();
            }

            // Create the frame fence
            _frameFence = new FenceD3D12(this, 0);

            // Create descriptor allocators
            for (var i = 0; i < (int)DescriptorHeapType.Count; i++)
            {
                _descriptorAllocator[i] = new DescriptorAllocator(this, (DescriptorHeapType)i);
            }
        }