rooty/dxvk
1
0
Fork 0
mirror of https://github.com/doitsujin/dxvk.git synced 2025-02-18 13:54:16 +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))
return E_INVALIDARG;
const VkPhysicalDeviceFeatures& features = m_dxvkDevice->features();
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;
case D3D11_FEATURE_FORMAT_SUPPORT: {
@ -1599,10 +1598,10 @@ namespace dxvk {
// 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
const VkPhysicalDeviceFeatures& features = m_dxvkDevice->features();
const DxvkDeviceFeatures& features = m_dxvkDevice->features();
auto info = static_cast<D3D11_FEATURE_DATA_D3D11_OPTIONS*>(pFeatureSupportData);
info->OutputMergerLogicOp = features.logicOp;
info->OutputMergerLogicOp = features.core.features.logicOp;
info->UAVOnlyRenderingForcedSampleCount = FALSE;
info->DiscardAPIsSeenByDriver = FALSE;
info->FlagsForUpdateAndCopySeenByDriver = FALSE;
@ -1760,10 +1759,10 @@ namespace dxvk {
| VK_PIPELINE_STAGE_FRAGMENT_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;
if (m_dxvkDevice->features().tessellationShader) {
if (m_dxvkDevice->features().core.features.tessellationShader) {
enabledShaderPipelineStages |= VK_PIPELINE_STAGE_TESSELLATION_CONTROL_SHADER_BIT
| VK_PIPELINE_STAGE_TESSELLATION_EVALUATION_SHADER_BIT;
}
@ -1780,7 +1779,7 @@ namespace dxvk {
return false;
// Check whether all features are supported
const VkPhysicalDeviceFeatures features
const DxvkDeviceFeatures features
= GetDeviceFeatures(adapter, featureLevel);
if (!adapter->checkFeatureSupport(features))
@ -1791,60 +1790,63 @@ namespace dxvk {
}
VkPhysicalDeviceFeatures D3D11Device::GetDeviceFeatures(
DxvkDeviceFeatures D3D11Device::GetDeviceFeatures(
const Rc<DxvkAdapter>& adapter,
D3D_FEATURE_LEVEL featureLevel) {
VkPhysicalDeviceFeatures supported = adapter->features();
VkPhysicalDeviceFeatures enabled = {};
DxvkDeviceFeatures supported = adapter->features();
DxvkDeviceFeatures enabled = {};
enabled.core.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2_KHR;
enabled.core.pNext = nullptr;
if (featureLevel >= D3D_FEATURE_LEVEL_9_1) {
enabled.depthClamp = VK_TRUE;
enabled.depthBiasClamp = VK_TRUE;
enabled.fillModeNonSolid = VK_TRUE;
enabled.pipelineStatisticsQuery = supported.pipelineStatisticsQuery;
enabled.sampleRateShading = VK_TRUE;
enabled.samplerAnisotropy = VK_TRUE;
enabled.shaderClipDistance = VK_TRUE;
enabled.shaderCullDistance = VK_TRUE;
enabled.robustBufferAccess = VK_TRUE;
enabled.core.features.depthClamp = VK_TRUE;
enabled.core.features.depthBiasClamp = VK_TRUE;
enabled.core.features.fillModeNonSolid = VK_TRUE;
enabled.core.features.pipelineStatisticsQuery = supported.core.features.pipelineStatisticsQuery;
enabled.core.features.sampleRateShading = VK_TRUE;
enabled.core.features.samplerAnisotropy = VK_TRUE;
enabled.core.features.shaderClipDistance = VK_TRUE;
enabled.core.features.shaderCullDistance = VK_TRUE;
enabled.core.features.robustBufferAccess = VK_TRUE;
}
if (featureLevel >= D3D_FEATURE_LEVEL_9_2) {
enabled.occlusionQueryPrecise = VK_TRUE;
enabled.core.features.occlusionQueryPrecise = VK_TRUE;
}
if (featureLevel >= D3D_FEATURE_LEVEL_9_3) {
enabled.multiViewport = VK_TRUE;
enabled.independentBlend = VK_TRUE;
enabled.core.features.multiViewport = VK_TRUE;
enabled.core.features.independentBlend = VK_TRUE;
}
if (featureLevel >= D3D_FEATURE_LEVEL_10_0) {
enabled.fullDrawIndexUint32 = VK_TRUE;
enabled.fragmentStoresAndAtomics = VK_TRUE;
enabled.geometryShader = VK_TRUE;
enabled.logicOp = supported.logicOp;
enabled.shaderImageGatherExtended = VK_TRUE;
enabled.textureCompressionBC = VK_TRUE;
enabled.core.features.fullDrawIndexUint32 = VK_TRUE;
enabled.core.features.fragmentStoresAndAtomics = VK_TRUE;
enabled.core.features.geometryShader = VK_TRUE;
enabled.core.features.logicOp = supported.core.features.logicOp;
enabled.core.features.shaderImageGatherExtended = VK_TRUE;
enabled.core.features.textureCompressionBC = VK_TRUE;
}
if (featureLevel >= D3D_FEATURE_LEVEL_10_1) {
enabled.dualSrcBlend = VK_TRUE;
enabled.imageCubeArray = VK_TRUE;
enabled.core.features.dualSrcBlend = VK_TRUE;
enabled.core.features.imageCubeArray = VK_TRUE;
}
if (featureLevel >= D3D_FEATURE_LEVEL_11_0) {
enabled.shaderFloat64 = supported.shaderFloat64;
enabled.shaderInt64 = supported.shaderInt64;
enabled.tessellationShader = VK_TRUE;
enabled.core.features.shaderFloat64 = supported.core.features.shaderFloat64;
enabled.core.features.shaderInt64 = supported.core.features.shaderInt64;
enabled.core.features.tessellationShader = VK_TRUE;
// TODO enable unconditionally once RADV gains support
enabled.shaderStorageImageMultisample = supported.shaderStorageImageMultisample;
enabled.shaderStorageImageReadWithoutFormat = supported.shaderStorageImageReadWithoutFormat;
enabled.shaderStorageImageWriteWithoutFormat = VK_TRUE;
enabled.core.features.shaderStorageImageMultisample = supported.core.features.shaderStorageImageMultisample;
enabled.core.features.shaderStorageImageReadWithoutFormat = supported.core.features.shaderStorageImageReadWithoutFormat;
enabled.core.features.shaderStorageImageWriteWithoutFormat = VK_TRUE;
}
if (featureLevel >= D3D_FEATURE_LEVEL_11_1) {
enabled.logicOp = VK_TRUE;
enabled.vertexPipelineStoresAndAtomics = VK_TRUE;
enabled.core.features.logicOp = VK_TRUE;
enabled.core.features.vertexPipelineStoresAndAtomics = VK_TRUE;
}
return enabled;
@ -1936,7 +1938,7 @@ namespace dxvk {
flags1 |= D3D11_FORMAT_SUPPORT_RENDER_TARGET
| 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;
}
@ -1981,7 +1983,7 @@ namespace dxvk {
flags1 |= D3D11_FORMAT_SUPPORT_TYPED_UNORDERED_ACCESS_VIEW;
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_SINT
|| Format == DXGI_FORMAT_R32_FLOAT)

2
src/d3d11/d3d11_device.h
View File

@ -340,7 +340,7 @@ namespace dxvk {
const Rc<DxvkAdapter>& adapter,
D3D_FEATURE_LEVEL featureLevel);
static VkPhysicalDeviceFeatures GetDeviceFeatures(
static DxvkDeviceFeatures GetDeviceFeatures(
const Rc<DxvkAdapter>& adapter,
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));
Com<D3D11DeviceContainer> container = new D3D11DeviceContainer();
const VkPhysicalDeviceFeatures deviceFeatures
const DxvkDeviceFeatures deviceFeatures
= D3D11Device::GetDeviceFeatures(adapter, fl);
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 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::DeferKill);

2
src/dxgi/dxgi_adapter.cpp
View File

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

2
src/dxgi/dxgi_adapter.h
View File

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

2
src/dxgi/dxgi_device.cpp
View File

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

2
src/dxgi/dxgi_device.h
View File

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

2
src/dxgi/dxgi_interfaces.h
View File

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

193
src/dxvk/dxvk_adapter.cpp
View File

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

24
src/dxvk/dxvk_adapter.h
View File

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

2
src/dxvk/dxvk_device.cpp
View File

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

7
src/dxvk/dxvk_device.h
View File

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

12
src/dxvk/dxvk_device_info.h
View File

@ -17,4 +17,16 @@ namespace dxvk {
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;
};
}