rooty/dxvk
1
0
Fork 0
mirror of https://github.com/doitsujin/dxvk.git synced 2025-02-18 22:54:15 +01:00
Code Issues Projects Releases Wiki Activity

[dxvk] Add extended device feature structure

Browse Source 
This allows the client API to query and enable extended
features in the future, should it become necessary, much
like the extende feature queries.
This commit is contained in:
Philip Rebohle 2018-07-31 16:58:25 +02:00
parent ebb7902b2c
commit 0ba00b3f59
No known key found for this signature in database
GPG Key ID: C8CC613427A31C99
14 changed files with 207 additions and 133 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

84
src/d3d11/d3d11_device.cpp
View File

@ -1563,10 +1563,9 @@ namespace dxvk {
if (FeatureSupportDataSize != sizeof(D3D11_FEATURE_DATA_DOUBLES)) if (FeatureSupportDataSize != sizeof(D3D11_FEATURE_DATA_DOUBLES))
return E_INVALIDARG; return E_INVALIDARG;
const VkPhysicalDeviceFeatures& features = m_dxvkDevice->features();
auto info = static_cast<D3D11_FEATURE_DATA_DOUBLES*>(pFeatureSupportData); auto info = static_cast<D3D11_FEATURE_DATA_DOUBLES*>(pFeatureSupportData);
info->DoublePrecisionFloatShaderOps = features.shaderFloat64 && features.shaderInt64; info->DoublePrecisionFloatShaderOps = m_dxvkDevice->features().core.features.shaderFloat64
&& m_dxvkDevice->features().core.features.shaderInt64;
} return S_OK; } return S_OK;
case D3D11_FEATURE_FORMAT_SUPPORT: { case D3D11_FEATURE_FORMAT_SUPPORT: {
@ -1599,10 +1598,10 @@ namespace dxvk {
// TODO implement, most of these are required for FL 11.1 // TODO implement, most of these are required for FL 11.1
// https://msdn.microsoft.com/en-us/library/windows/desktop/hh404457(v=vs.85).aspx // https://msdn.microsoft.com/en-us/library/windows/desktop/hh404457(v=vs.85).aspx
const VkPhysicalDeviceFeatures& features = m_dxvkDevice->features(); const DxvkDeviceFeatures& features = m_dxvkDevice->features();
auto info = static_cast<D3D11_FEATURE_DATA_D3D11_OPTIONS*>(pFeatureSupportData); auto info = static_cast<D3D11_FEATURE_DATA_D3D11_OPTIONS*>(pFeatureSupportData);
info->OutputMergerLogicOp = features.logicOp; info->OutputMergerLogicOp = features.core.features.logicOp;
info->UAVOnlyRenderingForcedSampleCount = FALSE; info->UAVOnlyRenderingForcedSampleCount = FALSE;
info->DiscardAPIsSeenByDriver = FALSE; info->DiscardAPIsSeenByDriver = FALSE;
info->FlagsForUpdateAndCopySeenByDriver = FALSE; info->FlagsForUpdateAndCopySeenByDriver = FALSE;
@ -1760,10 +1759,10 @@ namespace dxvk {
| VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT | VK_PIPELINE_STAGE_FRAGMENT_SHADER_BIT
| VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT; | VK_PIPELINE_STAGE_COMPUTE_SHADER_BIT;
if (m_dxvkDevice->features().geometryShader) if (m_dxvkDevice->features().core.features.geometryShader)
enabledShaderPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT; enabledShaderPipelineStages |= VK_PIPELINE_STAGE_GEOMETRY_SHADER_BIT;
if (m_dxvkDevice->features().tessellationShader) { if (m_dxvkDevice->features().core.features.tessellationShader) {
enabledShaderPipelineStages |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT enabledShaderPipelineStages |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
| VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT; | VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
} }
@ -1780,7 +1779,7 @@ namespace dxvk {
return false; return false;
// Check whether all features are supported // Check whether all features are supported
const VkPhysicalDeviceFeatures features const DxvkDeviceFeatures features
= GetDeviceFeatures(adapter, featureLevel); = GetDeviceFeatures(adapter, featureLevel);
if (!adapter->checkFeatureSupport(features)) if (!adapter->checkFeatureSupport(features))
@ -1791,60 +1790,63 @@ namespace dxvk {
} }
VkPhysicalDeviceFeatures D3D11Device::GetDeviceFeatures( DxvkDeviceFeatures D3D11Device::GetDeviceFeatures(
const Rc<DxvkAdapter>& adapter, const Rc<DxvkAdapter>& adapter,
D3D_FEATURE_LEVEL featureLevel) { D3D_FEATURE_LEVEL featureLevel) {
VkPhysicalDeviceFeatures supported = adapter->features(); DxvkDeviceFeatures supported = adapter->features();
VkPhysicalDeviceFeatures enabled = {}; DxvkDeviceFeatures enabled = {};
enabled.core.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
enabled.core.pNext = nullptr;
if (featureLevel >= D3D_FEATURE_LEVEL_9_1) { if (featureLevel >= D3D_FEATURE_LEVEL_9_1) {
enabled.depthClamp = VK_TRUE; enabled.core.features.depthClamp = VK_TRUE;
enabled.depthBiasClamp = VK_TRUE; enabled.core.features.depthBiasClamp = VK_TRUE;
enabled.fillModeNonSolid = VK_TRUE; enabled.core.features.fillModeNonSolid = VK_TRUE;
enabled.pipelineStatisticsQuery = supported.pipelineStatisticsQuery; enabled.core.features.pipelineStatisticsQuery = supported.core.features.pipelineStatisticsQuery;
enabled.sampleRateShading = VK_TRUE; enabled.core.features.sampleRateShading = VK_TRUE;
enabled.samplerAnisotropy = VK_TRUE; enabled.core.features.samplerAnisotropy = VK_TRUE;
enabled.shaderClipDistance = VK_TRUE; enabled.core.features.shaderClipDistance = VK_TRUE;
enabled.shaderCullDistance = VK_TRUE; enabled.core.features.shaderCullDistance = VK_TRUE;
enabled.robustBufferAccess = VK_TRUE; enabled.core.features.robustBufferAccess = VK_TRUE;
} }
if (featureLevel >= D3D_FEATURE_LEVEL_9_2) { if (featureLevel >= D3D_FEATURE_LEVEL_9_2) {
enabled.occlusionQueryPrecise = VK_TRUE; enabled.core.features.occlusionQueryPrecise = VK_TRUE;
} }
if (featureLevel >= D3D_FEATURE_LEVEL_9_3) { if (featureLevel >= D3D_FEATURE_LEVEL_9_3) {
enabled.multiViewport = VK_TRUE; enabled.core.features.multiViewport = VK_TRUE;
enabled.independentBlend = VK_TRUE; enabled.core.features.independentBlend = VK_TRUE;
} }
if (featureLevel >= D3D_FEATURE_LEVEL_10_0) { if (featureLevel >= D3D_FEATURE_LEVEL_10_0) {
enabled.fullDrawIndexUint32 = VK_TRUE; enabled.core.features.fullDrawIndexUint32 = VK_TRUE;
enabled.fragmentStoresAndAtomics = VK_TRUE; enabled.core.features.fragmentStoresAndAtomics = VK_TRUE;
enabled.geometryShader = VK_TRUE; enabled.core.features.geometryShader = VK_TRUE;
enabled.logicOp = supported.logicOp; enabled.core.features.logicOp = supported.core.features.logicOp;
enabled.shaderImageGatherExtended = VK_TRUE; enabled.core.features.shaderImageGatherExtended = VK_TRUE;
enabled.textureCompressionBC = VK_TRUE; enabled.core.features.textureCompressionBC = VK_TRUE;
} }
if (featureLevel >= D3D_FEATURE_LEVEL_10_1) { if (featureLevel >= D3D_FEATURE_LEVEL_10_1) {
enabled.dualSrcBlend = VK_TRUE; enabled.core.features.dualSrcBlend = VK_TRUE;
enabled.imageCubeArray = VK_TRUE; enabled.core.features.imageCubeArray = VK_TRUE;
} }
if (featureLevel >= D3D_FEATURE_LEVEL_11_0) { if (featureLevel >= D3D_FEATURE_LEVEL_11_0) {
enabled.shaderFloat64 = supported.shaderFloat64; enabled.core.features.shaderFloat64 = supported.core.features.shaderFloat64;
enabled.shaderInt64 = supported.shaderInt64; enabled.core.features.shaderInt64 = supported.core.features.shaderInt64;
enabled.tessellationShader = VK_TRUE; enabled.core.features.tessellationShader = VK_TRUE;
// TODO enable unconditionally once RADV gains support // TODO enable unconditionally once RADV gains support
enabled.shaderStorageImageMultisample = supported.shaderStorageImageMultisample; enabled.core.features.shaderStorageImageMultisample = supported.core.features.shaderStorageImageMultisample;
enabled.shaderStorageImageReadWithoutFormat = supported.shaderStorageImageReadWithoutFormat; enabled.core.features.shaderStorageImageReadWithoutFormat = supported.core.features.shaderStorageImageReadWithoutFormat;
enabled.shaderStorageImageWriteWithoutFormat = VK_TRUE; enabled.core.features.shaderStorageImageWriteWithoutFormat = VK_TRUE;
} }
if (featureLevel >= D3D_FEATURE_LEVEL_11_1) { if (featureLevel >= D3D_FEATURE_LEVEL_11_1) {
enabled.logicOp = VK_TRUE; enabled.core.features.logicOp = VK_TRUE;
enabled.vertexPipelineStoresAndAtomics = VK_TRUE; enabled.core.features.vertexPipelineStoresAndAtomics = VK_TRUE;
} }
return enabled; return enabled;
@ -1936,7 +1938,7 @@ namespace dxvk {
flags1 |= D3D11_FORMAT_SUPPORT_RENDER_TARGET flags1 |= D3D11_FORMAT_SUPPORT_RENDER_TARGET
| D3D11_FORMAT_SUPPORT_MIP_AUTOGEN; | D3D11_FORMAT_SUPPORT_MIP_AUTOGEN;
if (m_dxvkDevice->features().logicOp) if (m_dxvkDevice->features().core.features.logicOp)
flags2 |= D3D11_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP; flags2 |= D3D11_FORMAT_SUPPORT2_OUTPUT_MERGER_LOGIC_OP;
} }
@ -1981,7 +1983,7 @@ namespace dxvk {
flags1 |= D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW; flags1 |= D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW;
flags2 |= D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE; flags2 |= D3D11_FORMAT_SUPPORT2_UAV_TYPED_STORE;
if (m_dxvkDevice->features().shaderStorageImageReadWithoutFormat if (m_dxvkDevice->features().core.features.shaderStorageImageReadWithoutFormat
|| Format == DXGI_FORMAT_R32_UINT || Format == DXGI_FORMAT_R32_UINT
|| Format == DXGI_FORMAT_R32_SINT || Format == DXGI_FORMAT_R32_SINT
|| Format == DXGI_FORMAT_R32_FLOAT) || Format == DXGI_FORMAT_R32_FLOAT)

2
src/d3d11/d3d11_device.h
View File

@ -340,7 +340,7 @@ namespace dxvk {
const Rc<DxvkAdapter>& adapter, const Rc<DxvkAdapter>& adapter,
D3D_FEATURE_LEVEL featureLevel); D3D_FEATURE_LEVEL featureLevel);
static VkPhysicalDeviceFeatures GetDeviceFeatures( static DxvkDeviceFeatures GetDeviceFeatures(
const Rc<DxvkAdapter>& adapter, const Rc<DxvkAdapter>& adapter,
D3D_FEATURE_LEVEL featureLevel); D3D_FEATURE_LEVEL featureLevel);

2
src/d3d11/d3d11_main.cpp
View File

@ -69,7 +69,7 @@ extern "C" {
Logger::info(str::format("D3D11CoreCreateDevice: Using feature level ", fl)); Logger::info(str::format("D3D11CoreCreateDevice: Using feature level ", fl));
Com<D3D11DeviceContainer> container = new D3D11DeviceContainer(); Com<D3D11DeviceContainer> container = new D3D11DeviceContainer();
const VkPhysicalDeviceFeatures deviceFeatures const DxvkDeviceFeatures deviceFeatures
= D3D11Device::GetDeviceFeatures(adapter, fl); = D3D11Device::GetDeviceFeatures(adapter, fl);
if (FAILED(dxvkAdapter->CreateDevice(container.ptr(), &deviceFeatures, &container->m_dxgiDevice))) { if (FAILED(dxvkAdapter->CreateDevice(container.ptr(), &deviceFeatures, &container->m_dxgiDevice))) {

4
src/dxbc/dxbc_options.cpp
View File

@ -21,9 +21,9 @@ namespace dxvk {
DxbcOptions getDxbcDeviceOptions(const Rc<DxvkDevice>& device) { DxbcOptions getDxbcDeviceOptions(const Rc<DxvkDevice>& device) {
DxbcOptions flags; DxbcOptions flags;
VkPhysicalDeviceFeatures devFeatures = device->features(); const DxvkDeviceFeatures& devFeatures = device->features();
if (devFeatures.shaderStorageImageReadWithoutFormat) if (devFeatures.core.features.shaderStorageImageReadWithoutFormat)
flags.set(DxbcOption::UseStorageImageReadWithoutFormat); flags.set(DxbcOption::UseStorageImageReadWithoutFormat);
flags.set(DxbcOption::DeferKill); flags.set(DxbcOption::DeferKill);

2
src/dxgi/dxgi_adapter.cpp
View File

@ -210,7 +210,7 @@ namespace dxvk {
HRESULT STDMETHODCALLTYPE DxgiAdapter::CreateDevice( HRESULT STDMETHODCALLTYPE DxgiAdapter::CreateDevice(
IDXGIObject* pContainer, IDXGIObject* pContainer,
const VkPhysicalDeviceFeatures* pFeatures, const DxvkDeviceFeatures* pFeatures,
IDXGIVkDevice** ppDevice) { IDXGIVkDevice** ppDevice) {
InitReturnPtr(ppDevice); InitReturnPtr(ppDevice);

2
src/dxgi/dxgi_adapter.h
View File

@ -50,7 +50,7 @@ namespace dxvk {
HRESULT STDMETHODCALLTYPE CreateDevice( HRESULT STDMETHODCALLTYPE CreateDevice(
IDXGIObject* pContainer, IDXGIObject* pContainer,
const VkPhysicalDeviceFeatures* pFeatures, const DxvkDeviceFeatures* pFeatures,
IDXGIVkDevice** ppDevice) final; IDXGIVkDevice** ppDevice) final;
DXGI_VK_FORMAT_INFO STDMETHODCALLTYPE LookupFormat( DXGI_VK_FORMAT_INFO STDMETHODCALLTYPE LookupFormat(

2
src/dxgi/dxgi_device.cpp
View File

@ -8,7 +8,7 @@ namespace dxvk {
DxgiDevice::DxgiDevice( DxgiDevice::DxgiDevice(
IDXGIObject* pContainer, IDXGIObject* pContainer,
IDXGIVkAdapter* pAdapter, IDXGIVkAdapter* pAdapter,
const VkPhysicalDeviceFeatures* pFeatures) const DxvkDeviceFeatures* pFeatures)
: m_container (pContainer), : m_container (pContainer),
m_adapter (pAdapter) { m_adapter (pAdapter) {
m_device = m_adapter->GetDXVKAdapter()->createDevice(*pFeatures); m_device = m_adapter->GetDXVKAdapter()->createDevice(*pFeatures);

2
src/dxgi/dxgi_device.h
View File

@ -16,7 +16,7 @@ namespace dxvk {
DxgiDevice( DxgiDevice(
IDXGIObject* pContainer, IDXGIObject* pContainer,
IDXGIVkAdapter* pAdapter, IDXGIVkAdapter* pAdapter,
const VkPhysicalDeviceFeatures* pFeatures); const DxvkDeviceFeatures* pFeatures);
~DxgiDevice(); ~DxgiDevice();
ULONG STDMETHODCALLTYPE AddRef() final; ULONG STDMETHODCALLTYPE AddRef() final;

2
src/dxgi/dxgi_interfaces.h
View File

@ -55,7 +55,7 @@ IDXGIVkAdapter : public IDXGIAdapter2 {
*/ */
virtual HRESULT STDMETHODCALLTYPE CreateDevice( virtual HRESULT STDMETHODCALLTYPE CreateDevice(
IDXGIObject* pContainer, IDXGIObject* pContainer,
const VkPhysicalDeviceFeatures* pFeatures, const dxvk::DxvkDeviceFeatures* pFeatures,
IDXGIVkDevice** ppDevice) = 0; IDXGIVkDevice** ppDevice) = 0;
/** /**

193
src/dxvk/dxvk_adapter.cpp
View File

@ -15,6 +15,7 @@ namespace dxvk {
m_handle (handle) { m_handle (handle) {
this->queryExtensions(); this->queryExtensions();
this->queryDeviceInfo(); this->queryDeviceInfo();
this->queryDeviceFeatures();
this->queryDeviceQueues(); this->queryDeviceQueues();
} }
@ -36,13 +37,6 @@ namespace dxvk {
} }
VkPhysicalDeviceFeatures DxvkAdapter::features() const {
VkPhysicalDeviceFeatures features;
m_vki->vkGetPhysicalDeviceFeatures(m_handle, &features);
return features;
}
VkFormatProperties DxvkAdapter::formatProperties(VkFormat format) const { VkFormatProperties DxvkAdapter::formatProperties(VkFormat format) const {
VkFormatProperties formatProperties; VkFormatProperties formatProperties;
m_vki->vkGetPhysicalDeviceFormatProperties(m_handle, format, &formatProperties); m_vki->vkGetPhysicalDeviceFormatProperties(m_handle, format, &formatProperties);
@ -78,69 +72,121 @@ namespace dxvk {
} }
bool DxvkAdapter::checkFeatureSupport( bool DxvkAdapter::checkFeatureSupport(const DxvkDeviceFeatures& required) const {
const VkPhysicalDeviceFeatures& required) const { return (m_deviceFeatures.core.features.robustBufferAccess
const VkPhysicalDeviceFeatures supported = this->features(); || !required.core.features.robustBufferAccess)
&& (m_deviceFeatures.core.features.fullDrawIndexUint32
return (supported.robustBufferAccess || !required.robustBufferAccess) || !required.core.features.fullDrawIndexUint32)
&& (supported.fullDrawIndexUint32 || !required.fullDrawIndexUint32) && (m_deviceFeatures.core.features.imageCubeArray
&& (supported.imageCubeArray || !required.imageCubeArray) || !required.core.features.imageCubeArray)
&& (supported.independentBlend || !required.independentBlend) && (m_deviceFeatures.core.features.independentBlend
&& (supported.geometryShader || !required.geometryShader) || !required.core.features.independentBlend)
&& (supported.tessellationShader || !required.tessellationShader) && (m_deviceFeatures.core.features.geometryShader
&& (supported.sampleRateShading || !required.sampleRateShading) || !required.core.features.geometryShader)
&& (supported.dualSrcBlend || !required.dualSrcBlend) && (m_deviceFeatures.core.features.tessellationShader
&& (supported.logicOp || !required.logicOp) || !required.core.features.tessellationShader)
&& (supported.multiDrawIndirect || !required.multiDrawIndirect) && (m_deviceFeatures.core.features.sampleRateShading
&& (supported.drawIndirectFirstInstance || !required.drawIndirectFirstInstance) || !required.core.features.sampleRateShading)
&& (supported.depthClamp || !required.depthClamp) && (m_deviceFeatures.core.features.dualSrcBlend
&& (supported.depthBiasClamp || !required.depthBiasClamp) || !required.core.features.dualSrcBlend)
&& (supported.fillModeNonSolid || !required.fillModeNonSolid) && (m_deviceFeatures.core.features.logicOp
&& (supported.depthBounds || !required.depthBounds) || !required.core.features.logicOp)
&& (supported.wideLines || !required.wideLines) && (m_deviceFeatures.core.features.multiDrawIndirect
&& (supported.largePoints || !required.largePoints) || !required.core.features.multiDrawIndirect)
&& (supported.alphaToOne || !required.alphaToOne) && (m_deviceFeatures.core.features.drawIndirectFirstInstance
&& (supported.multiViewport || !required.multiViewport) || !required.core.features.drawIndirectFirstInstance)
&& (supported.samplerAnisotropy || !required.samplerAnisotropy) && (m_deviceFeatures.core.features.depthClamp
&& (supported.textureCompressionETC2 || !required.textureCompressionETC2) || !required.core.features.depthClamp)
&& (supported.textureCompressionASTC_LDR || !required.textureCompressionASTC_LDR) && (m_deviceFeatures.core.features.depthBiasClamp
&& (supported.textureCompressionBC || !required.textureCompressionBC) || !required.core.features.depthBiasClamp)
&& (supported.occlusionQueryPrecise || !required.occlusionQueryPrecise) && (m_deviceFeatures.core.features.fillModeNonSolid
&& (supported.pipelineStatisticsQuery || !required.pipelineStatisticsQuery) || !required.core.features.fillModeNonSolid)
&& (supported.vertexPipelineStoresAndAtomics || !required.vertexPipelineStoresAndAtomics) && (m_deviceFeatures.core.features.depthBounds
&& (supported.fragmentStoresAndAtomics || !required.fragmentStoresAndAtomics) || !required.core.features.depthBounds)
&& (supported.shaderTessellationAndGeometryPointSize || !required.shaderTessellationAndGeometryPointSize) && (m_deviceFeatures.core.features.wideLines
&& (supported.shaderImageGatherExtended || !required.shaderImageGatherExtended) || !required.core.features.wideLines)
&& (supported.shaderStorageImageExtendedFormats || !required.shaderStorageImageExtendedFormats) && (m_deviceFeatures.core.features.largePoints
&& (supported.shaderStorageImageMultisample || !required.shaderStorageImageMultisample) || !required.core.features.largePoints)
&& (supported.shaderStorageImageReadWithoutFormat || !required.shaderStorageImageReadWithoutFormat) && (m_deviceFeatures.core.features.alphaToOne
&& (supported.shaderStorageImageWriteWithoutFormat || !required.shaderStorageImageWriteWithoutFormat) || !required.core.features.alphaToOne)
&& (supported.shaderUniformBufferArrayDynamicIndexing || !required.shaderUniformBufferArrayDynamicIndexing) && (m_deviceFeatures.core.features.multiViewport
&& (supported.shaderSampledImageArrayDynamicIndexing || !required.shaderSampledImageArrayDynamicIndexing) || !required.core.features.multiViewport)
&& (supported.shaderStorageBufferArrayDynamicIndexing || !required.shaderStorageBufferArrayDynamicIndexing) && (m_deviceFeatures.core.features.samplerAnisotropy
&& (supported.shaderStorageImageArrayDynamicIndexing || !required.shaderStorageImageArrayDynamicIndexing) || !required.core.features.samplerAnisotropy)
&& (supported.shaderClipDistance || !required.shaderClipDistance) && (m_deviceFeatures.core.features.textureCompressionETC2
&& (supported.shaderCullDistance || !required.shaderCullDistance) || !required.core.features.textureCompressionETC2)
&& (supported.shaderFloat64 || !required.shaderFloat64) && (m_deviceFeatures.core.features.textureCompressionASTC_LDR
&& (supported.shaderInt64 || !required.shaderInt64) || !required.core.features.textureCompressionASTC_LDR)
&& (supported.shaderInt16 || !required.shaderInt16) && (m_deviceFeatures.core.features.textureCompressionBC
&& (supported.shaderResourceResidency || !required.shaderResourceResidency) || !required.core.features.textureCompressionBC)
&& (supported.shaderResourceMinLod || !required.shaderResourceMinLod) && (m_deviceFeatures.core.features.occlusionQueryPrecise
&& (supported.sparseBinding || !required.sparseBinding) || !required.core.features.occlusionQueryPrecise)
&& (supported.sparseResidencyBuffer || !required.sparseResidencyBuffer) && (m_deviceFeatures.core.features.pipelineStatisticsQuery
&& (supported.sparseResidencyImage2D || !required.sparseResidencyImage2D) || !required.core.features.pipelineStatisticsQuery)
&& (supported.sparseResidencyImage3D || !required.sparseResidencyImage3D) && (m_deviceFeatures.core.features.vertexPipelineStoresAndAtomics
&& (supported.sparseResidency2Samples || !required.sparseResidency2Samples) || !required.core.features.vertexPipelineStoresAndAtomics)
&& (supported.sparseResidency4Samples || !required.sparseResidency4Samples) && (m_deviceFeatures.core.features.fragmentStoresAndAtomics
&& (supported.sparseResidency8Samples || !required.sparseResidency8Samples) || !required.core.features.fragmentStoresAndAtomics)
&& (supported.sparseResidency16Samples || !required.sparseResidency16Samples) && (m_deviceFeatures.core.features.shaderTessellationAndGeometryPointSize
&& (supported.sparseResidencyAliased || !required.sparseResidencyAliased) || !required.core.features.shaderTessellationAndGeometryPointSize)
&& (supported.variableMultisampleRate || !required.variableMultisampleRate) && (m_deviceFeatures.core.features.shaderImageGatherExtended
&& (supported.inheritedQueries || !required.inheritedQueries); || !required.core.features.shaderImageGatherExtended)
&& (m_deviceFeatures.core.features.shaderStorageImageExtendedFormats
|| !required.core.features.shaderStorageImageExtendedFormats)
&& (m_deviceFeatures.core.features.shaderStorageImageMultisample
|| !required.core.features.shaderStorageImageMultisample)
&& (m_deviceFeatures.core.features.shaderStorageImageReadWithoutFormat
|| !required.core.features.shaderStorageImageReadWithoutFormat)
&& (m_deviceFeatures.core.features.shaderStorageImageWriteWithoutFormat
|| !required.core.features.shaderStorageImageWriteWithoutFormat)
&& (m_deviceFeatures.core.features.shaderUniformBufferArrayDynamicIndexing
|| !required.core.features.shaderUniformBufferArrayDynamicIndexing)
&& (m_deviceFeatures.core.features.shaderSampledImageArrayDynamicIndexing
|| !required.core.features.shaderSampledImageArrayDynamicIndexing)
&& (m_deviceFeatures.core.features.shaderStorageBufferArrayDynamicIndexing
|| !required.core.features.shaderStorageBufferArrayDynamicIndexing)
&& (m_deviceFeatures.core.features.shaderStorageImageArrayDynamicIndexing
|| !required.core.features.shaderStorageImageArrayDynamicIndexing)
&& (m_deviceFeatures.core.features.shaderClipDistance
|| !required.core.features.shaderClipDistance)
&& (m_deviceFeatures.core.features.shaderCullDistance
|| !required.core.features.shaderCullDistance)
&& (m_deviceFeatures.core.features.shaderFloat64
|| !required.core.features.shaderFloat64)
&& (m_deviceFeatures.core.features.shaderInt64
|| !required.core.features.shaderInt64)
&& (m_deviceFeatures.core.features.shaderInt16
|| !required.core.features.shaderInt16)
&& (m_deviceFeatures.core.features.shaderResourceResidency
|| !required.core.features.shaderResourceResidency)
&& (m_deviceFeatures.core.features.shaderResourceMinLod
|| !required.core.features.shaderResourceMinLod)
&& (m_deviceFeatures.core.features.sparseBinding
|| !required.core.features.sparseBinding)
&& (m_deviceFeatures.core.features.sparseResidencyBuffer
|| !required.core.features.sparseResidencyBuffer)
&& (m_deviceFeatures.core.features.sparseResidencyImage2D
|| !required.core.features.sparseResidencyImage2D)
&& (m_deviceFeatures.core.features.sparseResidencyImage3D
|| !required.core.features.sparseResidencyImage3D)
&& (m_deviceFeatures.core.features.sparseResidency2Samples
|| !required.core.features.sparseResidency2Samples)
&& (m_deviceFeatures.core.features.sparseResidency4Samples
|| !required.core.features.sparseResidency4Samples)
&& (m_deviceFeatures.core.features.sparseResidency8Samples
|| !required.core.features.sparseResidency8Samples)
&& (m_deviceFeatures.core.features.sparseResidency16Samples
|| !required.core.features.sparseResidency16Samples)
&& (m_deviceFeatures.core.features.sparseResidencyAliased
|| !required.core.features.sparseResidencyAliased)
&& (m_deviceFeatures.core.features.variableMultisampleRate
|| !required.core.features.variableMultisampleRate)
&& (m_deviceFeatures.core.features.inheritedQueries
|| !required.core.features.inheritedQueries);
} }
Rc<DxvkDevice> DxvkAdapter::createDevice(const VkPhysicalDeviceFeatures& enabledFeatures) { Rc<DxvkDevice> DxvkAdapter::createDevice(DxvkDeviceFeatures enabledFeatures) {
DxvkDeviceExtensions devExtensions; DxvkDeviceExtensions devExtensions;
std::array<DxvkExt*, 11> devExtensionList = {{ std::array<DxvkExt*, 11> devExtensionList = {{
@ -192,7 +238,7 @@ namespace dxvk {
presentQueue.queueFamilyIndex = pIndex; presentQueue.queueFamilyIndex = pIndex;
queueInfos.push_back(presentQueue); queueInfos.push_back(presentQueue);
} }
VkDeviceCreateInfo info; VkDeviceCreateInfo info;
info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO; info.sType = VK_STRUCTURE_TYPE_DEVICE_CREATE_INFO;
info.pNext = nullptr; info.pNext = nullptr;
@ -203,7 +249,7 @@ namespace dxvk {
info.ppEnabledLayerNames = nullptr; info.ppEnabledLayerNames = nullptr;
info.enabledExtensionCount = extensionNameList.count(); info.enabledExtensionCount = extensionNameList.count();
info.ppEnabledExtensionNames = extensionNameList.names(); info.ppEnabledExtensionNames = extensionNameList.names();
info.pEnabledFeatures = &enabledFeatures; info.pEnabledFeatures = &enabledFeatures.core.features;
VkDevice device = VK_NULL_HANDLE; VkDevice device = VK_NULL_HANDLE;
@ -282,6 +328,15 @@ namespace dxvk {
} }
void DxvkAdapter::queryDeviceFeatures() {
m_deviceFeatures = DxvkDeviceFeatures();
m_deviceFeatures.core.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
m_deviceFeatures.core.pNext = nullptr;
m_vki->vkGetPhysicalDeviceFeatures2KHR(m_handle, &m_deviceFeatures.core);
}
void DxvkAdapter::queryDeviceQueues() { void DxvkAdapter::queryDeviceQueues() {
uint32_t numQueueFamilies = 0; uint32_t numQueueFamilies = 0;
m_vki->vkGetPhysicalDeviceQueueFamilyProperties( m_vki->vkGetPhysicalDeviceQueueFamilyProperties(

24
src/dxvk/dxvk_adapter.h
View File

@ -81,6 +81,16 @@ namespace dxvk {
return m_deviceInfo; return m_deviceInfo;
} }
/**
* \brief Supportred device features
*
* Queries the supported device features.
* \returns Device features
*/
const DxvkDeviceFeatures& features() const {
return m_deviceFeatures;
}
/** /**
* \brief Memory properties * \brief Memory properties
* *
@ -90,14 +100,6 @@ namespace dxvk {
*/ */
VkPhysicalDeviceMemoryProperties memoryProperties() const; VkPhysicalDeviceMemoryProperties memoryProperties() const;
/**
* \brief Supportred device features
*
* Queries the supported device features.
* \returns Device features
*/
VkPhysicalDeviceFeatures features() const;
/** /**
* \brief Queries format support * \brief Queries format support
* *
@ -145,7 +147,7 @@ namespace dxvk {
* \returns \c true if all features are supported * \returns \c true if all features are supported
*/ */
bool checkFeatureSupport( bool checkFeatureSupport(
const VkPhysicalDeviceFeatures& required) const; const DxvkDeviceFeatures& required) const;
/** /**
* \brief Creates a DXVK device * \brief Creates a DXVK device
@ -155,7 +157,7 @@ namespace dxvk {
* \returns Device handle * \returns Device handle
*/ */
Rc<DxvkDevice> createDevice( Rc<DxvkDevice> createDevice(
const VkPhysicalDeviceFeatures& enabledFeatures); DxvkDeviceFeatures enabledFeatures);
/** /**
* \brief Creates a surface * \brief Creates a surface
@ -184,11 +186,13 @@ namespace dxvk {
DxvkNameSet m_deviceExtensions; DxvkNameSet m_deviceExtensions;
DxvkDeviceInfo m_deviceInfo; DxvkDeviceInfo m_deviceInfo;
DxvkDeviceFeatures m_deviceFeatures;
std::vector<VkQueueFamilyProperties> m_queueFamilies; std::vector<VkQueueFamilyProperties> m_queueFamilies;
void queryExtensions(); void queryExtensions();
void queryDeviceInfo(); void queryDeviceInfo();
void queryDeviceFeatures();
void queryDeviceQueues(); void queryDeviceQueues();
uint32_t getAdapterIndex() const; uint32_t getAdapterIndex() const;

2
src/dxvk/dxvk_device.cpp
View File

@ -7,7 +7,7 @@ namespace dxvk {
const Rc<DxvkAdapter>& adapter, const Rc<DxvkAdapter>& adapter,
const Rc<vk::DeviceFn>& vkd, const Rc<vk::DeviceFn>& vkd,
const DxvkDeviceExtensions& extensions, const DxvkDeviceExtensions& extensions,
const VkPhysicalDeviceFeatures& features) const DxvkDeviceFeatures& features)
: m_adapter (adapter), : m_adapter (adapter),
m_vkd (vkd), m_vkd (vkd),
m_extensions (extensions), m_extensions (extensions),

7
src/dxvk/dxvk_device.h
View File

@ -65,7 +65,7 @@ namespace dxvk {
const Rc<DxvkAdapter>& adapter, const Rc<DxvkAdapter>& adapter,
const Rc<vk::DeviceFn>& vkd, const Rc<vk::DeviceFn>& vkd,
const DxvkDeviceExtensions& extensions, const DxvkDeviceExtensions& extensions,
const VkPhysicalDeviceFeatures& features); const DxvkDeviceFeatures& features);
~DxvkDevice(); ~DxvkDevice();
@ -119,7 +119,7 @@ namespace dxvk {
* \brief Enabled device features * \brief Enabled device features
* \returns Enabled features * \returns Enabled features
*/ */
const VkPhysicalDeviceFeatures& features() const { const DxvkDeviceFeatures& features() const {
return m_features; return m_features;
} }
@ -374,7 +374,8 @@ namespace dxvk {
Rc<DxvkAdapter> m_adapter; Rc<DxvkAdapter> m_adapter;
Rc<vk::DeviceFn> m_vkd; Rc<vk::DeviceFn> m_vkd;
DxvkDeviceExtensions m_extensions; DxvkDeviceExtensions m_extensions;
VkPhysicalDeviceFeatures m_features;
DxvkDeviceFeatures m_features;
VkPhysicalDeviceProperties m_properties; VkPhysicalDeviceProperties m_properties;
Rc<DxvkMemoryAllocator> m_memory; Rc<DxvkMemoryAllocator> m_memory;

12
src/dxvk/dxvk_device_info.h
View File

@ -17,4 +17,16 @@ namespace dxvk {
VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT extVertexAttributeDivisor; VkPhysicalDeviceVertexAttributeDivisorPropertiesEXT extVertexAttributeDivisor;
}; };
/**
* \brief Device features
*
* Stores core features and extension-specific features.
* If the respective extensions are not available, the
* extended features will be marked as unsupported.
*/
struct DxvkDeviceFeatures {
VkPhysicalDeviceFeatures2KHR core;
};
} }