Exemple #1
0
        private static Adapter CreateAdapter(UniqueComPtr <IDXGIAdapter1> dxgiAdapter)
        {
            var p = dxgiAdapter.Ptr;
            DXGI_ADAPTER_DESC1 desc;

            Guard.ThrowIfFailed(p->GetDesc1(&desc));

            LARGE_INTEGER driverVersion;
            Guid          iid = IID_IDXGIDevice;

            Guard.ThrowIfFailed(dxgiAdapter.Ptr->CheckInterfaceSupport(&iid, &driverVersion));

            var descText = new string((char *)desc.Description);

            return(new Adapter(
                       dxgiAdapter.AsIUnknown(),
                       descText,
                       (AdapterVendor)desc.VendorId,
                       desc.DeviceId,
                       desc.SubSysId,
                       desc.Revision,
                       desc.DedicatedVideoMemory,
                       desc.DedicatedSystemMemory,
                       desc.SharedSystemMemory,
                       desc.AdapterLuid,
                       (ulong)driverVersion.QuadPart,
                       (desc.Flags & (int)DXGI_ADAPTER_FLAG.DXGI_ADAPTER_FLAG_SOFTWARE) != 0,
                       DeviceType.GraphicsAndCompute // DXGI doesn't support enumerating non-graphics adapters
                       ));
        }
Exemple #2
0
        private static Adapter CreateAdapter(UniqueComPtr <IDXCoreAdapter> adapter)
        {
            nuint size;

            Guard.ThrowIfFailed(adapter.Ptr->GetPropertySize(DXCoreAdapterProperty.DriverDescription, &size));

            // we do this because we don't want to overrwrite the mem of the buff
            // this just truncates if necessary
            // but buffer may return >requested size, so we use the size we requested for
            var realSize = (int)size;

            using var buff = RentedArray <byte> .Create(realSize);

            fixed(byte *pBuff = buff.Value)
            {
                Guard.ThrowIfFailed(adapter.Ptr->GetProperty(DXCoreAdapterProperty.DriverDescription, (uint)realSize, pBuff));
            }

            GetProperty <DXCoreHardwareID>(DXCoreAdapterProperty.HardwareID, out var vendor);
            GetProperty <LUID>(DXCoreAdapterProperty.InstanceLuid, out var luid);
            GetProperty <bool>(DXCoreAdapterProperty.IsHardware, out var isHardware);
            GetProperty <ulong>(DXCoreAdapterProperty.DedicatedAdapterMemory, out var dedicatedVideoMemory);
            GetProperty <ulong>(DXCoreAdapterProperty.DedicatedSystemMemory, out var dedicatedSystemMemory);
            GetProperty <ulong>(DXCoreAdapterProperty.SharedSystemMemory, out var sharedSystemMemory);
            GetProperty <ulong>(DXCoreAdapterProperty.DriverVersion, out var driverVersion);

            DeviceType type;
            Guid       graphics = DXCORE_ADAPTER_ATTRIBUTE_D3D12_GRAPHICS;
            Guid       compute  = DXCORE_ADAPTER_ATTRIBUTE_D3D12_CORE_COMPUTE;

            if (adapter.Ptr->IsAttributeSupported(&graphics))
            {
                type = DeviceType.GraphicsAndCompute;
            }
            else if (adapter.Ptr->IsAttributeSupported(&compute))
            {
                type = DeviceType.ComputeOnly;
            }
            else
            {
                ThrowHelper.ThrowPlatformNotSupportedException("Adapter does not support DXCore compute or D3D12 graphics");
                type = default;
            }

            return(new Adapter(
                       adapter.AsIUnknown().Move(),
                       Encoding.UTF8.GetString(buff.Value),
                       (AdapterVendor)vendor.vendorID,
                       vendor.deviceID,
                       vendor.subSysID,
                       vendor.revision,
                       dedicatedVideoMemory,
                       dedicatedSystemMemory,
                       sharedSystemMemory,
                       luid,
                       driverVersion,
                       isSoftware: !isHardware,
                       type
                       ));

            void GetProperty <T>(DXCoreAdapterProperty property, out T val) where T : unmanaged
            {
                if (!adapter.Ptr->IsPropertySupported(property))
                {
                    val = default;
                    LogHelper.LogInformation($"DXCoreProperty '{property}' not supported by adapter");
                }

                T data;

                Guard.ThrowIfFailed(adapter.Ptr->GetProperty(property, (uint)sizeof(T), &data));
                val = data;
            }
        }