/// <summary>
    /// Check if this device is supporting threading.
    /// </summary>
    /// <param name="supportsConcurrentResources">Support concurrent resources.</param>
    /// <param name="supportsCommandLists">Support command lists.</param>
    /// <returns>
    /// A <see cref="Result"/> object describing the result of the operation.
    /// </returns>
    public Result CheckThreadingSupport(out bool supportsConcurrentResources, out bool supportsCommandLists)
    {
        FeatureDataThreading support = default;
        Result result = CheckFeatureSupport(Feature.Threading, &support, sizeof(FeatureDataThreading));

        if (result.Failure)
        {
            supportsConcurrentResources = false;
            supportsCommandLists        = false;
        }
        else
        {
            supportsConcurrentResources = support.DriverConcurrentCreates;
            supportsCommandLists        = support.DriverCommandLists;
        }

        return(result);
    }
Example #2
0
        public DeviceD3D11(IDXGIFactory1 factory, bool validation)
        {
            DXGIFactory = factory;
            var adapters = DXGIFactory.EnumAdapters1();

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

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

                var creationFlags = DeviceCreationFlags.BgraSupport /* | DeviceCreationFlags.VideoSupport*/;

                if (validation)
                {
                    creationFlags |= DeviceCreationFlags.Debug;
                }

                if (D3D11CreateDevice(
                        null,
                        DriverType.Hardware,
                        creationFlags,
                        s_featureLevels,
                        out D3D11Device,
                        out FeatureLevel,
                        out D3D11DeviceContext).Failure)
                {
                    // Remove debug flag not being supported.
                    creationFlags &= ~DeviceCreationFlags.Debug;

                    if (D3D11CreateDevice(null, DriverType.Hardware,
                                          creationFlags, s_featureLevels,
                                          out D3D11Device, out FeatureLevel, out D3D11DeviceContext).Failure)
                    {
                        throw new GraphicsException("Cannot create D3D11 Device");
                    }
                }

                DXGIAdapter = adapter;
                break;
            }

            D3D11Device1 = D3D11Device.QueryInterfaceOrNull <ID3D11Device1>();

            // Detect multithreading
            FeatureDataThreading featureDataThreading = default;

            if (D3D11Device.CheckFeatureSupport(DirectX.Direct3D11.Feature.Threading, ref featureDataThreading))
            {
                SupportsConcurrentResources = featureDataThreading.DriverConcurrentCreates;
                SupportsCommandLists        = featureDataThreading.DriverCommandLists;
            }

            // Init device features.
            InitializeFeatures();

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