namespace vk
{
-static bool isPhysicalDeviceFeatures2Supported (const deUint32 version, const std::vector<std::string>& instanceExtensions)
-{
- return isInstanceExtensionSupported(version, instanceExtensions, "VK_KHR_get_physical_device_properties2");
-}
-
DeviceFeatures::DeviceFeatures (const InstanceInterface& vki,
const deUint32 apiVersion,
const VkPhysicalDevice physicalDevice,
const std::vector<std::string>& instanceExtensions,
const std::vector<std::string>& deviceExtensions)
{
- deMemset(&m_coreFeatures2, 0, sizeof(m_coreFeatures2));
- m_coreFeatures2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
+ m_coreFeatures2 = initVulkanStructure();
+ m_vulkan11Features = initVulkanStructure();
+ m_vulkan12Features = initVulkanStructure();
- if (isPhysicalDeviceFeatures2Supported(apiVersion, instanceExtensions))
+ if (isInstanceExtensionSupported(apiVersion, instanceExtensions, "VK_KHR_get_physical_device_properties2"))
{
const std::vector<VkExtensionProperties> deviceExtensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
void** nextPtr = &m_coreFeatures2.pNext;
+ std::vector<FeatureStructWrapperBase*> featuresToFillFromBlob;
+ bool vk12Supported = (apiVersion >= VK_MAKE_VERSION(1, 2, 0));
+
+ // in vk12 we have blob structures combining features of couple previously
+ // available feature structures, that now in vk12 must be removed from chain
+ if (vk12Supported)
+ {
+ addToChainVulkanStructure(&nextPtr, m_vulkan11Features);
+ addToChainVulkanStructure(&nextPtr, m_vulkan12Features);
+ }
- for (size_t i = 0; i < DE_LENGTH_OF_ARRAY(featureStructCreatorMap); ++i)
+ // iterate over data for all feature that are defined in specification
+ for (const auto& featureStructCreationData : featureStructCreationArray)
{
- const char* featureName = featureStructCreatorMap[i].name;
+ const char* featureName = featureStructCreationData.name;
- if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), featureName)
- && verifyFeatureAddCriteria(featureStructCreatorMap[i], deviceExtensionProperties))
+ // check if this feature is available on current device
+ if (de::contains(deviceExtensions.begin(), deviceExtensions.end(), featureName) &&
+ verifyFeatureAddCriteria(featureStructCreationData, deviceExtensionProperties))
{
- FeatureStruct* p = createFeatureStructWrapper(featureName);
-
- if (p)
+ FeatureStructWrapperBase* p = (*featureStructCreationData.creatorFunction)();
+ if (p == DE_NULL)
+ continue;
+
+ // if feature struct is part of VkPhysicalDeviceVulkan1{1,2}Features
+ // we dont add it to the chain but store and fill later from blob data
+ bool featureFilledFromBlob = false;
+ if (vk12Supported)
+ featureFilledFromBlob = isPartOfBlobFeatures(p->getFeatureDesc().sType);
+
+ if (featureFilledFromBlob)
+ featuresToFillFromBlob.push_back(p);
+ else
{
+ // add to chain
*nextPtr = p->getFeatureTypeRaw();
nextPtr = p->getFeatureTypeNext();
- m_features.push_back(p);
}
+ m_features.push_back(p);
}
}
vki.getPhysicalDeviceFeatures2(physicalDevice, &m_coreFeatures2);
+
+ // fill data from VkPhysicalDeviceVulkan1{1,2}Features
+ if (vk12Supported)
+ {
+ AllBlobs allBlobs =
+ {
+ m_vulkan11Features,
+ m_vulkan12Features,
+ // add blobs from future vulkan versions here
+ };
+
+ for (auto feature : featuresToFillFromBlob)
+ feature->initializeFromBlob(allBlobs);
+ }
}
else
m_coreFeatures2.features = getPhysicalDeviceFeatures(vki, physicalDevice);
m_coreFeatures2.features.robustBufferAccess = false;
}
-bool DeviceFeatures::verifyFeatureAddCriteria (const FeatureStructMapItem& item, const std::vector<VkExtensionProperties>& properties)
+bool DeviceFeatures::verifyFeatureAddCriteria (const FeatureStructCreationData& item, const std::vector<VkExtensionProperties>& properties)
{
- bool criteriaOK = true;
-
if (deStringEqual(item.name, VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME))
{
- const size_t propSize = properties.size();
-
- for (size_t propIdx = 0; propIdx < propSize; ++propIdx)
+ for (const auto& property : properties)
{
- if (deStringEqual(properties[propIdx].extensionName, item.name))
- {
- criteriaOK = properties[propIdx].specVersion == item.specVersion;
- break;
- }
+ if (deStringEqual(property.extensionName, item.name))
+ return (property.specVersion == item.specVersion);
}
}
- return criteriaOK;
+ return true;
}
bool DeviceFeatures::contains (const std::string& feature, bool throwIfNotExists) const
{
- const size_t typesSize = m_features.size();
-
- for (size_t typeIdx = 0; typeIdx < typesSize; ++typeIdx)
+ for (const auto f : m_features)
{
- if (deStringEqual(m_features[typeIdx]->getFeatureDesc().name, feature.c_str()))
- {
+ if (deStringEqual(f->getFeatureDesc().name, feature.c_str()))
return true;
- }
}
if (throwIfNotExists)
- {
- std::string msg("Feature " + feature + " is not supported");
-
- TCU_THROW(NotSupportedError, msg);
- }
+ TCU_THROW(NotSupportedError, "Feature " + feature + " is not supported");
return false;
}
bool DeviceFeatures::isDeviceFeatureInitialized (VkStructureType sType) const
{
- return findStructureInChain(&m_coreFeatures2, sType) != DE_NULL;
+ for (const auto f : m_features)
+ {
+ if (f->getFeatureDesc().sType == sType)
+ return true;
+ }
+ return false;
}
DeviceFeatures::~DeviceFeatures (void)
{
- for (size_t i = 0; i < m_features.size(); ++i)
- delete m_features[i];
+ for (auto p : m_features)
+ delete p;
m_features.clear();
}
-FeatureStruct* DeviceFeatures::createFeatureStructWrapper (const std::string& s)
-{
- for (size_t i = 0; i < DE_LENGTH_OF_ARRAY(featureStructCreatorMap); ++i)
- {
- if (deStringEqual(featureStructCreatorMap[i].name, s.c_str()))
- return (*featureStructCreatorMap[i].creator)();
- }
-
- return DE_NULL;
-}
-
} // vk
namespace vk
{
+// Structure describing vulkan feature structure
struct FeatureDesc
{
- FeatureDesc (VkStructureType sType_, const char* name_, deUint32 specVersion_, deUint32 typeId_)
- : name (name_)
- , sType (sType_)
- , specVersion (specVersion_)
- , typeId (typeId_)
- {}
-
- const char* name;
VkStructureType sType;
+ const char* name;
const deUint32 specVersion;
const deUint32 typeId;
};
-struct FeatureStruct
+// Structure containg all feature blobs - this simplifies generated code
+struct AllBlobs
{
- virtual deUint32 getFeatureTypeId (void) const = 0;
- virtual FeatureDesc getFeatureDesc (void) const = 0;
- virtual void** getFeatureTypeNext (void) = 0;
- virtual void* getFeatureTypeRaw (void) = 0;
- virtual ~FeatureStruct (void) {}
+ VkPhysicalDeviceVulkan11Features& vk11;
+ VkPhysicalDeviceVulkan12Features& vk12;
+ // add blobs from future vulkan versions here
};
+// Base class for all FeatureStructWrapper specializations
+class FeatureStructWrapperBase
+{
+public:
+ virtual ~FeatureStructWrapperBase (void) {}
+ virtual void initializeFromBlob (const AllBlobs& allBlobs) = 0;
+ virtual deUint32 getFeatureTypeId (void) const = 0;
+ virtual FeatureDesc getFeatureDesc (void) const = 0;
+ virtual void** getFeatureTypeNext (void) = 0;
+ virtual void* getFeatureTypeRaw (void) = 0;
+};
-struct FeatureStructMapItem
+using FeatureStructWrapperCreator = FeatureStructWrapperBase* (*) (void);
+struct FeatureStructCreationData
{
- FeatureStruct* (*creator)(void);
- const char* name;
- deUint32 specVersion;
+ FeatureStructWrapperCreator creatorFunction;
+ const char* name;
+ deUint32 specVersion;
};
-template<class FeatureType> struct FeatureStructWrapper;
+template<class FeatureType> class FeatureStructWrapper;
template<class FeatureType> FeatureDesc makeFeatureDesc (void);
template<class FeatureType>
-FeatureStruct* createFeatureStructWrapper (void)
+FeatureStructWrapperBase* createFeatureStructWrapper (void)
{
return new FeatureStructWrapper<FeatureType>(makeFeatureDesc<FeatureType>());
}
+template<class FeatureType>
+void initFromBlob(FeatureType& featureType, const AllBlobs& allBlobs);
+
+template<class FeatureType>
+void initFromBlobWrapper(FeatureType& featureType, const AllBlobs& allBlobs)
+{
+ initFromBlob<FeatureType>(featureType, allBlobs);
+}
+
class DeviceFeatures
{
public:
- DeviceFeatures (const InstanceInterface& vki,
- const deUint32 apiVersion,
- const VkPhysicalDevice physicalDevice,
- const std::vector<std::string>& instanceExtensions,
- const std::vector<std::string>& deviceExtensions);
-
- ~DeviceFeatures (void);
+ DeviceFeatures (const InstanceInterface& vki,
+ const deUint32 apiVersion,
+ const VkPhysicalDevice physicalDevice,
+ const std::vector<std::string>& instanceExtensions,
+ const std::vector<std::string>& deviceExtensions);
- template<class FeatureType>
- bool getFeatureType (FeatureType& featureType) const
- {
- typedef FeatureStructWrapper<FeatureType> *FeatureWrapperPtr;
-
- const VkStructureType sType = makeFeatureDesc<FeatureType>().sType;
- const size_t featCount = m_features.size();
-
- for (size_t featIdx = 0; featIdx < featCount; ++featIdx)
- {
- if (sType == m_features[featIdx]->getFeatureDesc().sType)
- {
- featureType = static_cast<FeatureWrapperPtr>(m_features[featIdx])->getFeatureTypeRef();
- return true;
- }
- }
- return false;
- }
+ ~DeviceFeatures (void);
template<class FeatureType>
- const FeatureType& getFeatureType (void) const
- {
- typedef FeatureStructWrapper<FeatureType> *FeatureWrapperPtr;
+ const FeatureType& getFeatureType (void) const;
- const FeatureDesc featDesc = makeFeatureDesc<FeatureType>();
- const VkStructureType sType = featDesc.sType;
- const size_t featCount = m_features.size();
+ const VkPhysicalDeviceFeatures2& getCoreFeatures2 (void) const { return m_coreFeatures2; }
+ const VkPhysicalDeviceVulkan11Features& getVulkan11Features (void) const { return m_vulkan11Features; }
+ const VkPhysicalDeviceVulkan12Features& getVulkan12Features (void) const { return m_vulkan12Features; }
- for (size_t featIdx = 0; featIdx < featCount; ++featIdx)
- {
- if (sType == m_features[featIdx]->getFeatureDesc().sType)
- return static_cast<FeatureWrapperPtr>(m_features[featIdx])->getFeatureTypeRef();
- }
+ bool contains (const std::string& feature, bool throwIfNotExists = false) const;
- const deUint32 featureId = featDesc.typeId;
+ bool isDeviceFeatureInitialized (VkStructureType sType) const;
- for (size_t featIdx = 0; featIdx < featCount; ++featIdx)
- {
- if (featureId == m_features[featIdx]->getFeatureTypeId())
- return static_cast<FeatureWrapperPtr>(m_features[featIdx])->getFeatureTypeRef();
- }
+private:
- FeatureStruct* p = vk::createFeatureStructWrapper<FeatureType>();
- m_features.push_back(p);
+ static bool verifyFeatureAddCriteria (const FeatureStructCreationData& item, const std::vector<VkExtensionProperties>& properties);
- return static_cast<FeatureWrapperPtr>(p)->getFeatureTypeRef();
- }
+private:
- const VkPhysicalDeviceFeatures2& getCoreFeatures2 (void) const { return m_coreFeatures2; }
+ VkPhysicalDeviceFeatures2 m_coreFeatures2;
+ mutable std::vector<FeatureStructWrapperBase*> m_features;
+ VkPhysicalDeviceVulkan11Features m_vulkan11Features;
+ VkPhysicalDeviceVulkan12Features m_vulkan12Features;
+};
- bool contains (const std::string& feature, bool throwIfNotExists = false) const;
+template<class FeatureType>
+const FeatureType& DeviceFeatures::getFeatureType(void) const
+{
+ typedef FeatureStructWrapper<FeatureType>* FeatureWrapperPtr;
- bool isDeviceFeatureInitialized (VkStructureType sType) const;
+ const FeatureDesc featDesc = makeFeatureDesc<FeatureType>();
+ const VkStructureType sType = featDesc.sType;
-private:
- static FeatureStruct* createFeatureStructWrapper (const std::string& s);
+ // try to find feature by sType
+ for (auto feature : m_features)
+ {
+ if (sType == feature->getFeatureDesc().sType)
+ return static_cast<FeatureWrapperPtr>(feature)->getFeatureTypeRef();
+ }
- static bool verifyFeatureAddCriteria (const FeatureStructMapItem& item, const std::vector<VkExtensionProperties>& properties);
+ // try to find feature by id that was assigned by gen_framework script
+ const deUint32 featureId = featDesc.typeId;
+ for (auto feature : m_features)
+ {
+ if (featureId == feature->getFeatureTypeId())
+ return static_cast<FeatureWrapperPtr>(feature)->getFeatureTypeRef();
+ }
- VkPhysicalDeviceFeatures2 m_coreFeatures2;
- mutable std::vector<FeatureStruct*> m_features;
-};
+ // if initialized feature structure was not found create empty one and return it
+ m_features.push_back(vk::createFeatureStructWrapper<FeatureType>());
+ return static_cast<FeatureWrapperPtr>(m_features.back())->getFeatureTypeRef();
+}
template<class FeatureType>
-struct FeatureStructWrapper : FeatureStruct
+class FeatureStructWrapper : public FeatureStructWrapperBase
{
+public:
+ FeatureStructWrapper (const FeatureDesc& featureDesc)
+ : m_featureDesc(featureDesc)
+ {
+ deMemset(&m_featureType, 0, sizeof(m_featureType));
+ m_featureType.sType = featureDesc.sType;
+ }
+
+ void initializeFromBlob (const AllBlobs& allBlobs)
+ {
+ initFromBlobWrapper(m_featureType, allBlobs);
+ }
+
+ deUint32 getFeatureTypeId (void) const { return m_featureDesc.typeId; }
+ FeatureDesc getFeatureDesc (void) const { return m_featureDesc; }
+ void** getFeatureTypeNext (void) { return &m_featureType.pNext; }
+ void* getFeatureTypeRaw (void) { return &m_featureType; }
+ FeatureType& getFeatureTypeRef (void) { return m_featureType; }
+
+public:
+ // metadata about feature structure
const FeatureDesc m_featureDesc;
- FeatureType m_featureType;
- FeatureStructWrapper (void)
- : m_featureDesc (VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2, DE_NULL, ~0u, 0u)
- {
- deMemset(&m_featureType, 0, sizeof(m_featureType));
- }
-
- FeatureStructWrapper (const FeatureDesc& featureDesc)
- : m_featureDesc (featureDesc)
- {
- deMemset(&m_featureType, 0, sizeof(m_featureType));
- m_featureType.sType = featureDesc.sType;
- }
-
- deUint32 getFeatureTypeId (void) const { return m_featureDesc.typeId; }
- FeatureDesc getFeatureDesc (void) const { return m_featureDesc; }
- void** getFeatureTypeNext (void) { return &m_featureType.pNext; }
- void* getFeatureTypeRaw (void) { return &m_featureType; }
- FeatureType& getFeatureTypeRef (void) { return m_featureType; }
+ // actual vulkan feature structure
+ FeatureType m_featureType;
};
} // vk
#define VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME "VK_EXT_ycbcr_image_arrays"
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 51); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 50); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 49); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 48); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 47); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0, 46); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 45); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 44); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 43); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 42); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 41); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 40); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 39); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 38); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 37); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 36); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 35); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 34); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 33); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 32); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 31); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 30); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 29); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 28); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 27); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 26); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePerformanceQueryFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME, VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION, 25); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION, 24); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 23); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 22); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, 21); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceScalarBlockLayoutFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION, 20); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION, 19); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderAtomicInt64Features>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION, 18); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderClockFeaturesKHR>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, VK_KHR_SHADER_CLOCK_EXTENSION_NAME, VK_KHR_SHADER_CLOCK_SPEC_VERSION, 17); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION, 16); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDrawParametersFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION, 15); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderFloat16Int8Features>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION, 14); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME, VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION, 13); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION, 12); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME, VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION, 11); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShadingRateImageFeaturesNV>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME, VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION, 10); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION, 9); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION, 8); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceTimelineSemaphoreFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION, 7); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION, 6); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION, 5); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceVariablePointersFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, VK_KHR_VARIABLE_POINTERS_SPEC_VERSION, 4); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION, 3); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceVulkanMemoryModelFeatures>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME, VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION, 2); }
-template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>(void) { return FeatureDesc(VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME, VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION, 1); }
+template<> void initFromBlob<VkPhysicalDevice16BitStorageFeatures>(VkPhysicalDevice16BitStorageFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.storageBuffer16BitAccess = allBlobs.vk11.storageBuffer16BitAccess;
+ featureType.uniformAndStorageBuffer16BitAccess = allBlobs.vk11.uniformAndStorageBuffer16BitAccess;
+ featureType.storagePushConstant16 = allBlobs.vk11.storagePushConstant16;
+ featureType.storageInputOutput16 = allBlobs.vk11.storageInputOutput16;
+}
+template<> void initFromBlob<VkPhysicalDeviceMultiviewFeatures>(VkPhysicalDeviceMultiviewFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.multiview = allBlobs.vk11.multiview;
+ featureType.multiviewGeometryShader = allBlobs.vk11.multiviewGeometryShader;
+ featureType.multiviewTessellationShader = allBlobs.vk11.multiviewTessellationShader;
+}
+template<> void initFromBlob<VkPhysicalDeviceVariablePointersFeatures>(VkPhysicalDeviceVariablePointersFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.variablePointersStorageBuffer = allBlobs.vk11.variablePointersStorageBuffer;
+ featureType.variablePointers = allBlobs.vk11.variablePointers;
+}
+template<> void initFromBlob<VkPhysicalDeviceProtectedMemoryFeatures>(VkPhysicalDeviceProtectedMemoryFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.protectedMemory = allBlobs.vk11.protectedMemory;
+}
+template<> void initFromBlob<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(VkPhysicalDeviceSamplerYcbcrConversionFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.samplerYcbcrConversion = allBlobs.vk11.samplerYcbcrConversion;
+}
+template<> void initFromBlob<VkPhysicalDeviceShaderDrawParametersFeatures>(VkPhysicalDeviceShaderDrawParametersFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.shaderDrawParameters = allBlobs.vk11.shaderDrawParameters;
+}
+template<> void initFromBlob<VkPhysicalDevice8BitStorageFeatures>(VkPhysicalDevice8BitStorageFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.storageBuffer8BitAccess = allBlobs.vk12.storageBuffer8BitAccess;
+ featureType.uniformAndStorageBuffer8BitAccess = allBlobs.vk12.uniformAndStorageBuffer8BitAccess;
+ featureType.storagePushConstant8 = allBlobs.vk12.storagePushConstant8;
+}
+template<> void initFromBlob<VkPhysicalDeviceShaderAtomicInt64Features>(VkPhysicalDeviceShaderAtomicInt64Features& featureType, const AllBlobs& allBlobs)
+{
+ featureType.shaderBufferInt64Atomics = allBlobs.vk12.shaderBufferInt64Atomics;
+ featureType.shaderSharedInt64Atomics = allBlobs.vk12.shaderSharedInt64Atomics;
+}
+template<> void initFromBlob<VkPhysicalDeviceShaderFloat16Int8Features>(VkPhysicalDeviceShaderFloat16Int8Features& featureType, const AllBlobs& allBlobs)
+{
+ featureType.shaderFloat16 = allBlobs.vk12.shaderFloat16;
+ featureType.shaderInt8 = allBlobs.vk12.shaderInt8;
+}
+template<> void initFromBlob<VkPhysicalDeviceDescriptorIndexingFeatures>(VkPhysicalDeviceDescriptorIndexingFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.shaderInputAttachmentArrayDynamicIndexing = allBlobs.vk12.shaderInputAttachmentArrayDynamicIndexing;
+ featureType.shaderUniformTexelBufferArrayDynamicIndexing = allBlobs.vk12.shaderUniformTexelBufferArrayDynamicIndexing;
+ featureType.shaderStorageTexelBufferArrayDynamicIndexing = allBlobs.vk12.shaderStorageTexelBufferArrayDynamicIndexing;
+ featureType.shaderUniformBufferArrayNonUniformIndexing = allBlobs.vk12.shaderUniformBufferArrayNonUniformIndexing;
+ featureType.shaderSampledImageArrayNonUniformIndexing = allBlobs.vk12.shaderSampledImageArrayNonUniformIndexing;
+ featureType.shaderStorageBufferArrayNonUniformIndexing = allBlobs.vk12.shaderStorageBufferArrayNonUniformIndexing;
+ featureType.shaderStorageImageArrayNonUniformIndexing = allBlobs.vk12.shaderStorageImageArrayNonUniformIndexing;
+ featureType.shaderInputAttachmentArrayNonUniformIndexing = allBlobs.vk12.shaderInputAttachmentArrayNonUniformIndexing;
+ featureType.shaderUniformTexelBufferArrayNonUniformIndexing = allBlobs.vk12.shaderUniformTexelBufferArrayNonUniformIndexing;
+ featureType.shaderStorageTexelBufferArrayNonUniformIndexing = allBlobs.vk12.shaderStorageTexelBufferArrayNonUniformIndexing;
+ featureType.descriptorBindingUniformBufferUpdateAfterBind = allBlobs.vk12.descriptorBindingUniformBufferUpdateAfterBind;
+ featureType.descriptorBindingSampledImageUpdateAfterBind = allBlobs.vk12.descriptorBindingSampledImageUpdateAfterBind;
+ featureType.descriptorBindingStorageImageUpdateAfterBind = allBlobs.vk12.descriptorBindingStorageImageUpdateAfterBind;
+ featureType.descriptorBindingStorageBufferUpdateAfterBind = allBlobs.vk12.descriptorBindingStorageBufferUpdateAfterBind;
+ featureType.descriptorBindingUniformTexelBufferUpdateAfterBind = allBlobs.vk12.descriptorBindingUniformTexelBufferUpdateAfterBind;
+ featureType.descriptorBindingStorageTexelBufferUpdateAfterBind = allBlobs.vk12.descriptorBindingStorageTexelBufferUpdateAfterBind;
+ featureType.descriptorBindingUpdateUnusedWhilePending = allBlobs.vk12.descriptorBindingUpdateUnusedWhilePending;
+ featureType.descriptorBindingPartiallyBound = allBlobs.vk12.descriptorBindingPartiallyBound;
+ featureType.descriptorBindingVariableDescriptorCount = allBlobs.vk12.descriptorBindingVariableDescriptorCount;
+ featureType.runtimeDescriptorArray = allBlobs.vk12.runtimeDescriptorArray;
+}
+template<> void initFromBlob<VkPhysicalDeviceScalarBlockLayoutFeatures>(VkPhysicalDeviceScalarBlockLayoutFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.scalarBlockLayout = allBlobs.vk12.scalarBlockLayout;
+}
+template<> void initFromBlob<VkPhysicalDeviceVulkanMemoryModelFeatures>(VkPhysicalDeviceVulkanMemoryModelFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.vulkanMemoryModel = allBlobs.vk12.vulkanMemoryModel;
+ featureType.vulkanMemoryModelDeviceScope = allBlobs.vk12.vulkanMemoryModelDeviceScope;
+ featureType.vulkanMemoryModelAvailabilityVisibilityChains = allBlobs.vk12.vulkanMemoryModelAvailabilityVisibilityChains;
+}
+template<> void initFromBlob<VkPhysicalDeviceImagelessFramebufferFeatures>(VkPhysicalDeviceImagelessFramebufferFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.imagelessFramebuffer = allBlobs.vk12.imagelessFramebuffer;
+}
+template<> void initFromBlob<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>(VkPhysicalDeviceUniformBufferStandardLayoutFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.uniformBufferStandardLayout = allBlobs.vk12.uniformBufferStandardLayout;
+}
+template<> void initFromBlob<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>(VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.shaderSubgroupExtendedTypes = allBlobs.vk12.shaderSubgroupExtendedTypes;
+}
+template<> void initFromBlob<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>(VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.separateDepthStencilLayouts = allBlobs.vk12.separateDepthStencilLayouts;
+}
+template<> void initFromBlob<VkPhysicalDeviceHostQueryResetFeatures>(VkPhysicalDeviceHostQueryResetFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.hostQueryReset = allBlobs.vk12.hostQueryReset;
+}
+template<> void initFromBlob<VkPhysicalDeviceTimelineSemaphoreFeatures>(VkPhysicalDeviceTimelineSemaphoreFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.timelineSemaphore = allBlobs.vk12.timelineSemaphore;
+}
+template<> void initFromBlob<VkPhysicalDeviceBufferDeviceAddressFeatures>(VkPhysicalDeviceBufferDeviceAddressFeatures& featureType, const AllBlobs& allBlobs)
+{
+ featureType.bufferDeviceAddress = allBlobs.vk12.bufferDeviceAddress;
+ featureType.bufferDeviceAddressCaptureReplay = allBlobs.vk12.bufferDeviceAddressCaptureReplay;
+ featureType.bufferDeviceAddressMultiDevice = allBlobs.vk12.bufferDeviceAddressMultiDevice;
+}
+// generic template is not enough for some compilers
+template<> void initFromBlob<VkPhysicalDevicePerformanceQueryFeaturesKHR>(VkPhysicalDevicePerformanceQueryFeaturesKHR&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(VkPhysicalDeviceTransformFeedbackFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceCornerSampledImageFeaturesNV>(VkPhysicalDeviceCornerSampledImageFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>(VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceASTCDecodeFeaturesEXT>(VkPhysicalDeviceASTCDecodeFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(VkPhysicalDeviceConditionalRenderingFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(VkPhysicalDeviceDepthClipEnableFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(VkPhysicalDeviceInlineUniformBlockFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceShaderSMBuiltinsFeaturesNV>(VkPhysicalDeviceShaderSMBuiltinsFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceShaderClockFeaturesKHR>(VkPhysicalDeviceShaderClockFeaturesKHR&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceShadingRateImageFeaturesNV>(VkPhysicalDeviceShadingRateImageFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>(VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(VkPhysicalDeviceComputeShaderDerivativesFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceMeshShaderFeaturesNV>(VkPhysicalDeviceMeshShaderFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(VkPhysicalDeviceShaderImageFootprintFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceExclusiveScissorFeaturesNV>(VkPhysicalDeviceExclusiveScissorFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(VkPhysicalDeviceFragmentDensityMapFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>(VkPhysicalDeviceSubgroupSizeControlFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(VkPhysicalDeviceCoherentMemoryFeaturesAMD&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(VkPhysicalDeviceMemoryPriorityFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(VkPhysicalDeviceBufferDeviceAddressFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(VkPhysicalDeviceCooperativeMatrixFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(VkPhysicalDeviceCoverageReductionModeFeaturesNV&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>(VkPhysicalDeviceYcbcrImageArraysFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceLineRasterizationFeaturesEXT>(VkPhysicalDeviceLineRasterizationFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(VkPhysicalDeviceIndexTypeUint8FeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>(VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT&, const AllBlobs&) {}
+template<> void initFromBlob<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT&, const AllBlobs&) {}
-static const FeatureStructMapItem featureStructCreatorMap[] =
+
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice16BitStorageFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION, 51}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevice8BitStorageFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION, 50}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BLEND_OPERATION_ADVANCED_FEATURES_EXT, VK_EXT_BLEND_OPERATION_ADVANCED_EXTENSION_NAME, VK_EXT_BLEND_OPERATION_ADVANCED_SPEC_VERSION, 49}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES, VK_KHR_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_KHR_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 48}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceBufferDeviceAddressFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES_EXT, VK_EXT_BUFFER_DEVICE_ADDRESS_EXTENSION_NAME, VK_EXT_BUFFER_DEVICE_ADDRESS_SPEC_VERSION, 47}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoherentMemoryFeaturesAMD>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COHERENT_MEMORY_FEATURES_AMD, DECL_AMD_COHERENT_MEMORY_EXTENSION_NAME, 0, 46}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceComputeShaderDerivativesFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COMPUTE_SHADER_DERIVATIVES_FEATURES_NV, VK_NV_COMPUTE_SHADER_DERIVATIVES_EXTENSION_NAME, VK_NV_COMPUTE_SHADER_DERIVATIVES_SPEC_VERSION, 45}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceConditionalRenderingFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CONDITIONAL_RENDERING_FEATURES_EXT, VK_EXT_CONDITIONAL_RENDERING_EXTENSION_NAME, VK_EXT_CONDITIONAL_RENDERING_SPEC_VERSION, 44}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCooperativeMatrixFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COOPERATIVE_MATRIX_FEATURES_NV, VK_NV_COOPERATIVE_MATRIX_EXTENSION_NAME, VK_NV_COOPERATIVE_MATRIX_SPEC_VERSION, 43}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCornerSampledImageFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_CORNER_SAMPLED_IMAGE_FEATURES_NV, VK_NV_CORNER_SAMPLED_IMAGE_EXTENSION_NAME, VK_NV_CORNER_SAMPLED_IMAGE_SPEC_VERSION, 42}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceCoverageReductionModeFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_COVERAGE_REDUCTION_MODE_FEATURES_NV, VK_NV_COVERAGE_REDUCTION_MODE_EXTENSION_NAME, VK_NV_COVERAGE_REDUCTION_MODE_SPEC_VERSION, 41}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDedicatedAllocationImageAliasingFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEDICATED_ALLOCATION_IMAGE_ALIASING_FEATURES_NV, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_EXTENSION_NAME, VK_NV_DEDICATED_ALLOCATION_IMAGE_ALIASING_SPEC_VERSION, 40}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDepthClipEnableFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DEPTH_CLIP_ENABLE_FEATURES_EXT, VK_EXT_DEPTH_CLIP_ENABLE_EXTENSION_NAME, VK_EXT_DEPTH_CLIP_ENABLE_SPEC_VERSION, 39}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceDescriptorIndexingFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES, VK_EXT_DESCRIPTOR_INDEXING_EXTENSION_NAME, VK_EXT_DESCRIPTOR_INDEXING_SPEC_VERSION, 38}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceExclusiveScissorFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_EXCLUSIVE_SCISSOR_FEATURES_NV, VK_NV_SCISSOR_EXCLUSIVE_EXTENSION_NAME, VK_NV_SCISSOR_EXCLUSIVE_SPEC_VERSION, 37}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_DENSITY_MAP_FEATURES_EXT, VK_EXT_FRAGMENT_DENSITY_MAP_EXTENSION_NAME, VK_EXT_FRAGMENT_DENSITY_MAP_SPEC_VERSION, 36}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderBarycentricFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_BARYCENTRIC_FEATURES_NV, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_EXTENSION_NAME, VK_NV_FRAGMENT_SHADER_BARYCENTRIC_SPEC_VERSION, 35}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FRAGMENT_SHADER_INTERLOCK_FEATURES_EXT, VK_EXT_FRAGMENT_SHADER_INTERLOCK_EXTENSION_NAME, VK_EXT_FRAGMENT_SHADER_INTERLOCK_SPEC_VERSION, 34}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceHostQueryResetFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES, VK_EXT_HOST_QUERY_RESET_EXTENSION_NAME, VK_EXT_HOST_QUERY_RESET_SPEC_VERSION, 33}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceImagelessFramebufferFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES, VK_KHR_IMAGELESS_FRAMEBUFFER_EXTENSION_NAME, VK_KHR_IMAGELESS_FRAMEBUFFER_SPEC_VERSION, 32}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INDEX_TYPE_UINT8_FEATURES_EXT, VK_EXT_INDEX_TYPE_UINT8_EXTENSION_NAME, VK_EXT_INDEX_TYPE_UINT8_SPEC_VERSION, 31}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT, VK_EXT_INLINE_UNIFORM_BLOCK_EXTENSION_NAME, VK_EXT_INLINE_UNIFORM_BLOCK_SPEC_VERSION, 30}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceLineRasterizationFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_LINE_RASTERIZATION_FEATURES_EXT, VK_EXT_LINE_RASTERIZATION_EXTENSION_NAME, VK_EXT_LINE_RASTERIZATION_SPEC_VERSION, 29}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMemoryPriorityFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MEMORY_PRIORITY_FEATURES_EXT, VK_EXT_MEMORY_PRIORITY_EXTENSION_NAME, VK_EXT_MEMORY_PRIORITY_SPEC_VERSION, 28}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMeshShaderFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MESH_SHADER_FEATURES_NV, VK_NV_MESH_SHADER_EXTENSION_NAME, VK_NV_MESH_SHADER_SPEC_VERSION, 27}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceMultiviewFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES, VK_KHR_MULTIVIEW_EXTENSION_NAME, VK_KHR_MULTIVIEW_SPEC_VERSION, 26}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePerformanceQueryFeaturesKHR>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PERFORMANCE_QUERY_FEATURES_KHR, VK_KHR_PERFORMANCE_QUERY_EXTENSION_NAME, VK_KHR_PERFORMANCE_QUERY_SPEC_VERSION, 25}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PIPELINE_EXECUTABLE_PROPERTIES_FEATURES_KHR, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_EXTENSION_NAME, VK_KHR_PIPELINE_EXECUTABLE_PROPERTIES_SPEC_VERSION, 24}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceProtectedMemoryFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES, DECL_PROTECTED_MEMORY_EXTENSION_NAME, 0, 23}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceRepresentativeFragmentTestFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_REPRESENTATIVE_FRAGMENT_TEST_FEATURES_NV, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_EXTENSION_NAME, VK_NV_REPRESENTATIVE_FRAGMENT_TEST_SPEC_VERSION, 22}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSamplerYcbcrConversionFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES, VK_KHR_SAMPLER_YCBCR_CONVERSION_EXTENSION_NAME, VK_KHR_SAMPLER_YCBCR_CONVERSION_SPEC_VERSION, 21}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceScalarBlockLayoutFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES, VK_EXT_SCALAR_BLOCK_LAYOUT_EXTENSION_NAME, VK_EXT_SCALAR_BLOCK_LAYOUT_SPEC_VERSION, 20}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_EXTENSION_NAME, VK_KHR_SEPARATE_DEPTH_STENCIL_LAYOUTS_SPEC_VERSION, 19}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderAtomicInt64Features>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES, VK_KHR_SHADER_ATOMIC_INT64_EXTENSION_NAME, VK_KHR_SHADER_ATOMIC_INT64_SPEC_VERSION, 18}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderClockFeaturesKHR>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR, VK_KHR_SHADER_CLOCK_EXTENSION_NAME, VK_KHR_SHADER_CLOCK_SPEC_VERSION, 17}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DEMOTE_TO_HELPER_INVOCATION_FEATURES_EXT, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_EXTENSION_NAME, VK_EXT_SHADER_DEMOTE_TO_HELPER_INVOCATION_SPEC_VERSION, 16}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderDrawParametersFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES, VK_KHR_SHADER_DRAW_PARAMETERS_EXTENSION_NAME, VK_KHR_SHADER_DRAW_PARAMETERS_SPEC_VERSION, 15}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderFloat16Int8Features>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES, VK_KHR_SHADER_FLOAT16_INT8_EXTENSION_NAME, VK_KHR_SHADER_FLOAT16_INT8_SPEC_VERSION, 14}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderImageFootprintFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_IMAGE_FOOTPRINT_FEATURES_NV, VK_NV_SHADER_IMAGE_FOOTPRINT_EXTENSION_NAME, VK_NV_SHADER_IMAGE_FOOTPRINT_SPEC_VERSION, 13}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderIntegerFunctions2FeaturesINTEL>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_INTEGER_FUNCTIONS_2_FEATURES_INTEL, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_EXTENSION_NAME, VK_INTEL_SHADER_INTEGER_FUNCTIONS_2_SPEC_VERSION, 12}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES, VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_EXTENSION_NAME, VK_KHR_SHADER_SUBGROUP_EXTENDED_TYPES_SPEC_VERSION, 11}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceShadingRateImageFeaturesNV>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADING_RATE_IMAGE_FEATURES_NV, VK_NV_SHADING_RATE_IMAGE_EXTENSION_NAME, VK_NV_SHADING_RATE_IMAGE_SPEC_VERSION, 10}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SUBGROUP_SIZE_CONTROL_FEATURES_EXT, VK_EXT_SUBGROUP_SIZE_CONTROL_EXTENSION_NAME, VK_EXT_SUBGROUP_SIZE_CONTROL_SPEC_VERSION, 9}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TEXEL_BUFFER_ALIGNMENT_FEATURES_EXT, VK_EXT_TEXEL_BUFFER_ALIGNMENT_EXTENSION_NAME, VK_EXT_TEXEL_BUFFER_ALIGNMENT_SPEC_VERSION, 8}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceTimelineSemaphoreFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES, VK_KHR_TIMELINE_SEMAPHORE_EXTENSION_NAME, VK_KHR_TIMELINE_SEMAPHORE_SPEC_VERSION, 7}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceTransformFeedbackFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TRANSFORM_FEEDBACK_FEATURES_EXT, VK_EXT_TRANSFORM_FEEDBACK_EXTENSION_NAME, VK_EXT_TRANSFORM_FEEDBACK_SPEC_VERSION, 6}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES, VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_EXTENSION_NAME, VK_KHR_UNIFORM_BUFFER_STANDARD_LAYOUT_SPEC_VERSION, 5}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceVariablePointersFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES, VK_KHR_VARIABLE_POINTERS_EXTENSION_NAME, VK_KHR_VARIABLE_POINTERS_SPEC_VERSION, 4}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VERTEX_ATTRIBUTE_DIVISOR_FEATURES_EXT, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_EXTENSION_NAME, VK_EXT_VERTEX_ATTRIBUTE_DIVISOR_SPEC_VERSION, 3}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceVulkanMemoryModelFeatures>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES, VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME, VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION, 2}; }
+template<> FeatureDesc makeFeatureDesc<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>(void) { return FeatureDesc{VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_YCBCR_IMAGE_ARRAYS_FEATURES_EXT, VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME, VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION, 1}; }
+
+
+static const FeatureStructCreationData featureStructCreationArray[] =
{
{ createFeatureStructWrapper<VkPhysicalDevice16BitStorageFeatures>, VK_KHR_16BIT_STORAGE_EXTENSION_NAME, VK_KHR_16BIT_STORAGE_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDevice8BitStorageFeatures>, VK_KHR_8BIT_STORAGE_EXTENSION_NAME, VK_KHR_8BIT_STORAGE_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceVulkanMemoryModelFeatures>, VK_KHR_VULKAN_MEMORY_MODEL_EXTENSION_NAME, VK_KHR_VULKAN_MEMORY_MODEL_SPEC_VERSION },
{ createFeatureStructWrapper<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>, VK_EXT_YCBCR_IMAGE_ARRAYS_EXTENSION_NAME, VK_EXT_YCBCR_IMAGE_ARRAYS_SPEC_VERSION },
};
+
+bool isPartOfBlobFeatures (VkStructureType sType)
+{
+ const std::vector<VkStructureType> sTypeVect = {
+ // Vulkan11
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_16BIT_STORAGE_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_MULTIVIEW_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROTECTED_MEMORY_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SAMPLER_YCBCR_CONVERSION_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_DRAW_PARAMETERS_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VARIABLE_POINTERS_FEATURES,
+ // Vulkan12
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_8BIT_STORAGE_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_BUFFER_DEVICE_ADDRESS_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_HOST_QUERY_RESET_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_IMAGELESS_FRAMEBUFFER_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SCALAR_BLOCK_LAYOUT_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SEPARATE_DEPTH_STENCIL_LAYOUTS_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_ATOMIC_INT64_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_FLOAT16_INT8_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_SUBGROUP_EXTENDED_TYPES_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_TIMELINE_SEMAPHORE_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_UNIFORM_BUFFER_STANDARD_LAYOUT_FEATURES,
+ VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_VULKAN_MEMORY_MODEL_FEATURES,
+ };
+ return de::contains(sTypeVect.begin(), sTypeVect.end(), sType);
+}
+
} // vk
namespace vk
{
-static bool isPhysicalDeviceProperties2Supported (const deUint32 version, const std::vector<std::string>& instanceExtensions)
-{
- return isInstanceExtensionSupported(version, instanceExtensions, "VK_KHR_get_physical_device_properties2");
-}
-
DeviceProperties::DeviceProperties (const InstanceInterface& vki,
const deUint32 apiVersion,
const VkPhysicalDevice physicalDevice,
{
m_coreProperties2 = initVulkanStructure();
- if (isPhysicalDeviceProperties2Supported(apiVersion, instanceExtensions))
+ if (isInstanceExtensionSupported(apiVersion, instanceExtensions, "VK_KHR_get_physical_device_properties2"))
{
const std::vector<VkExtensionProperties> deviceExtensionProperties = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
void** nextPtr = &m_coreProperties2.pNext;
*/
bool checkMandatoryFeatures(const vkt::Context& context)
{
- if ( !vk::isInstanceExtensionSupported(context.getUsedApiVersion(), context.getInstanceExtensions(), "VK_KHR_get_physical_device_properties2") )
+ if (!context.isInstanceFunctionalitySupported("VK_KHR_get_physical_device_properties2"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_get_physical_device_properties2 is not present");
VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
return true;
}
-bool isInstanceExtensionSupported (const deUint32 instanceVersion, const std::vector<std::string>& extensions, const std::string& required)
-{
- if (isCoreInstanceExtension(instanceVersion, required))
- return true;
- else
- return de::contains(extensions.begin(), extensions.end(), required);
-}
-
-bool isDeviceExtensionSupported (const deUint32 deviceVersion, const std::vector<std::string>& extensions, const std::string& required)
-{
- if (isCoreDeviceExtension(deviceVersion, required))
- return true;
- else
- return de::contains(extensions.begin(), extensions.end(), required);
-}
-
-bool isInstanceExtensionSupported (const deUint32 instanceVersion, const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required)
-{
- if (isCoreInstanceExtension(instanceVersion, required.name))
- return true;
- else
- return isExtensionSupported(extensions.begin(), extensions.end(), required);
-}
-
-bool isDeviceExtensionSupported (const deUint32 deviceVersion, const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required)
-{
- if (isCoreDeviceExtension(deviceVersion, required.name))
- return true;
- else
- return isExtensionSupported(extensions.begin(), extensions.end(), required);
-}
-
bool isExtensionSupported (const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required)
{
return isExtensionSupported(extensions.begin(), extensions.end(), required);
return de::contains(extensionStrings.begin(), extensionStrings.end(), extensionName);
}
+bool isInstanceExtensionSupported(const deUint32 instanceVersion, const std::vector<std::string>& extensions, const std::string& required)
+{
+ // NOTE: this function is only needed in few cases during creation of context,
+ // dont use it, call Context::isInstanceFunctionalitySupported instead
+ if (isCoreInstanceExtension(instanceVersion, required))
+ return true;
+ return de::contains(extensions.begin(), extensions.end(), required);
+}
+
bool isLayerSupported (const std::vector<VkLayerProperties>& layers, const RequiredLayer& required)
{
return isLayerSupported(layers.begin(), layers.end(), required);
template<typename ExtensionIterator>
bool isExtensionSupported (ExtensionIterator begin, ExtensionIterator end, const RequiredExtension& required);
bool isExtensionSupported (const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required);
-bool isDeviceExtensionSupported (const deUint32 deviceVersion, const std::vector<std::string>& extensions, const std::string& required);
+
bool isInstanceExtensionSupported (const deUint32 instanceVersion, const std::vector<std::string>& extensions, const std::string& required);
-bool isDeviceExtensionSupported (const deUint32 deviceVersion, const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required);
-bool isInstanceExtensionSupported (const deUint32 instanceVersion, const std::vector<VkExtensionProperties>& extensions, const RequiredExtension& required);
template<typename LayerIterator>
bool isLayerSupported (LayerIterator begin, LayerIterator end, const RequiredLayer& required);
de::MovePtr<Allocation>& memory) const
{
DE_UNREF(allocator);
- const std::vector<std::string>& extensions = context.getDeviceExtensions();
- const deBool isSupported = isDeviceExtensionSupported(context.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
- if (!isSupported)
- {
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
TCU_THROW(NotSupportedError, "Not supported");
- }
const InstanceInterface& vkInstance = context.getInstanceInterface();
const VkDevice vkDevice = context.getDevice();
VkImageTiling tiling) const
{
DE_UNREF(allocator);
- const std::vector<std::string>& extensions = context.getDeviceExtensions();
- const deBool isSupported = isDeviceExtensionSupported(context.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
- if (!isSupported)
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
{
TCU_THROW(NotSupportedError, "Not supported");
}
virtual void checkSupport (Context& ctx) const
{
- const std::vector<std::string>& extensions = ctx.getDeviceExtensions();
- const deBool isSupported = isDeviceExtensionSupported(ctx.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
- if (!isSupported)
- {
+ if (!ctx.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
TCU_THROW(NotSupportedError, "Not supported");
- }
}
private:
BufferCaseParameters m_testCase;
TCU_THROW(NotSupportedError, "Format not supported");
if (m_testCase.bufferAllocationKind == ALLOCATION_KIND_DEDICATED)
{
- const std::vector<std::string>& extensions = ctx.getDeviceExtensions();
- const deBool isSupported = isDeviceExtensionSupported(ctx.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
- if (!isSupported)
+ if (!ctx.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
TCU_THROW(NotSupportedError, "Dedicated allocation not supported");
}
}
tcu::TestStatus trimCommandPoolTest (Context& context, const VkCommandBufferLevel cmdBufferLevel)
{
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_maintenance1"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
const VkDevice vkDevice = context.getDevice();
{
if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
{
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
}
if (m_params.separateDepthStencilLayouts)
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_separate_depth_stencil_layouts"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_separate_depth_stencil_layouts"))
TCU_THROW(NotSupportedError, "VK_KHR_separate_depth_stencil_layouts is not supported");
if ((m_params.dst.image.imageType == VK_IMAGE_TYPE_3D && m_params.src.image.imageType == VK_IMAGE_TYPE_2D) ||
(m_params.dst.image.imageType == VK_IMAGE_TYPE_2D && m_params.src.image.imageType == VK_IMAGE_TYPE_3D))
{
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_maintenance1"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance1 not supported");
}
{
const DeviceInterface& vkd = context.getDeviceInterface();
const VkDevice device = context.getDevice();
- const bool expectOutOfPoolMemoryError = isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1");
+ const bool expectOutOfPoolMemoryError = context.isDeviceFunctionalitySupported("VK_KHR_maintenance1");
deUint32 numErrorsReturned = 0;
const struct FailureCase
const VkDevice device = context.getDevice();
if (descriptorSetLayoutCreateFlags == VK_DESCRIPTOR_SET_LAYOUT_CREATE_PUSH_DESCRIPTOR_BIT_KHR)
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_push_descriptor"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_push_descriptor"))
TCU_THROW(NotSupportedError, "VK_KHR_push_descriptor extension not supported");
const VkDescriptorSetLayoutCreateInfo descriptorSetLayoutCreateInfo =
void checkSupport (Context& context, const TestType config)
{
DE_UNREF(config);
- context.requireDeviceExtension("VK_KHR_driver_properties");
+ context.requireDeviceFunctionality("VK_KHR_driver_properties");
}
void testDriverMatch (const VkPhysicalDeviceDriverPropertiesKHR& deviceDriverProperties)
void checkSupportKhrPushDescriptor (Context& context)
{
- context.requireDeviceExtension("VK_KHR_push_descriptor");
+ context.requireDeviceFunctionality("VK_KHR_push_descriptor");
}
tcu::TestStatus validateLimitsKhrPushDescriptor (Context& context)
void checkSupportKhrMultiview (Context& context)
{
- context.requireDeviceExtension("VK_KHR_multiview");
+ context.requireDeviceFunctionality("VK_KHR_multiview");
}
tcu::TestStatus validateLimitsKhrMultiview (Context& context)
void checkSupportExtDiscardRectangles (Context& context)
{
- context.requireDeviceExtension("VK_EXT_discard_rectangles");
+ context.requireDeviceFunctionality("VK_EXT_discard_rectangles");
}
tcu::TestStatus validateLimitsExtDiscardRectangles (Context& context)
void checkSupportExtSampleLocations (Context& context)
{
- context.requireDeviceExtension("VK_EXT_sample_locations");
+ context.requireDeviceFunctionality("VK_EXT_sample_locations");
}
tcu::TestStatus validateLimitsExtSampleLocations (Context& context)
void checkSupportExtExternalMemoryHost (Context& context)
{
- context.requireDeviceExtension("VK_EXT_external_memory_host");
+ context.requireDeviceFunctionality("VK_EXT_external_memory_host");
}
tcu::TestStatus validateLimitsExtExternalMemoryHost (Context& context)
void checkSupportExtBlendOperationAdvanced (Context& context)
{
- context.requireDeviceExtension("VK_EXT_blend_operation_advanced");
+ context.requireDeviceFunctionality("VK_EXT_blend_operation_advanced");
}
tcu::TestStatus validateLimitsExtBlendOperationAdvanced (Context& context)
void checkSupportKhrMaintenance3 (Context& context)
{
- context.requireDeviceExtension("VK_KHR_maintenance3");
+ context.requireDeviceFunctionality("VK_KHR_maintenance3");
}
tcu::TestStatus validateLimitsKhrMaintenance3 (Context& context)
void checkSupportExtConservativeRasterization (Context& context)
{
- context.requireDeviceExtension("VK_EXT_conservative_rasterization");
+ context.requireDeviceFunctionality("VK_EXT_conservative_rasterization");
}
tcu::TestStatus validateLimitsExtConservativeRasterization (Context& context)
void checkSupportExtInlineUniformBlock (Context& context)
{
- context.requireDeviceExtension("VK_EXT_inline_uniform_block");
+ context.requireDeviceFunctionality("VK_EXT_inline_uniform_block");
}
tcu::TestStatus validateLimitsExtInlineUniformBlock (Context& context)
void checkSupportExtVertexAttributeDivisor (Context& context)
{
- context.requireDeviceExtension("VK_EXT_vertex_attribute_divisor");
+ context.requireDeviceFunctionality("VK_EXT_vertex_attribute_divisor");
}
tcu::TestStatus validateLimitsExtVertexAttributeDivisor (Context& context)
void checkSupportExtTransformFeedback (Context& context)
{
- context.requireDeviceExtension("VK_EXT_transform_feedback");
+ context.requireDeviceFunctionality("VK_EXT_transform_feedback");
}
tcu::TestStatus validateLimitsExtTransformFeedback (Context& context)
void checkSupportExtFragmentDensityMap (Context& context)
{
- context.requireDeviceExtension("VK_EXT_fragment_density_map");
+ context.requireDeviceFunctionality("VK_EXT_fragment_density_map");
}
tcu::TestStatus validateLimitsExtFragmentDensityMap (Context& context)
void checkSupportKhrTimelineSemaphore (Context& context)
{
- context.requireDeviceExtension("VK_KHR_timeline_semaphore");
+ context.requireDeviceFunctionality("VK_KHR_timeline_semaphore");
}
tcu::TestStatus validateLimitsKhrTimelineSemaphore (Context& context)
void checkSupportExtLineRasterization (Context& context)
{
- context.requireDeviceExtension("VK_EXT_line_rasterization");
+ context.requireDeviceFunctionality("VK_EXT_line_rasterization");
}
tcu::TestStatus validateLimitsExtLineRasterization (Context& context)
TestLog& log = context.getTestContext().getLog();
deUint8 buffer[sizeof(VkPhysicalDeviceMemoryBudgetPropertiesEXT) + GUARD_SIZE];
- if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_memory_budget"))
+ if (!context.isDeviceFunctionalitySupported("VK_EXT_memory_budget"))
TCU_THROW(NotSupportedError, "VK_EXT_memory_budget is not supported");
VkPhysicalDeviceMemoryBudgetPropertiesEXT *budgetProps = reinterpret_cast<VkPhysicalDeviceMemoryBudgetPropertiesEXT *>(buffer);
if (!vk::isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_sampler_ycbcr_conversion"))
{
- if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_sampler_ycbcr_conversion"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_sampler_ycbcr_conversion"))
TCU_THROW(NotSupportedError, "VK_KHR_sampler_ycbcr_conversion is not supported");
// Hard dependency for ycbcr
const VkPhysicalDeviceFeatures& deviceFeatures = context.getDeviceFeatures();
const VkPhysicalDeviceLimits& deviceLimits = context.getDeviceProperties().limits;
const VkFormatProperties formatProperties = getPhysicalDeviceFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(), format);
- const bool hasKhrMaintenance1 = isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1");
+ const bool hasKhrMaintenance1 = context.isDeviceFunctionalitySupported("VK_KHR_maintenance1");
const VkFormatFeatureFlags supportedFeatures = tiling == VK_IMAGE_TILING_LINEAR ? formatProperties.linearTilingFeatures : formatProperties.optimalTilingFeatures;
const VkImageUsageFlags usageFlagSet = getValidImageUsageFlags(supportedFeatures, hasKhrMaintenance1);
// Instance extensions
{
- static const char* mandatoryExtensions[] =
+ static const string mandatoryExtensions[] =
{
"VK_KHR_get_physical_device_properties2",
};
- const vector<VkExtensionProperties> extensions = enumerateInstanceExtensionProperties(context.getPlatformInterface(), DE_NULL);
- for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(mandatoryExtensions); ++ndx)
+ for (const auto ext : mandatoryExtensions)
{
- if (!isInstanceExtensionSupported(context.getUsedApiVersion(), extensions, RequiredExtension(mandatoryExtensions[ndx])))
- results.fail(string(mandatoryExtensions[ndx]) + " is not supported");
+ if (!context.isInstanceFunctionalitySupported(ext))
+ results.fail(ext + " is not supported");
}
}
// Device extensions
{
- static const char* mandatoryExtensions[] =
+ static const string mandatoryExtensions[] =
{
"VK_KHR_maintenance1",
};
- const vector<VkExtensionProperties> extensions = enumerateDeviceExtensionProperties(context.getInstanceInterface(), context.getPhysicalDevice(), DE_NULL);
- for (int ndx = 0; ndx < DE_LENGTH_OF_ARRAY(mandatoryExtensions); ++ndx)
+ for (const auto ext : mandatoryExtensions)
{
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), extensions, RequiredExtension(mandatoryExtensions[ndx])))
- results.fail(string(mandatoryExtensions[ndx]) + " is not supported");
+ if (!context.isDeviceFunctionalitySupported(ext))
+ results.fail(ext + " is not supported");
}
}
, m_frameBuffer (m_isAttachmentFormat ? createFrameBuffer(*m_imageView, *m_renderPass, params.imageExtent.width, params.imageExtent.height, params.imageViewLayerRange.layerCount) : vk::Move<vk::VkFramebuffer>())
{
if (m_params.allocationKind == ALLOCATION_KIND_DEDICATED)
- context.requireDeviceExtension("VK_KHR_dedicated_allocation");
+ context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
if (m_params.separateDepthStencilLayoutMode != SEPARATE_DEPTH_STENCIL_LAYOUT_MODE_NONE)
- context.requireDeviceExtension("VK_KHR_separate_depth_stencil_layouts");
+ context.requireDeviceFunctionality("VK_KHR_separate_depth_stencil_layouts");
}
ImageClearingTestInstance::ViewType ImageClearingTestInstance::getViewType (deUint32 imageLayerCount) const
{}
virtual void checkSupport (Context& ctx) const
{
- ctx.requireDeviceExtension("VK_KHR_maintenance3");
+ ctx.requireDeviceFunctionality("VK_KHR_maintenance3");
}
virtual TestInstance* createInstance (Context& ctx) const
{
{}
virtual void checkSupport (Context& ctx) const
{
- ctx.requireDeviceExtension("VK_KHR_maintenance3");
+ ctx.requireDeviceFunctionality("VK_KHR_maintenance3");
}
virtual TestInstance* createInstance (Context& ctx) const
{
size_t refSizes[testCycles];
unsigned int order[testCycles];
bool success = true;
- const std::vector<std::string>& extensions = m_context.getDeviceExtensions();
- const deBool isDedicatedAllocationSupported =
- isDeviceExtensionSupported(m_context.getUsedApiVersion(), extensions, "VK_KHR_dedicated_allocation");
- const deBool isYcbcrSupported =
- isDeviceExtensionSupported(m_context.getUsedApiVersion(), extensions, "VK_KHR_sampler_ycbcr_conversion");
+ const deBool isDedicatedAllocationSupported = m_context.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation");
+ const deBool isYcbcrSupported = m_context.isDeviceFunctionalitySupported("VK_KHR_sampler_ycbcr_conversion");
std::vector<int> optimalFormats;
std::vector<int> linearFormats;
std::vector<int> memoryTypes;
inline bool hasDeviceExtension (Context& context, const string name)
{
- return isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), name);
+ return context.isDeviceFunctionalitySupported(name);
}
VkDeviceSize getPageTableSize (const PlatformMemoryLimits& limits, VkDeviceSize allocationSize)
{
vector<const char*> extensionNamePtrs;
const vector<VkExtensionProperties> instanceExts = enumerateInstanceExtensionProperties(env.vkp, DE_NULL);
- for (size_t extensionID = 0; extensionID < params.instanceExtensions.size(); extensionID++)
+ for (const auto& extName : params.instanceExtensions)
{
- if (!isInstanceExtensionSupported(env.apiVersion, instanceExts, RequiredExtension(params.instanceExtensions[extensionID])))
- TCU_THROW(NotSupportedError, (params.instanceExtensions[extensionID] + " is not supported").c_str());
+ bool extNotInCore = !isCoreInstanceExtension(env.apiVersion, extName);
+ if (extNotInCore && !isExtensionSupported(instanceExts.begin(), instanceExts.end(), RequiredExtension(extName)))
+ TCU_THROW(NotSupportedError, (extName + " is not supported").c_str());
- if (!isCoreInstanceExtension(env.apiVersion, params.instanceExtensions[extensionID]))
- extensionNamePtrs.push_back(params.instanceExtensions[extensionID].c_str());
+ if (extNotInCore)
+ extensionNamePtrs.push_back(extName.c_str());
}
const VkApplicationInfo appInfo =
if (m_data.set >= context.getDeviceProperties().limits.maxBoundDescriptorSets)
TCU_THROW(NotSupportedError, "descriptor set number not supported");
- if (m_data.bufType == BT_REPLAY && !context.isBufferDeviceAddressWithCaptureReplaySupported())
+ bool isBufferDeviceAddressWithCaptureReplaySupported =
+ (context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address") && context.getBufferDeviceAddressFeatures().bufferDeviceAddressCaptureReplay) ||
+ (context.isDeviceFunctionalitySupported("VK_EXT_buffer_device_address") && context.getBufferDeviceAddressFeaturesEXT().bufferDeviceAddressCaptureReplay);
+ if (m_data.bufType == BT_REPLAY && !isBufferDeviceAddressWithCaptureReplaySupported)
TCU_THROW(NotSupportedError, "Capture/replay of physical storage buffer pointers not supported");
if (m_data.layout == LAYOUT_SCALAR && !context.getScalarBlockLayoutFeatures().scalarBlockLayout)
#if ENABLE_RAYTRACING
if (m_data.stage == STAGE_RAYGEN &&
- !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_NV_ray_tracing"))
+ !context.isDeviceFunctionalitySupported("VK_NV_ray_tracing"))
{
TCU_THROW(NotSupportedError, "Ray tracing not supported");
}
if (m_data.convertUToPtr == CONVERT_UTOPTR && !context.getDeviceFeatures().shaderInt64)
TCU_THROW(NotSupportedError, "Int64 not supported");
- if (m_data.convertUToPtr == CONVERT_UVEC2 && !context.isBufferDeviceAddressKHRSupported())
+ if (m_data.convertUToPtr == CONVERT_UVEC2 && !context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address"))
TCU_THROW(NotSupportedError, "VK_KHR_buffer_device_address not supported");
}
const VkPhysicalDevice& physDevice = m_context.getPhysicalDevice();
const VkDevice device = m_context.getDevice();
Allocator& allocator = m_context.getDefaultAllocator();
- const bool useKHR = m_context.isBufferDeviceAddressKHRSupported();
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
VkFlags allShaderStages = VK_SHADER_STAGE_COMPUTE_BIT | VK_SHADER_STAGE_VERTEX_BIT | VK_SHADER_STAGE_FRAGMENT_BIT;
deMemset(&rayTracingProperties, 0, sizeof(rayTracingProperties));
rayTracingProperties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_RAY_TRACING_PROPERTIES_NV;
- if (isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_NV_ray_tracing"))
+ if (context.isDeviceFunctionalitySupported("VK_NV_ray_tracing")))
{
properties.pNext = &rayTracingProperties;
}
deUint32 seed;
};
+static void getNeededFeatures(const Context& context,
+ VkPhysicalDeviceFeatures2& features,
+ VkPhysicalDeviceInlineUniformBlockFeaturesEXT& inlineUniformFeatures,
+ VkPhysicalDeviceDescriptorIndexingFeatures& indexingFeatures)
+{
+ inlineUniformFeatures = initVulkanStructure();
+ indexingFeatures = initVulkanStructure();
+ features = initVulkanStructure();
+
+ void** nextPtr = &features.pNext;
+ if (context.isDeviceFunctionalitySupported("VK_EXT_descriptor_indexing"))
+ addToChainVulkanStructure(&nextPtr, indexingFeatures);
+ if (context.isDeviceFunctionalitySupported("VK_EXT_inline_uniform_block"))
+ addToChainVulkanStructure(&nextPtr, inlineUniformFeatures);
+
+ context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &features);
+}
class RandomLayout
{
deMemset(&properties, 0, sizeof(properties));
properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_inline_uniform_block"))
+ if (context.isDeviceFunctionalitySupported("VK_EXT_inline_uniform_block"))
{
properties.pNext = &inlineUniformProperties;
}
context.getInstanceInterface().getPhysicalDeviceProperties2(context.getPhysicalDevice(), &properties);
- VkPhysicalDeviceInlineUniformBlockFeaturesEXT inlineUniformFeatures;
- deMemset(&inlineUniformFeatures, 0, sizeof(inlineUniformFeatures));
- inlineUniformFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT;
-
- VkPhysicalDeviceDescriptorIndexingFeatures indexingFeatures;
- deMemset(&indexingFeatures, 0, sizeof(indexingFeatures));
- indexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES;
-
VkPhysicalDeviceFeatures2 features;
- deMemset(&features, 0, sizeof(features));
- features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-
- const bool descriptorIndexing = context.isDescriptorIndexingSupported();
-
- if (descriptorIndexing &&
- isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_inline_uniform_block"))
- {
- indexingFeatures.pNext = &inlineUniformFeatures;
- features.pNext = &indexingFeatures;
- }
- else if (descriptorIndexing)
- {
- features.pNext = &indexingFeatures;
- }
- else if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_inline_uniform_block"))
- {
- features.pNext = &inlineUniformFeatures;
- }
+ VkPhysicalDeviceDescriptorIndexingFeatures indexingFeatures;
+ VkPhysicalDeviceInlineUniformBlockFeaturesEXT inlineUniformFeatures;
+ getNeededFeatures(context, features, inlineUniformFeatures, indexingFeatures);
context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &features);
if (m_data.stage == STAGE_VERTEX && !features.features.vertexPipelineStoresAndAtomics)
RandomLayout randomLayout(m_data.numDescriptorSets);
generateRandomLayout(randomLayout, m_data);
-
VkPhysicalDeviceProperties2 properties;
deMemset(&properties, 0, sizeof(properties));
properties.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_PROPERTIES_2;
m_context.getInstanceInterface().getPhysicalDeviceProperties2(m_context.getPhysicalDevice(), &properties);
+ VkPhysicalDeviceFeatures2 features;
VkPhysicalDeviceInlineUniformBlockFeaturesEXT inlineUniformFeatures;
- deMemset(&inlineUniformFeatures, 0, sizeof(inlineUniformFeatures));
- inlineUniformFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_INLINE_UNIFORM_BLOCK_FEATURES_EXT;
-
VkPhysicalDeviceDescriptorIndexingFeatures indexingFeatures;
- deMemset(&indexingFeatures, 0, sizeof(indexingFeatures));
- indexingFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_DESCRIPTOR_INDEXING_FEATURES_EXT;
-
- VkPhysicalDeviceFeatures2 features;
- deMemset(&features, 0, sizeof(features));
- features.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
-
- const bool descriptorIndexing = m_context.isDescriptorIndexingSupported();
-
- if (descriptorIndexing &&
- isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_EXT_inline_uniform_block"))
- {
- indexingFeatures.pNext = &inlineUniformFeatures;
- features.pNext = &indexingFeatures;
- }
- else if (descriptorIndexing)
- {
- features.pNext = &indexingFeatures;
- }
- else if (isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_EXT_inline_uniform_block"))
- {
- features.pNext = &inlineUniformFeatures;
- }
-
- m_context.getInstanceInterface().getPhysicalDeviceFeatures2(m_context.getPhysicalDevice(), &features);
+ getNeededFeatures(m_context, features, inlineUniformFeatures, indexingFeatures);
deRandom rnd;
deRandom_init(&rnd, m_data.seed);
if (binding.descriptorType == VK_DESCRIPTOR_TYPE_INLINE_UNIFORM_BLOCK_EXT)
{
- VkWriteDescriptorSetInlineUniformBlockEXT inlineUniformBlock =
+ VkWriteDescriptorSetInlineUniformBlockEXT iuBlock =
{
VK_STRUCTURE_TYPE_WRITE_DESCRIPTOR_SET_INLINE_UNIFORM_BLOCK_EXT, // VkStructureType sType;
DE_NULL, // const void* pNext;
&descriptorNumber[descriptor], // const void* pData;
};
- inlineInfoVec[vecIndex] = inlineUniformBlock;
+ inlineInfoVec[vecIndex] = iuBlock;
w.dstArrayElement = ai*16 + 16; // add 16 to skip "ivec4 dummy"
w.pNext = &inlineInfoVec[vecIndex];
w.descriptorCount = sizeof(deUint32);
bool pointClippingOutside = true;
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_maintenance2"))
{
VkPointClippingBehavior clippingBehavior = getClippingBehavior(context.getInstanceInterface(), context.getPhysicalDevice());
const VkDevice device = m_context.getDevice();
Allocator& allocator = m_context.getDefaultAllocator();
MemoryRequirement memoryDeviceAddress = m_data.storageClass == SC_PHYSICAL_STORAGE_BUFFER &&
- m_context.isBufferDeviceAddressKHRSupported() ? MemoryRequirement::DeviceAddress : MemoryRequirement::Any;
+ m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address") ? MemoryRequirement::DeviceAddress : MemoryRequirement::Any;
deRandom rnd;
deRandom_init(&rnd, 1234);
vk::DescriptorSetUpdateBuilder setUpdateBuilder;
if (m_data.storageClass == SC_PHYSICAL_STORAGE_BUFFER)
{
- const bool useKHR = m_context.isBufferDeviceAddressKHRSupported();
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
VkBufferDeviceAddressInfo info =
{
void checkSupport (Context& context)
{
- context.requireDeviceExtension("VK_EXT_conditional_rendering");
+ context.requireDeviceFunctionality("VK_EXT_conditional_rendering");
}
} // unnamed namespace
void checkConditionalRenderingCapabilities (vkt::Context& context, const ConditionalData& data)
{
- if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_conditional_rendering"))
+ if (!context.isDeviceFunctionalitySupported("VK_EXT_conditional_rendering"))
TCU_THROW(NotSupportedError, "Missing extension: VK_EXT_conditional_rendering");
if (data.conditionInherited)
virtual void checkSupport (vkt::Context& context) const
{
- if (!context.isDescriptorIndexingSupported())
+ if (!context.isDeviceFunctionalitySupported("VK_EXT_descriptor_indexing"))
TCU_THROW(NotSupportedError, "Descriptor indexing is not supported");
const vk::VkPhysicalDeviceDescriptorIndexingFeaturesEXT& feats = context.getDescriptorIndexingFeatures();
void DeviceGroupTestInstance::init (void)
{
- if (!isInstanceExtensionSupported(m_context.getUsedApiVersion(), m_context.getInstanceExtensions(), "VK_KHR_device_group_creation"))
+ if (!m_context.isInstanceFunctionalitySupported("VK_KHR_device_group_creation"))
TCU_THROW(NotSupportedError, "Device Group tests are not supported, no device group extension present.");
const InstanceInterface& instanceInterface = m_context.getInstanceInterface();
vector<string> deviceExtensions;
vector<string> enabledLayers;
- if (!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_KHR_device_group"))
+ if (!m_context.isDeviceFunctionalitySupported("VK_KHR_device_group"))
TCU_THROW(NotSupportedError, "Missing extension: VK_KHR_device_group");
if (!isCoreDeviceExtension(m_context.getUsedApiVersion(), "VK_KHR_device_group"))
if(m_useDedicated)
{
- if (!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ if (!m_context.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
TCU_THROW(NotSupportedError, "Missing extension: VK_KHR_dedicated_allocation");
if (!isCoreDeviceExtension(m_context.getUsedApiVersion(), "VK_KHR_dedicated_allocation"))
void DiscardRectanglesTestCase::checkSupport (Context& context) const
{
- context.requireDeviceExtension("VK_EXT_discard_rectangles");
+ context.requireDeviceFunctionality("VK_EXT_discard_rectangles");
}
TestInstance* DiscardRectanglesTestCase::createInstance (Context& context) const
if (context.contextSupports(vk::ApiVersion(1, 2, 0)) && !vk::getPhysicalDeviceVulkan12Features(context.getInstanceInterface(), context.getPhysicalDevice()).drawIndirectCount)
TCU_THROW(NotSupportedError, "drawIndirectCount is not supported");
else
- context.requireDeviceExtension("VK_KHR_draw_indirect_count");
+ context.requireDeviceFunctionality("VK_KHR_draw_indirect_count");
}
} // anonymous
{
if (m_params.testAttribDivisor)
{
- context.requireDeviceExtension("VK_EXT_vertex_attribute_divisor");
+ context.requireDeviceFunctionality("VK_EXT_vertex_attribute_divisor");
const vk::VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT& vertexAttributeDivisorFeatures = context.getVertexAttributeDivisorFeaturesEXT();
if (m_params.testMultiview)
{
- context.requireDeviceExtension("VK_KHR_multiview");
+ context.requireDeviceFunctionality("VK_KHR_multiview");
const vk::VkPhysicalDeviceMultiviewFeatures& multiviewFeatures = context.getMultiviewFeatures();
context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_DEPTH_CLAMP);
if (m_params.minDepth > 1.0f || m_params.minDepth < 0.0f || m_params.maxDepth > 1.0f || m_params.maxDepth < 0.0f)
- context.requireDeviceExtension("VK_EXT_depth_range_unrestricted");
+ context.requireDeviceFunctionality("VK_EXT_depth_range_unrestricted");
}
virtual TestInstance* createInstance (Context& context) const
virtual void checkSupport (Context& context) const
{
- context.requireDeviceExtension("VK_KHR_maintenance1");
+ context.requireDeviceFunctionality("VK_KHR_maintenance1");
}
virtual TestInstance* createInstance (Context& context) const
void checkSupport (Context& context, TestFlags flags)
{
- context.requireDeviceExtension("VK_KHR_shader_draw_parameters");
+ context.requireDeviceFunctionality("VK_KHR_shader_draw_parameters");
// Shader draw parameters is part of Vulkan 1.1 but is optional
if (context.contextSupports(vk::ApiVersion(1, 1, 0)) )
void checkRequirements (Context& context, const int)
{
context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_MULTI_VIEWPORT);
- if (context.contextSupports(1, 2, 0))
- {
- if (!getPhysicalDeviceVulkan12Features(context.getInstanceInterface(), context.getPhysicalDevice()).shaderOutputLayer)
- TCU_THROW(NotSupportedError, "Required Vulkan 1.2 feature is not supported: shaderOutputLayer");
- }
- else
- context.requireDeviceExtension("VK_EXT_shader_viewport_index_layer");
+ context.requireDeviceFunctionality("VK_EXT_shader_viewport_index_layer");
const VkPhysicalDeviceLimits limits = context.getDeviceProperties().limits;
void checkSupportVertex (Context& context, const int)
{
context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_MULTI_VIEWPORT);
- if (context.contextSupports(1, 2, 0))
- {
- if (!getPhysicalDeviceVulkan12Features(context.getInstanceInterface(), context.getPhysicalDevice()).shaderOutputViewportIndex)
- TCU_THROW(NotSupportedError, "Required Vulkan 1.2 feature is not supported: shaderOutputViewportIndex");
- }
- else
- context.requireDeviceExtension("VK_EXT_shader_viewport_index_layer");
+ context.requireDeviceFunctionality("VK_EXT_shader_viewport_index_layer");
if (context.getDeviceProperties().limits.maxViewports < MIN_MAX_VIEWPORTS)
TCU_FAIL("multiViewport supported but maxViewports is less than the minimum required");
void FSITestCase::checkSupport(Context& context) const
{
- context.requireDeviceExtension("VK_EXT_fragment_shader_interlock");
+ context.requireDeviceFunctionality("VK_EXT_fragment_shader_interlock");
if ((m_data.interlock == INT_SAMPLE_ORDERED || m_data.interlock == INT_SAMPLE_UNORDERED) &&
!context.getFragmentShaderInterlockFeaturesEXT().fragmentShaderSampleInterlock)
context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER);
if (params.image.viewType == VK_IMAGE_VIEW_TYPE_3D)
- context.requireDeviceExtension("VK_KHR_maintenance1");
+ context.requireDeviceFunctionality("VK_KHR_maintenance1");
if (params.testType == TEST_TYPE_SECONDARY_CMD_BUFFER)
context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_FRAGMENT_STORES_AND_ATOMICS);
const VkPhysicalDevice physicalDevice = context.getPhysicalDevice();
const InstanceInterface& vk = context.getInstanceInterface();
- context.requireDeviceExtension("VK_KHR_maintenance2");
+ context.requireDeviceFunctionality("VK_KHR_maintenance2");
{
VkImageFormatProperties imageFormatProperties;
context.getPhysicalDevice(),
m_format));
- if (!context.requireDeviceExtension("VK_KHR_spirv_1_4"))
+ if (!context.requireDeviceFunctionality("VK_KHR_spirv_1_4"))
TCU_THROW(NotSupportedError, "VK_KHR_spirv_1_4 not supported");
if ((m_texture.type() != IMAGE_TYPE_BUFFER) && !(formatProperties.optimalTilingFeatures & VK_FORMAT_FEATURE_STORAGE_IMAGE_BIT))
public:
UploadDownloadExecutor(Context& context, VkDevice device, VkQueue queue, deUint32 queueFamilyIndex, const CaseDef& caseSpec) :
m_caseDef(caseSpec),
- m_haveMaintenance2(isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2")),
+ m_haveMaintenance2(context.isDeviceFunctionalitySupported("VK_KHR_maintenance2")),
m_vk(context.getDeviceInterface()),
m_device(device),
m_queue(queue),
// If this is a VK_KHR_image_format_list test, check that the extension is supported
if (caseDef.isFormatListTest)
- context.requireDeviceExtension("VK_KHR_image_format_list");
+ context.requireDeviceFunctionality("VK_KHR_image_format_list");
// Check required features on the format for the required upload/download methods
VkFormatProperties imageFormatProps, viewFormatProps;
if ((viewFormatProps.optimalTilingFeatures & viewFormatFeatureFlags) != viewFormatFeatureFlags)
TCU_THROW(NotSupportedError, "View format doesn't support upload/download method");
- const bool haveMaintenance2 = isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2");
+ const bool haveMaintenance2 = context.isDeviceFunctionalitySupported("VK_KHR_maintenance2");
// We don't use the base image for anything other than transfer
// operations so there are no features to check. However, The Vulkan
void ImageTranscodingCase::checkSupport (Context& context) const
{
- context.requireDeviceExtension("VK_KHR_maintenance2");
+ context.requireDeviceFunctionality("VK_KHR_maintenance2");
if (!isFormatUsageFlagSupported(context, m_parameters.featuredFormat, m_parameters.testedImageUsageFeature))
TCU_THROW(NotSupportedError, "Test skipped due to feature is not supported by the format");
ColorImagelessTestInstance::ColorImagelessTestInstance (Context& context, const TestParameters& parameters)
: TestInstance (context)
- , m_extensions (context.requireDeviceExtension("VK_KHR_imageless_framebuffer"))
+ , m_extensions (context.requireDeviceFunctionality("VK_KHR_imageless_framebuffer"))
, m_imageExtent2D (makeExtent2D(32u, 32u))
, m_parameters (parameters)
, m_colorImageUsage (VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | VK_IMAGE_USAGE_TRANSFER_SRC_BIT)
DepthResolveImagelessTestInstance::DepthResolveImagelessTestInstance (Context& context, const TestParameters& parameters)
: DepthImagelessTestInstance (context, parameters)
{
- context.requireDeviceExtension("VK_KHR_depth_stencil_resolve");
+ context.requireDeviceFunctionality("VK_KHR_depth_stencil_resolve");
const InstanceInterface& vki = m_context.getInstanceInterface();
const VkPhysicalDevice physDevice = m_context.getPhysicalDevice();
virtual void checkSupport (Context& ctx) const
{
- ctx.requireDeviceExtension("VK_KHR_bind_memory2");
+ ctx.requireDeviceFunctionality("VK_KHR_bind_memory2");
if (m_params.usePriority && !ctx.getMemoryPriorityFeaturesEXT().memoryPriority)
TCU_THROW(NotSupportedError, "VK_EXT_memory_priority Not supported");
void checkSupport (Context& context)
{
- context.requireDeviceExtension("VK_EXT_external_memory_host");
+ context.requireDeviceFunctionality("VK_EXT_external_memory_host");
}
} // unnamed namespace
if (config.allocationKind == ALLOCATION_KIND_DEDICATED_IMAGE
|| config.allocationKind == ALLOCATION_KIND_DEDICATED_BUFFER)
{
- context.requireDeviceExtension("VK_KHR_dedicated_allocation");
+ context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
}
}
{
checkSupportBufferMemoryRequirementsOriginal(context, flags);
- context.requireDeviceExtension("VK_KHR_get_memory_requirements2");
+ context.requireDeviceFunctionality("VK_KHR_get_memory_requirements2");
}
void BufferMemoryRequirementsExtended::addFunctionTestCase (tcu::TestCaseGroup* group,
{
checkSupportBufferMemoryRequirementsExtended(context, flags);
- context.requireDeviceExtension("VK_KHR_dedicated_allocation");
+ context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
}
void BufferMemoryRequirementsDedicatedAllocation::addFunctionTestCase (tcu::TestCaseGroup* group,
const VkPhysicalDeviceMemoryProperties& deviceMemoryProperties);
private:
- virtual bool isImageSupported (const deUint32 apiVersion,
+ virtual bool isImageSupported (const Context& context,
const InstanceInterface& vki,
const VkPhysicalDevice physDevice,
- const std::vector<std::string>& deviceExtensions,
const VkImageCreateInfo& info);
virtual bool isFormatMatchingAspect (const VkFormat format,
}
//! This catches both invalid as well as legal but unsupported combinations of image parameters
-bool ImageMemoryRequirementsOriginal::isImageSupported (const deUint32 apiVersion, const InstanceInterface& vki, const VkPhysicalDevice physDevice, const std::vector<std::string>& deviceExtensions, const VkImageCreateInfo& info)
+bool ImageMemoryRequirementsOriginal::isImageSupported (const Context& context, const InstanceInterface& vki, const VkPhysicalDevice physDevice, const VkImageCreateInfo& info)
{
DE_ASSERT(info.extent.width >= 1u && info.extent.height >= 1u && info.extent.depth >= 1u);
|| info.mipLevels != 1
|| info.arrayLayers != 1
|| info.samples != VK_SAMPLE_COUNT_1_BIT))
- || !isDeviceExtensionSupported(apiVersion, deviceExtensions, "VK_KHR_sampler_ycbcr_conversion"))
+ || !context.isDeviceFunctionalitySupported("VK_KHR_sampler_ycbcr_conversion"))
{
return false;
}
m_currentTestImageInfo = imageInfo;
- if (!isImageSupported(context.getUsedApiVersion(), vki, physDevice, context.getDeviceExtensions(), m_currentTestImageInfo))
+ if (!isImageSupported(context, vki, physDevice, m_currentTestImageInfo))
continue;
log << tcu::TestLog::Message << "- " << getImageInfoString(m_currentTestImageInfo) << tcu::TestLog::EndMessage;
{
checkSupportImageMemoryRequirementsOriginal(context, params);
- context.requireDeviceExtension("VK_KHR_get_memory_requirements2");
+ context.requireDeviceFunctionality("VK_KHR_get_memory_requirements2");
}
void ImageMemoryRequirementsExtended::addFunctionTestCase (tcu::TestCaseGroup* group,
{
checkSupportImageMemoryRequirementsExtended(context, params);
- context.requireDeviceExtension("VK_KHR_dedicated_allocation");
+ context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
}
void ImageMemoryRequirementsDedicatedAllocation::addFunctionTestCase (tcu::TestCaseGroup* group,
{
checkSupportImageMemoryRequirementsOriginal(context, params);
- context.requireDeviceExtension("VK_KHR_get_memory_requirements2");
- context.requireDeviceExtension("VK_KHR_sampler_ycbcr_conversion");
+ context.requireDeviceFunctionality("VK_KHR_get_memory_requirements2");
+ context.requireDeviceFunctionality("VK_KHR_sampler_ycbcr_conversion");
}
void populateMultiplaneTestGroup (tcu::TestCaseGroup* group)
if (m_data.payloadSC == SC_PHYSBUFFER)
{
usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
- if (m_context.isBufferDeviceAddressKHRSupported())
+ if (m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address"))
memoryDeviceAddress = true;
}
break;
if (m_data.guardSC == SC_PHYSBUFFER)
{
usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
- if (m_context.isBufferDeviceAddressKHRSupported())
+ if (m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address"))
memoryDeviceAddress = true;
}
break;
if (m_data.payloadSC == SC_PHYSBUFFER)
{
- const bool useKHR = m_context.isBufferDeviceAddressKHRSupported();
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
addrInfo.buffer = **buffers[0];
VkDeviceAddress addr;
if (useKHR)
}
if (m_data.guardSC == SC_PHYSBUFFER)
{
- const bool useKHR = m_context.isBufferDeviceAddressKHRSupported();
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
addrInfo.buffer = **buffers[1];
VkDeviceAddress addr;
if (useKHR)
MultiViewRenderTestInstance::MultiViewRenderTestInstance (Context& context, const TestParameters& parameters)
: TestInstance (context)
- , m_extensionSupported ((parameters.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2"))
+ , m_extensionSupported ((parameters.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceFunctionality("VK_KHR_create_renderpass2"))
, m_parameters (fillMissingParameters(parameters))
, m_seed (context.getTestContext().getCommandLine().getBaseSeed())
, m_squareCount (4u)
virtual void checkSupport (Context& context) const
{
- context.requireDeviceExtension("VK_KHR_multiview");
+ context.requireDeviceFunctionality("VK_KHR_multiview");
}
void initPrograms (SourceCollections& programCollection) const
const CacheTestParam* param)
: TestInstance (context)
, m_param (param)
- , m_extensions (m_context.requireDeviceExtension("VK_EXT_pipeline_creation_feedback"))
+ , m_extensions (m_context.requireDeviceFunctionality("VK_EXT_pipeline_creation_feedback"))
{
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
const DepthRangeUnrestrictedParam param)
: TestInstance (context)
, m_param (param)
- , m_extensions (m_context.requireDeviceExtension("VK_EXT_depth_range_unrestricted"))
+ , m_extensions (m_context.requireDeviceFunctionality("VK_EXT_depth_range_unrestricted"))
, m_renderSize (tcu::UVec2(32,32))
, m_colorFormat (VK_FORMAT_R8G8B8A8_UNORM)
, m_shaderStageCount (0)
if (!isSupportedDepthStencilFormat(context.getInstanceInterface(), context.getPhysicalDevice(), m_depthFormat))
throw tcu::NotSupportedError(std::string("Unsupported depth/stencil format: ") + getFormatName(m_depthFormat));
- if (m_separateDepthStencilLayouts && !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_separate_depth_stencil_layouts"))
+ if (m_separateDepthStencilLayouts && !context.isDeviceFunctionalitySupported("VK_KHR_separate_depth_stencil_layouts"))
TCU_THROW(NotSupportedError, "VK_KHR_separate_depth_stencil_layouts is not supported");
}
const ExecutablePropertiesTestParam* param)
: TestInstance (context)
, m_param (param)
- , m_extensions (m_context.requireDeviceExtension("VK_KHR_pipeline_executable_properties"))
+ , m_extensions (m_context.requireDeviceFunctionality("VK_KHR_pipeline_executable_properties"))
{
const DeviceInterface& vk = m_context.getDeviceInterface();
const VkDevice vkDevice = m_context.getDevice();
if (params.separateStencilUsage)
{
- context.requireDeviceExtension("VK_EXT_separate_stencil_usage");
- context.requireInstanceExtension("VK_KHR_get_physical_device_properties2");
+ context.requireDeviceFunctionality("VK_EXT_separate_stencil_usage");
+ context.requireInstanceFunctionality("VK_KHR_get_physical_device_properties2");
const VkImageStencilUsageCreateInfo stencilUsage =
{
if (nextType == VK_STRUCTURE_TYPE_SAMPLER_REDUCTION_MODE_CREATE_INFO_EXT)
{
- if (context.contextSupports(1, 2, 0))
- {
- if (!getPhysicalDeviceVulkan12Features(context.getInstanceInterface(), context.getPhysicalDevice()).samplerFilterMinmax)
- TCU_THROW(NotSupportedError, "Required Vulkan 1.2 feature is not supported: samplerFilterMinmax");
- }
- else
- context.requireDeviceExtension("VK_EXT_sampler_filter_minmax");
+ context.requireDeviceFunctionality("VK_EXT_sampler_filter_minmax");
if (!isMinMaxFilteringSupported(context.getInstanceInterface(), context.getPhysicalDevice(), params.imageFormat, VK_IMAGE_TILING_OPTIMAL))
throw tcu::NotSupportedError(std::string("Unsupported format for min/max filtering: ") + getFormatName(params.imageFormat));
params.samplerParams.addressModeV == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE ||
params.samplerParams.addressModeW == VK_SAMPLER_ADDRESS_MODE_MIRROR_CLAMP_TO_EDGE)
{
- if (context.contextSupports(1, 2, 0))
- {
- if (!getPhysicalDeviceVulkan12Features(context.getInstanceInterface(), context.getPhysicalDevice()).samplerMirrorClampToEdge)
- TCU_THROW(NotSupportedError, "Required Vulkan 1.2 feature is not supported: samplerMirrorClampToEdge");
- }
- else
- context.requireDeviceExtension("VK_KHR_sampler_mirror_clamp_to_edge");
+ context.requireDeviceFunctionality("VK_KHR_sampler_mirror_clamp_to_edge");
}
if ((isCompressedFormat(params.imageFormat) || isDepthStencilFormat(params.imageFormat)) && params.imageViewType == VK_IMAGE_VIEW_TYPE_3D)
context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_IMAGE_CUBE_ARRAY);
if (params.allocationKind == ALLOCATION_KIND_DEDICATED)
- context.requireDeviceExtension("VK_KHR_dedicated_allocation");
+ context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
}
ImageSamplingInstance::ImageSamplingInstance (Context& context,
void InputAssemblyTest::checkSupport (Context& context) const
{
if (m_indexType == VK_INDEX_TYPE_UINT8_EXT)
- context.requireDeviceExtension("VK_EXT_index_type_uint8");
+ context.requireDeviceFunctionality("VK_EXT_index_type_uint8");
switch (m_primitiveTopology)
{
void checkSupportSampleLocations (Context& context)
{
- context.requireDeviceExtension("VK_EXT_sample_locations");
+ context.requireDeviceFunctionality("VK_EXT_sample_locations");
}
std::string getString (const VkSampleCountFlagBits sampleCount)
if (!context.getDeviceProperties().limits.standardSampleLocations)
TCU_THROW(NotSupportedError, "standardSampleLocations required");
- context.requireDeviceExtension("VK_EXT_post_depth_coverage");
+ context.requireDeviceFunctionality("VK_EXT_post_depth_coverage");
}
void SampleMaskWithDepthTestTest::initPrograms (SourceCollections& programCollection) const
void checkImageViewTypeRequirements (Context& context, const VkImageViewType viewType)
{
if (viewType == VK_IMAGE_VIEW_TYPE_3D)
- context.requireDeviceExtension("VK_KHR_maintenance1");
+ context.requireDeviceFunctionality("VK_KHR_maintenance1");
if (viewType == VK_IMAGE_VIEW_TYPE_CUBE_ARRAY)
context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_IMAGE_CUBE_ARRAY);
checkImageViewTypeRequirements(context, caseDef.viewType);
if (caseDef.allocationKind == ALLOCATION_KIND_DEDICATED)
- context.requireDeviceExtension("VK_KHR_dedicated_allocation");
+ context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
if (caseDef.depthStencilFormat != VK_FORMAT_UNDEFINED && !isDepthStencilFormatSupported(context.getInstanceInterface(), context.getPhysicalDevice(), caseDef.depthStencilFormat))
TCU_THROW(NotSupportedError, "Unsupported depth/stencil format");
checkImageViewTypeRequirements(context, caseDef.viewType);
if (caseDef.allocationKind == ALLOCATION_KIND_DEDICATED)
- context.requireDeviceExtension("VK_KHR_dedicated_allocation");
+ context.requireDeviceFunctionality("VK_KHR_dedicated_allocation");
if (caseDef.depthStencilFormat != VK_FORMAT_UNDEFINED && !isDepthStencilFormatSupported(context.getInstanceInterface(), context.getPhysicalDevice(), caseDef.depthStencilFormat))
TCU_THROW(NotSupportedError, "Unsupported depth/stencil format");
void checkSupport (Context& context)
{
- context.requireDeviceExtension("VK_EXT_shader_stencil_export");
+ context.requireDeviceFunctionality("VK_EXT_shader_stencil_export");
const VkFormat stencilFormat = VK_FORMAT_S8_UINT;
if (!isSupportedDepthStencilFormat(context.getInstanceInterface(), context.getPhysicalDevice(), stencilFormat))
if (!isSupportedDepthStencilFormat(context.getInstanceInterface(), context.getPhysicalDevice(), m_stencilFormat))
throw tcu::NotSupportedError(std::string("Unsupported depth/stencil format: ") + getFormatName(m_stencilFormat));
- if (m_separateDepthStencilLayouts && !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_separate_depth_stencil_layouts"))
+ if (m_separateDepthStencilLayouts && !context.isDeviceFunctionalitySupported("VK_KHR_separate_depth_stencil_layouts"))
TCU_THROW(NotSupportedError, "VK_KHR_separate_depth_stencil_layouts is not supported");
}
if (m_hostQueryReset)
{
// Check VK_EXT_host_query_reset is supported
- context.requireDeviceExtension("VK_EXT_host_query_reset");
+ context.requireDeviceFunctionality("VK_EXT_host_query_reset");
if(context.getHostQueryResetFeatures().hostQueryReset == VK_FALSE)
throw tcu::NotSupportedError("Implementation doesn't support resetting queries from the host");
template <class T>
void CalibratedTimestampTest<T>::checkSupport (Context& context) const
{
- context.requireDeviceExtension("VK_EXT_calibrated_timestamps");
+ context.requireDeviceFunctionality("VK_EXT_calibrated_timestamps");
}
CalibratedTimestampTestInstance::CalibratedTimestampTestInstance (Context& context)
const Extensions supportedExtensions(vk::enumerateInstanceExtensionProperties(vkp, DE_NULL));
std::vector<std::string> requiredExtensions = extraExtensions;
- if (!isCoreInstanceExtension(context.getUsedApiVersion(), "VK_KHR_get_physical_device_properties2"))
+ deUint32 apiVersion = context.getUsedApiVersion();
+ if (!isCoreInstanceExtension(apiVersion, "VK_KHR_get_physical_device_properties2"))
requiredExtensions.push_back("VK_KHR_get_physical_device_properties2");
+ // extract extension names
+ std::vector<std::string> extensions;
+ for (const auto& e : supportedExtensions)
+ extensions.push_back(e.extensionName);
+
for (const auto& extName : requiredExtensions)
{
- if (!isInstanceExtensionSupported(context.getUsedApiVersion(), supportedExtensions, vk::RequiredExtension(extName)))
+ if (!isInstanceExtensionSupported(apiVersion, extensions, extName))
TCU_THROW(NotSupportedError, (extName + " is not supported").c_str());
}
// Check if the physical device supports the protected memory extension name
for (deUint32 ndx = 0; ndx < extensions.size(); ++ndx)
{
- if (!isDeviceExtensionSupported(apiVersion, supportedExtensions, vk::RequiredExtension(extensions[ndx])))
+ bool notInCore = !isCoreDeviceExtension(apiVersion, extensions[ndx]);
+ if (notInCore && !isExtensionSupported(supportedExtensions.begin(), supportedExtensions.end(), RequiredExtension(extensions[ndx])))
TCU_THROW(NotSupportedError, (extensions[ndx] + " is not supported").c_str());
- if (!isCoreDeviceExtension(apiVersion, extensions[ndx]))
+ if (notInCore)
requiredExtensions.push_back(extensions[ndx]);
}
if (m_testVector.queryResultsMode == RESULTS_MODE_GET_RESET)
{
// Check VK_EXT_host_query_reset is supported
- m_context.requireDeviceExtension("VK_EXT_host_query_reset");
+ m_context.requireDeviceFunctionality("VK_EXT_host_query_reset");
if(m_context.getHostQueryResetFeatures().hostQueryReset == VK_FALSE)
throw tcu::NotSupportedError(std::string("Implementation doesn't support resetting queries from the host").c_str());
}
if (m_testVector.queryResultsMode == RESULTS_MODE_GET_RESET)
{
// Check VK_EXT_host_query_reset is supported
- m_context.requireDeviceExtension("VK_EXT_host_query_reset");
+ m_context.requireDeviceFunctionality("VK_EXT_host_query_reset");
if(m_context.getHostQueryResetFeatures().hostQueryReset == VK_FALSE)
throw tcu::NotSupportedError(std::string("Implementation doesn't support resetting queries from the host").c_str());
}
EnumerateAndValidateTest::EnumerateAndValidateTest (vkt::Context& context, VkQueueFlagBits queueFlagBits)
: TestInstance(context)
, m_queueFlagBits(queueFlagBits)
- , m_requiredExtensionsPresent(context.requireDeviceExtension("VK_KHR_performance_query"))
+ , m_requiredExtensionsPresent(context.requireDeviceFunctionality("VK_KHR_performance_query"))
{
}
QueryTestBase::QueryTestBase(vkt::Context& context)
: TestInstance (context)
- , m_requiredExtensionsPresent(context.requireDeviceExtension("VK_KHR_performance_query"))
+ , m_requiredExtensionsPresent(context.requireDeviceFunctionality("VK_KHR_performance_query"))
, m_requiredNumerOfPasses(0)
{
}
if (hostResetQueryEnabled == DE_TRUE)
{
// Check VK_EXT_host_query_reset is supported
- m_context.requireDeviceExtension("VK_EXT_host_query_reset");
+ m_context.requireDeviceFunctionality("VK_EXT_host_query_reset");
if(m_context.getHostQueryResetFeatures().hostQueryReset == VK_FALSE)
throw tcu::NotSupportedError(std::string("Implementation doesn't support resetting queries from the host").c_str());
}
{
DE_ASSERT(m_primitiveWideness < PRIMITIVEWIDENESS_LAST);
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_line_rasterization"))
+ if (context.isDeviceFunctionalitySupported("VK_EXT_line_rasterization"))
{
VkPhysicalDeviceLineRasterizationPropertiesEXT lineRasterizationProperties =
{
bool DepthStencilResolveTest::isFeaturesSupported()
{
- m_context.requireDeviceExtension("VK_KHR_depth_stencil_resolve");
+ m_context.requireDeviceFunctionality("VK_KHR_depth_stencil_resolve");
if (m_config.imageLayers > 1)
m_context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER);
if (m_config.separateDepthStencilLayouts)
- m_context.requireDeviceExtension("VK_KHR_separate_depth_stencil_layouts");
+ m_context.requireDeviceFunctionality("VK_KHR_separate_depth_stencil_layouts");
VkPhysicalDeviceDepthStencilResolveProperties dsResolveProperties;
deMemset(&dsResolveProperties, 0, sizeof(VkPhysicalDeviceDepthStencilResolveProperties));
MultisampleRenderPassTestBase::MultisampleRenderPassTestBase (Context& context, TestConfig config, deUint32 attachmentsCount)
: TestInstance (context)
, m_featuresSupported (featuresSupported(context, config))
- , m_extensionSupported ((config.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2"))
+ , m_extensionSupported ((config.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceFunctionality("VK_KHR_create_renderpass2"))
, m_renderPassType (config.renderPassType)
, m_format (config.format)
, m_sampleCount (sampleCountBitFromSampleCount(config.sampleCount))
{
if (renderPassType == RENDERPASS_TYPE_RENDERPASS2)
- context.requireDeviceExtension("VK_KHR_create_renderpass2");
+ context.requireDeviceFunctionality("VK_KHR_create_renderpass2");
if (separateStencilUsage)
{
- context.requireDeviceExtension ("VK_EXT_separate_stencil_usage");
- context.requireInstanceExtension("VK_KHR_get_physical_device_properties2");
+ context.requireDeviceFunctionality ("VK_EXT_separate_stencil_usage");
+ context.requireInstanceFunctionality("VK_KHR_get_physical_device_properties2");
}
return true;
SampleReadTestInstance::SampleReadTestInstance (Context& context, TestConfig config)
: TestInstance (context)
, m_extensionSupported (context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_SAMPLE_RATE_SHADING) &&
- ((config.renderPassType != RENDERPASS_TYPE_RENDERPASS2) || context.requireDeviceExtension("VK_KHR_create_renderpass2")))
+ ((config.renderPassType != RENDERPASS_TYPE_RENDERPASS2) || context.requireDeviceFunctionality("VK_KHR_create_renderpass2")))
, m_renderPassType (config.renderPassType)
, m_sampleCount (config.sampleCount)
, m_width (32u)
SparseRenderTargetTestInstance::SparseRenderTargetTestInstance (Context& context, TestConfig testConfig)
: TestInstance (context)
- , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2"))
+ , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceFunctionality("VK_KHR_create_renderpass2"))
, m_renderPassType (testConfig.renderPassType)
, m_width (32u)
, m_height (32u)
ExternalDependencyTestInstance::ExternalDependencyTestInstance (Context& context, ExternalTestConfig testConfig)
: TestInstance (context)
- , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2"))
+ , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceFunctionality("VK_KHR_create_renderpass2"))
, m_renderPassType (testConfig.renderPassType)
, m_width (testConfig.imageSize.x())
, m_height (testConfig.imageSize.y())
SubpassDependencyTestInstance::SubpassDependencyTestInstance (Context& context, SubpassTestConfig testConfig)
: TestInstance (context)
- , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2"))
+ , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceFunctionality("VK_KHR_create_renderpass2"))
, m_renderPassInfo (testConfig.renderPass)
, m_renderPassType (testConfig.renderPassType)
, m_width (testConfig.imageSize.x())
SubpassSelfDependencyBackwardsTestInstance::SubpassSelfDependencyBackwardsTestInstance (Context& context, SubpassSelfDependencyBackwardsTestConfig testConfig)
: TestInstance (context)
- , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2"))
+ , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceFunctionality("VK_KHR_create_renderpass2"))
, m_featuresSupported (context.requireDeviceCoreFeature(DEVICE_CORE_FEATURE_GEOMETRY_SHADER))
, m_renderPassType (testConfig.renderPassType)
, m_width (testConfig.imageSize.x())
SeparateChannelsTestInstance::SeparateChannelsTestInstance (Context& context, SeparateChannelsTestConfig testConfig)
: TestInstance (context)
- , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceExtension("VK_KHR_create_renderpass2"))
+ , m_extensionSupported ((testConfig.renderPassType == RENDERPASS_TYPE_RENDERPASS2) && context.requireDeviceFunctionality("VK_KHR_create_renderpass2"))
, m_renderPassType (testConfig.renderPassType)
, m_width (256u)
, m_height (256u)
vector<SubpassRenderInfo> subpassRenderInfo;
if (config.renderPassType == RENDERPASS_TYPE_RENDERPASS2)
- context.requireDeviceExtension("VK_KHR_create_renderpass2");
+ context.requireDeviceFunctionality("VK_KHR_create_renderpass2");
if (config.allocationKind == ALLOCATION_KIND_DEDICATED)
{
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
TCU_THROW(NotSupportedError, "VK_KHR_dedicated_allocation is not supported");
}
if (!renderPassInfo.getInputAspects().empty())
{
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_maintenance2"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_maintenance2 not supported.");
}
}
}
- if (requireDepthStencilLayout && !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance2"))
+ if (requireDepthStencilLayout && !context.isDeviceFunctionalitySupported("VK_KHR_maintenance2"))
TCU_THROW(NotSupportedError, "VK_KHR_maintenance2 is not supported");
}
// Check for renderpass2 extension if used
if (testParams.renderPassType == RENDERPASS_TYPE_RENDERPASS2)
- context.requireDeviceExtension("VK_KHR_create_renderpass2");
+ context.requireDeviceFunctionality("VK_KHR_create_renderpass2");
// Create color image
{
{
// Check for renderpass2 extension if used
if (m_testParams.renderPassType == RENDERPASS_TYPE_RENDERPASS2)
- context.requireDeviceExtension("VK_KHR_create_renderpass2");
+ context.requireDeviceFunctionality("VK_KHR_create_renderpass2");
// Check support for the needed color, depth and stencil formats.
if (!m_testParams.colorUsed.empty())
{
// A function for getting information on variable pointer features supported through physical device
-vk::VkPhysicalDeviceVariablePointersFeatures querySupportedVariablePointersFeatures (const deUint32 apiVersion,
- const InstanceInterface& vki,
- VkPhysicalDevice device,
- const std::vector<std::string>& instanceExtensions)
+vk::VkPhysicalDeviceVariablePointersFeatures querySupportedVariablePointersFeatures (const Context& context)
{
VkPhysicalDeviceVariablePointersFeatures extensionFeatures =
{
features.pNext = &extensionFeatures;
// Call the getter only if supported. Otherwise above "zero" defaults are used
- if (isInstanceExtensionSupported(apiVersion, instanceExtensions, "VK_KHR_get_physical_device_properties2"))
+ if (context.isInstanceFunctionalitySupported("VK_KHR_get_physical_device_properties2"))
{
- vki.getPhysicalDeviceFeatures2(device, &features);
+ context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &features);
}
return extensionFeatures;
TestInstance* RobustReadTest::createInstance (Context& context) const
{
- VkPhysicalDeviceVariablePointersFeatures pointerFeatures = querySupportedVariablePointersFeatures(context.getUsedApiVersion(), context.getInstanceInterface(), context.getPhysicalDevice(), context.getInstanceExtensions());
+ VkPhysicalDeviceVariablePointersFeatures pointerFeatures = querySupportedVariablePointersFeatures(context);
if (pointerFeatures.variablePointersStorageBuffer != DE_TRUE)
return new NotSupportedInstance(context, std::string("VariablePointersStorageBuffer support is required for this test."));
TestInstance* RobustWriteTest::createInstance (Context& context) const
{
- VkPhysicalDeviceVariablePointersFeatures pointerFeatures = querySupportedVariablePointersFeatures(context.getUsedApiVersion(), context.getInstanceInterface(), context.getPhysicalDevice(), context.getInstanceExtensions());
+ VkPhysicalDeviceVariablePointersFeatures pointerFeatures = querySupportedVariablePointersFeatures(context);
if (pointerFeatures.variablePointersStorageBuffer != DE_TRUE)
return new NotSupportedInstance(context, std::string("VariablePointersStorageBuffer support is required for this test."));
{
if ((m_dataType == DATA_TYPE_INT64) || (m_dataType == DATA_TYPE_UINT64))
{
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_shader_atomic_int64"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_shader_atomic_int64"))
TCU_THROW(NotSupportedError, "Missing extension: VK_KHR_shader_atomic_int64");
VkPhysicalDeviceShaderAtomicInt64Features shaderAtomicInt64Features;
if ((m_flags & FLAG_USE_STORAGE_BUFFER) != 0)
{
- if (!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_KHR_storage_buffer_storage_class"))
+ if (!m_context.isDeviceFunctionalitySupported("VK_KHR_storage_buffer_storage_class"))
TCU_THROW(NotSupportedError, "VK_KHR_storage_buffer_storage_class is not supported");
}
private:
void checkSupported(void)
{
- m_context.requireDeviceExtension("VK_KHR_shader_clock");
+ m_context.requireDeviceFunctionality("VK_KHR_shader_clock");
VkPhysicalDeviceShaderClockFeaturesKHR shaderClockFeatures;
shaderClockFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_SHADER_CLOCK_FEATURES_KHR;
const VkMemoryRequirements requirements = getBufferMemoryRequirements(vkdi, device, *buffer);
AllocationMp bufferMemory = allocator.allocate(requirements,
(coherent ? MemoryRequirement::Coherent : MemoryRequirement::Any) |
- (context.isBufferDeviceAddressKHRSupported() && physStorageBuffer ? MemoryRequirement::DeviceAddress : MemoryRequirement::Any) |
+ (context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address") && physStorageBuffer ? MemoryRequirement::DeviceAddress : MemoryRequirement::Any) |
MemoryRequirement::HostVisible);
VK_CHECK(vkdi.bindBufferMemory(device, *buffer, bufferMemory->getMemory(), bufferMemory->getOffset()));
vector<VkDescriptorType> descriptorTypes;
// Check all required extensions are supported
- for (std::vector<std::string>::const_iterator i = m_shaderSpec.extensions.begin(); i != m_shaderSpec.extensions.end(); ++i)
- {
- if (!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), *i))
- TCU_THROW(NotSupportedError, (std::string("Extension not supported: ") + *i).c_str());
- }
+ for (const auto& ext : m_shaderSpec.extensions)
+ m_context.requireDeviceFunctionality(ext);
// Core features
{
// all the descriptors with just a desciptor to this new buffer.
if (m_shaderSpec.usesPhysStorageBuffer)
{
- const bool useKHR = m_context.isBufferDeviceAddressKHRSupported();
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
VkBufferDeviceAddressInfo info =
{
{
if (m_spirv14)
{
- context.requireDeviceExtension("VK_KHR_spirv_1_4");
+ context.requireDeviceFunctionality("VK_KHR_spirv_1_4");
}
else
{
if (m_fpWideness == 16)
{
- context.requireDeviceExtension("VK_KHR_shader_float16_int8");
+ context.requireDeviceFunctionality("VK_KHR_shader_float16_int8");
if (!isFloat16Int8FeaturesSupported(context, EXTFLOAT16INT8FEATURES_FLOAT16))
TCU_THROW(NotSupportedError, "Floating point number of width 16 bit are not supported");
}
// features are set to the same value when specific independence settings are used.
tcu::TestStatus verifyIndependenceSettings(Context& context)
{
- const std::vector<std::string>& deviceExtensions = context.getDeviceExtensions();
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), deviceExtensions, "VK_KHR_shader_float_controls"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_shader_float_controls"))
TCU_THROW(NotSupportedError, "VK_KHR_shader_float_controls not supported");
vk::VkPhysicalDeviceFloatControlsPropertiesKHR fcProperties;
return true;
// return false when float control features are requested and proper extension is not supported
- const std::vector<std::string>& deviceExtensions = context.getDeviceExtensions();
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), deviceExtensions, "VK_KHR_shader_float_controls"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_shader_float_controls"))
return false;
// perform query to get supported float control properties
if (m_usePhysStorageBuffer)
{
usageFlags |= vk::VK_BUFFER_USAGE_SHADER_DEVICE_ADDRESS_BIT;
- if (m_context.isBufferDeviceAddressKHRSupported())
+ if (m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address"))
memoryDeviceAddress = true;
}
// Query the buffer device addresses and push them via push constants
if (m_usePhysStorageBuffer)
{
- const bool useKHR = m_context.isBufferDeviceAddressKHRSupported();
+ const bool useKHR = m_context.isDeviceFunctionalitySupported("VK_KHR_buffer_device_address");
vk::VkBufferDeviceAddressInfo info =
{
TestInstance* SSBOLayoutCase::createInstance (Context& context) const
{
- if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_relaxed_block_layout") && usesRelaxedLayout(m_interface))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_relaxed_block_layout") && usesRelaxedLayout(m_interface))
TCU_THROW(NotSupportedError, "VK_KHR_relaxed_block_layout not supported");
if (!context.get16BitStorageFeatures().storageBuffer16BitAccess && uses16BitStorage(m_interface))
TCU_THROW(NotSupportedError, "storageBuffer16BitAccess not supported");
if (!subgroups::isFormatSupportedForDevice(context, caseDef.format))
TCU_THROW(NotSupportedError, "Device does not support the specified format in subgroup operations");
- if (caseDef.extShaderSubGroupBallotTests && !context.requireDeviceExtension("VK_EXT_shader_subgroup_ballot"))
+ if (caseDef.extShaderSubGroupBallotTests && !context.requireDeviceFunctionality("VK_EXT_shader_subgroup_ballot"))
{
TCU_THROW(NotSupportedError, "Device does not support VK_EXT_shader_subgroup_ballot extension");
}
if (!subgroups::isSubgroupSupported(context))
TCU_THROW(NotSupportedError, "Subgroup operations are not supported");
- if (!context.requireDeviceExtension("VK_EXT_shader_subgroup_ballot"))
+ if (!context.requireDeviceFunctionality("VK_EXT_shader_subgroup_ballot"))
{
TCU_THROW(NotSupportedError, "Device does not support VK_EXT_shader_subgroup_ballot extension");
}
TCU_THROW(NotSupportedError, "Device does not support subgroup ballot operations");
}
- if (caseDef.extShaderSubGroupBallotTests && !context.requireDeviceExtension("VK_EXT_shader_subgroup_ballot"))
+ if (caseDef.extShaderSubGroupBallotTests && !context.requireDeviceFunctionality("VK_EXT_shader_subgroup_ballot"))
{
TCU_THROW(NotSupportedError, "Device does not support VK_EXT_shader_subgroup_ballot extension");
}
features2.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
features2.pNext = DE_NULL;
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_shader_subgroup_extended_types") &&
- isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_shader_float16_int8"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_shader_subgroup_extended_types") &&
+ context.isDeviceFunctionalitySupported("VK_KHR_shader_float16_int8"))
{
features2.pNext = &subgroupExtendedTypesFeatures;
subgroupExtendedTypesFeatures.pNext = &float16Int8Features;
if (caseDef.opType > OPTYPE_LAST_NON_ARB)
{
- context.requireDeviceExtension("VK_EXT_shader_subgroup_vote");
+ context.requireDeviceFunctionality("VK_EXT_shader_subgroup_vote");
}
*caseDef.geometryPointSizeSupported = subgroups::isTessellationAndGeometryPointSizeSupported(context);
if (caseDef.opType > OPTYPE_LAST_NON_ARB)
{
- context.requireDeviceExtension("VK_EXT_shader_subgroup_vote");
+ context.requireDeviceFunctionality("VK_EXT_shader_subgroup_vote");
}
subgroups::SSBOData inputData;
std::vector<deUint32> queueFamilyIndices (queueFamilyProperties.size(), 0xFFFFFFFFu);
std::vector<const char*> extensions;
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_dedicated_allocation"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_dedicated_allocation"))
extensions.push_back("VK_KHR_dedicated_allocation");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_get_memory_requirements2"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_get_memory_requirements2"))
extensions.push_back("VK_KHR_get_memory_requirements2");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_semaphore"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_external_semaphore"))
extensions.push_back("VK_KHR_external_semaphore");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_memory"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_external_memory"))
extensions.push_back("VK_KHR_external_memory");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_semaphore_fd"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_external_semaphore_fd"))
extensions.push_back("VK_KHR_external_semaphore_fd");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_memory_fd"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_external_memory_fd"))
extensions.push_back("VK_KHR_external_memory_fd");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_semaphore_win32"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_external_semaphore_win32"))
extensions.push_back("VK_KHR_external_semaphore_win32");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_memory_win32"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_external_memory_win32"))
extensions.push_back("VK_KHR_external_memory_win32");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_timeline_semaphore"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_timeline_semaphore"))
extensions.push_back("VK_KHR_timeline_semaphore");
try
, m_supportWriteOp (makeOperationSupport(config.writeOp, config.resource))
, m_supportReadOp (makeOperationSupport(config.readOp, config.resource))
, m_notSupportedChecker (context, m_config, *m_supportWriteOp, *m_supportReadOp)
- , m_getMemReq2Supported (vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_get_memory_requirements2"))
+ , m_getMemReq2Supported (context.isDeviceFunctionalitySupported("VK_KHR_get_memory_requirements2"))
, m_instanceA (InstanceAndDevice::getInstanceA(context))
, m_vkiA (InstanceAndDevice::getDriverA())
const vk::Unique<vk::VkCommandBuffer> commandBufferA (createCommandBuffer(m_vkdA, *m_deviceA, *commandPoolA));
vk::SimpleAllocator allocatorA (m_vkdA, *m_deviceA, vk::getPhysicalDeviceMemoryProperties(m_vkiA, m_physicalDeviceA));
const std::vector<std::string> deviceExtensionsA;
- OperationContext operationContextA (m_context.getUsedApiVersion(), m_vkiA, m_vkdA, m_physicalDeviceA, *m_deviceA, allocatorA, deviceExtensionsA, m_context.getBinaryCollection(), m_pipelineCacheData);
+ OperationContext operationContextA (m_context, m_vkiA, m_vkdA, m_physicalDeviceA, *m_deviceA, allocatorA, deviceExtensionsA, m_context.getBinaryCollection(), m_pipelineCacheData);
if (!checkQueueFlags(m_queueFamiliesA[m_queueANdx].queueFlags , m_supportWriteOp->getQueueFlags(operationContextA)))
TCU_THROW(NotSupportedError, "Operation not supported by the source queue");
const vk::Unique<vk::VkCommandBuffer> commandBufferB (createCommandBuffer(m_vkdB, *m_deviceB, *commandPoolB));
vk::SimpleAllocator allocatorB (m_vkdB, *m_deviceB, vk::getPhysicalDeviceMemoryProperties(m_vkiB, m_physicalDeviceB));
const std::vector<std::string> deviceExtensionsB;
- OperationContext operationContextB (m_context.getUsedApiVersion(), m_vkiB, m_vkdB, m_physicalDeviceB, *m_deviceB, allocatorB, deviceExtensionsB, m_context.getBinaryCollection(), m_pipelineCacheData);
+ OperationContext operationContextB (m_context, m_vkiB, m_vkdB, m_physicalDeviceB, *m_deviceB, allocatorB, deviceExtensionsB, m_context.getBinaryCollection(), m_pipelineCacheData);
if (!checkQueueFlags(m_queueFamiliesB[m_queueBNdx].queueFlags , m_supportReadOp->getQueueFlags(operationContextB)))
TCU_THROW(NotSupportedError, "Operation not supported by the destination queue");
VkQueueFlags getQueueFlags (const OperationContext& context) const
{
- if (m_bufferOp == BUFFER_OP_FILL &&
- !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_maintenance1"))
+ if (m_bufferOp == BUFFER_OP_FILL && !context.isDeviceFunctionalitySupported("VK_KHR_maintenance1"))
{
return VK_QUEUE_COMPUTE_BIT | VK_QUEUE_GRAPHICS_BIT;
}
} // anonymous ns
OperationContext::OperationContext (Context& context, PipelineCacheData& pipelineCacheData)
- : m_vki (context.getInstanceInterface())
+ : m_context (context)
+ , m_vki (context.getInstanceInterface())
, m_vk (context.getDeviceInterface())
, m_physicalDevice (context.getPhysicalDevice())
, m_device (context.getDevice())
}
OperationContext::OperationContext (Context& context, PipelineCacheData& pipelineCacheData, const DeviceInterface& vk, const VkDevice device, vk::Allocator& allocator)
- : m_vki (context.getInstanceInterface())
+ : m_context (context)
+ , m_vki (context.getInstanceInterface())
, m_vk (vk)
, m_physicalDevice (context.getPhysicalDevice())
, m_device (device)
{
}
-OperationContext::OperationContext (const deUint32 apiVersion,
+OperationContext::OperationContext (Context& context,
const vk::InstanceInterface& vki,
const vk::DeviceInterface& vkd,
vk::VkPhysicalDevice physicalDevice,
const std::vector<std::string>& deviceExtensions,
vk::BinaryCollection& programCollection,
PipelineCacheData& pipelineCacheData)
- : m_vki (vki)
+ : m_context (context)
+ , m_vki (vki)
, m_vk (vkd)
, m_physicalDevice (physicalDevice)
, m_device (device)
, m_progCollection (programCollection)
, m_pipelineCacheData (pipelineCacheData)
, m_deviceExtensions (deviceExtensions)
- , m_usedApiVersion (apiVersion)
+ , m_usedApiVersion (context.getUsedApiVersion())
{
}
const vk::VkDevice device,
vk::Allocator& allocator);
- OperationContext (const deUint32 apiVersion,
+ OperationContext (Context& context,
const vk::InstanceInterface& vki,
const vk::DeviceInterface& vkd,
vk::VkPhysicalDevice physicalDevice,
const std::vector<std::string>& getDeviceExtensions (void) const { return m_deviceExtensions;}
deUint32 getUsedApiVersion (void) const { return m_usedApiVersion; }
+ bool isDeviceFunctionalitySupported(const std::string& extension) const
+ {
+ return m_context.isDeviceFunctionalitySupported(extension);
+ }
private:
+ const vkt::Context& m_context;
const vk::InstanceInterface& m_vki;
const vk::DeviceInterface& m_vk;
const vk::VkPhysicalDevice m_physicalDevice;
std::vector<deUint32> queueFamilyIndices (queueFamilyProperties.size(), 0xFFFFFFFFu);
std::vector<const char*> extensions;
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_timeline_semaphore"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_timeline_semaphore"))
extensions.push_back("VK_KHR_timeline_semaphore");
if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_external_semaphore"))
if (!isCoreDeviceExtension(context.getUsedApiVersion(), "VK_KHR_external_memory"))
extensions.push_back("VK_KHR_external_memory");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_semaphore_fd"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_external_semaphore_fd"))
extensions.push_back("VK_KHR_external_semaphore_fd");
- if (isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_semaphore_win32"))
+ if (context.isDeviceFunctionalitySupported("VK_KHR_external_semaphore_win32"))
extensions.push_back("VK_KHR_external_semaphore_win32");
try
if ((m_semaphoreHandleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_SYNC_FD_BIT ||
m_semaphoreHandleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_FD_BIT) &&
- !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_semaphore_fd"))
+ !context.isDeviceFunctionalitySupported("VK_KHR_external_semaphore_fd"))
TCU_THROW(NotSupportedError, "VK_KHR_external_semaphore_fd not supported");
if ((m_semaphoreHandleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_BIT ||
m_semaphoreHandleType == VK_EXTERNAL_SEMAPHORE_HANDLE_TYPE_OPAQUE_WIN32_KMT_BIT) &&
- !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_external_semaphore_win32"))
+ !context.isDeviceFunctionalitySupported("VK_KHR_external_semaphore_win32"))
TCU_THROW(NotSupportedError, "VK_KHR_external_semaphore_win32 not supported");
}
const vk::Unique<vk::VkCommandBuffer> commandBufferRead (allocateCommandBuffer(m_vkd, *m_device, *commandPool, vk::VK_COMMAND_BUFFER_LEVEL_PRIMARY));
vk::SimpleAllocator allocator (m_vkd, *m_device, vk::getPhysicalDeviceMemoryProperties(m_vki, m_physicalDevice));
const std::vector<std::string> deviceExtensions;
- OperationContext operationContext (m_context.getUsedApiVersion(), m_vki, m_vkd, m_physicalDevice, *m_device, allocator, deviceExtensions, m_context.getBinaryCollection(), m_pipelineCacheData);
+ OperationContext operationContext (m_context, m_vki, m_vkd, m_physicalDevice, *m_device, allocator, deviceExtensions, m_context.getBinaryCollection(), m_pipelineCacheData);
if (!checkQueueFlags(m_queueFamilies[m_queueNdx].queueFlags, vk::VK_QUEUE_GRAPHICS_BIT))
TCU_THROW(NotSupportedError, "Operation not supported by the source queue");
void WindingTestInstance::requireExtension (const char* name) const
{
- if(!isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), name))
+ if(!m_context.isDeviceFunctionalitySupported(name))
TCU_THROW(NotSupportedError, (std::string(name) + " is not supported").c_str());
}
if ((testParameters.wrapS == Sampler::MIRRORED_ONCE ||
testParameters.wrapT == Sampler::MIRRORED_ONCE) &&
- !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_sampler_mirror_clamp_to_edge"))
+ !context.isDeviceFunctionalitySupported("VK_KHR_sampler_mirror_clamp_to_edge"))
TCU_THROW(NotSupportedError, "VK_KHR_sampler_mirror_clamp_to_edge not supported");
// Create 2 textures.
if ((testParameters.wrapS == Sampler::MIRRORED_ONCE ||
testParameters.wrapT == Sampler::MIRRORED_ONCE) &&
- !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_sampler_mirror_clamp_to_edge"))
+ !context.isDeviceFunctionalitySupported("VK_KHR_sampler_mirror_clamp_to_edge"))
TCU_THROW(NotSupportedError, "VK_KHR_sampler_mirror_clamp_to_edge not supported");
m_textures.reserve(2);
if ((testParameters.wrapS == Sampler::MIRRORED_ONCE ||
testParameters.wrapT == Sampler::MIRRORED_ONCE) &&
- !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_sampler_mirror_clamp_to_edge"))
+ !context.isDeviceFunctionalitySupported("VK_KHR_sampler_mirror_clamp_to_edge"))
TCU_THROW(NotSupportedError, "VK_KHR_sampler_mirror_clamp_to_edge not supported");
// Create textures.
if ((testParameters.wrapS == Sampler::MIRRORED_ONCE ||
testParameters.wrapT == Sampler::MIRRORED_ONCE ||
testParameters.wrapR == Sampler::MIRRORED_ONCE) &&
- !isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_sampler_mirror_clamp_to_edge"))
+ !context.isDeviceFunctionalitySupported("VK_KHR_sampler_mirror_clamp_to_edge"))
TCU_THROW(NotSupportedError, "VK_KHR_sampler_mirror_clamp_to_edge not supported");
// Create textures.
TransformFeedbackTestInstance::TransformFeedbackTestInstance (Context& context, const TestParameters& parameters)
: TestInstance (context)
- , m_extensions (context.requireDeviceExtension("VK_EXT_transform_feedback"))
+ , m_extensions (context.requireDeviceFunctionality("VK_EXT_transform_feedback"))
, m_imageExtent2D (makeExtent2D(IMAGE_SIZE, IMAGE_SIZE))
, m_parameters (parameters)
, m_rnd (0)
if (m_parameters.testType == TEST_TYPE_QUERY_RESET)
{
// Check VK_EXT_host_query_reset is supported
- m_context.requireDeviceExtension("VK_EXT_host_query_reset");
+ m_context.requireDeviceFunctionality("VK_EXT_host_query_reset");
if(m_context.getHostQueryResetFeatures().hostQueryReset == VK_FALSE)
throw tcu::NotSupportedError(std::string("Implementation doesn't support resetting queries from the host").c_str());
}
const std::vector<vk::VkExtensionProperties> availableExtensions = vk::enumerateInstanceExtensionProperties(vkp, DE_NULL);
vector<string> extensionPtrs;
+ vector<string> availableExtensionNames;
+ for (const auto& ext : availableExtensions)
+ availableExtensionNames.push_back(ext.extensionName);
+
for (const auto& ext : extensions)
{
- if (!vk::isInstanceExtensionSupported(apiVersion, availableExtensions, vk::RequiredExtension(ext)))
+ if (!vk::isInstanceExtensionSupported(apiVersion, availableExtensionNames, ext))
TCU_THROW(NotSupportedError, ext + " is not supported");
if (!vk::isCoreInstanceExtension(apiVersion, ext))
bool isDeviceFeatureInitialized (VkStructureType sType) const { return m_deviceFeatures.isDeviceFeatureInitialized(sType); }
const VkPhysicalDeviceFeatures& getDeviceFeatures (void) const { return m_deviceFeatures.getCoreFeatures2().features; }
const VkPhysicalDeviceFeatures2& getDeviceFeatures2 (void) const { return m_deviceFeatures.getCoreFeatures2(); }
+ const VkPhysicalDeviceVulkan11Features& getVulkan11Features (void) const { return m_deviceFeatures.getVulkan11Features(); }
+ const VkPhysicalDeviceVulkan12Features& getVulkan12Features (void) const { return m_deviceFeatures.getVulkan12Features(); }
#include "vkDeviceFeaturesForDefaultDeviceDefs.inl"
}
deUint32 Context::getMaximumFrameworkVulkanVersion (void) const { return m_device->getMaximumFrameworkVulkanVersion(); }
-deUint32 Context::getAvailableInstanceVersion (void) const { return m_device->getAvailableInstanceVersion(); }
-const vector<string>& Context::getInstanceExtensions (void) const { return m_device->getInstanceExtensions(); }
-vk::VkInstance Context::getInstance (void) const { return m_device->getInstance(); }
-const vk::InstanceInterface& Context::getInstanceInterface (void) const { return m_device->getInstanceInterface(); }
-vk::VkPhysicalDevice Context::getPhysicalDevice (void) const { return m_device->getPhysicalDevice(); }
-deUint32 Context::getDeviceVersion (void) const { return m_device->getDeviceVersion(); }
-const vk::VkPhysicalDeviceFeatures& Context::getDeviceFeatures (void) const { return m_device->getDeviceFeatures(); }
-const vk::VkPhysicalDeviceFeatures2& Context::getDeviceFeatures2 (void) const { return m_device->getDeviceFeatures2(); }
+deUint32 Context::getAvailableInstanceVersion (void) const { return m_device->getAvailableInstanceVersion(); }
+const vector<string>& Context::getInstanceExtensions (void) const { return m_device->getInstanceExtensions(); }
+vk::VkInstance Context::getInstance (void) const { return m_device->getInstance(); }
+const vk::InstanceInterface& Context::getInstanceInterface (void) const { return m_device->getInstanceInterface(); }
+vk::VkPhysicalDevice Context::getPhysicalDevice (void) const { return m_device->getPhysicalDevice(); }
+deUint32 Context::getDeviceVersion (void) const { return m_device->getDeviceVersion(); }
+const vk::VkPhysicalDeviceFeatures& Context::getDeviceFeatures (void) const { return m_device->getDeviceFeatures(); }
+const vk::VkPhysicalDeviceFeatures2& Context::getDeviceFeatures2 (void) const { return m_device->getDeviceFeatures2(); }
+
+bool Context::isDeviceFunctionalitySupported (const std::string& extension) const
+{
+ // check if extension was promoted to core
+ deUint32 apiVersion = getUsedApiVersion();
+ if (isCoreDeviceExtension(getUsedApiVersion(), extension))
+ {
+ // all folowing checks are for vk12 and can be skipped for previous versions
+ if (apiVersion < VK_MAKE_VERSION(1, 2, 0))
+ return true;
+
+ // handle promoted functionality that was provided under feature bit
+ const auto& vk11Features = m_device->getVulkan11Features();
+ if (extension == "VK_KHR_multiview")
+ return !!vk11Features.multiview;
+ if (extension == "VK_KHR_variable_pointers")
+ return !!vk11Features.variablePointersStorageBuffer;
+ if (extension == "VK_KHR_sampler_ycbcr_conversion")
+ return !!vk11Features.samplerYcbcrConversion;
+ if (extension == "VK_KHR_shader_draw_parameters")
+ return !!vk11Features.shaderDrawParameters;
+
+ const auto& vk12Features = m_device->getVulkan12Features();
+ if (extension == "VK_KHR_buffer_device_address")
+ return !!vk12Features.bufferDeviceAddress;
+ if (extension == "VK_EXT_descriptor_indexing")
+ return !!vk12Features.descriptorIndexing;
+ if (extension == "VK_KHR_draw_indirect_count")
+ return !!vk12Features.drawIndirectCount;
+ if (extension == "VK_KHR_sampler_mirror_clamp_to_edge")
+ return !!vk12Features.samplerMirrorClampToEdge;
+ if (extension == "VK_EXT_sampler_filter_minmax")
+ return !!vk12Features.samplerFilterMinmax;
+ if (extension == "VK_EXT_shader_viewport_index_layer")
+ return !!vk12Features.shaderOutputViewportIndex && !!vk12Features.shaderOutputLayer;
+
+ // no feature flags to check
+ return true;
+ }
+
+ // check if extension is on the lits of extensions for current device
+ const auto& extensions = getDeviceExtensions();
+ return de::contains(extensions.begin(), extensions.end(), extension);
+}
+
+bool Context::isInstanceFunctionalitySupported(const std::string& extension) const
+{
+ // NOTE: current implementation uses isInstanceExtensionSupported but
+ // this will change when some instance extensions will be promoted to the
+ // core; don't use isInstanceExtensionSupported directly, use this method instead
+ return isInstanceExtensionSupported(getUsedApiVersion(), getInstanceExtensions(), extension);
+}
#include "vkDeviceFeaturesForContextDefs.inl"
bool Context::isDevicePropertyInitialized (vk::VkStructureType sType) const
{ return m_device->isDevicePropertyInitialized(sType); }
-bool Context::requireDeviceExtension (const std::string& required)
+bool Context::requireDeviceFunctionality (const std::string& required)
{
- if (!isDeviceExtensionSupported(getUsedApiVersion(), getDeviceExtensions(), required))
+ if (!isDeviceFunctionalitySupported(required))
TCU_THROW(NotSupportedError, required + " is not supported");
return true;
}
-bool Context::requireInstanceExtension (const std::string& required)
+bool Context::requireInstanceFunctionality (const std::string& required)
{
- if (!isInstanceExtensionSupported(getUsedApiVersion(), getInstanceExtensions(), required))
+ if (!isInstanceFunctionalitySupported(required))
TCU_THROW(NotSupportedError, required + " is not supported");
return true;
bool Context::isBufferDeviceAddressSupported(void) const
{
- return isBufferDeviceAddressKHRSupported() || isBufferDeviceAddressEXTSupported();
-}
-
-bool Context::isBufferDeviceAddressKHRSupported(void) const
-{
- if (isDeviceExtensionSupported(getUsedApiVersion(), getDeviceExtensions(), "VK_KHR_buffer_device_address"))
- return !!getBufferDeviceAddressFeatures().bufferDeviceAddress;
- return false;
+ return isDeviceFunctionalitySupported("VK_KHR_buffer_device_address") ||
+ isDeviceFunctionalitySupported("VK_EXT_buffer_device_address");
}
-bool Context::isBufferDeviceAddressEXTSupported(void) const
-{
- if (isDeviceExtensionSupported(getUsedApiVersion(), getDeviceExtensions(), "VK_EXT_buffer_device_address"))
- return !!getBufferDeviceAddressFeaturesEXT().bufferDeviceAddress;
- return false;
-}
-
-bool Context::isBufferDeviceAddressWithCaptureReplaySupported(void) const
-{
- return (isBufferDeviceAddressKHRSupported() && getBufferDeviceAddressFeatures().bufferDeviceAddressCaptureReplay) || (isBufferDeviceAddressEXTSupported() && getBufferDeviceAddressFeaturesEXT().bufferDeviceAddressCaptureReplay);
-}
-
-bool Context::isDescriptorIndexingSupported(void) const
-{
- if (contextSupports(vk::ApiVersion(1, 2, 0)))
- return getPhysicalDeviceVulkan12Features(getInstanceInterface(), getPhysicalDevice()).descriptorIndexing;
- else
- return isDeviceExtensionSupported(getUsedApiVersion(), getDeviceExtensions(), "VK_EXT_descriptor_indexing");
-}
// TestCase
void TestCase::initPrograms (SourceCollections&) const
const vk::InstanceInterface& getInstanceInterface (void) const;
vk::VkPhysicalDevice getPhysicalDevice (void) const;
deUint32 getDeviceVersion (void) const;
-
bool isDeviceFeatureInitialized (vk::VkStructureType sType) const;
const vk::VkPhysicalDeviceFeatures& getDeviceFeatures (void) const;
const vk::VkPhysicalDeviceFeatures2& getDeviceFeatures2 (void) const;
+ bool isInstanceFunctionalitySupported (const std::string& extension) const;
+ bool isDeviceFunctionalitySupported (const std::string& extension) const;
+
#include "vkDeviceFeaturesForContextDecl.inl"
bool isDevicePropertyInitialized (vk::VkStructureType sType) const;
bool contextSupports (const deUint32 majorNum, const deUint32 minorNum, const deUint32 patchNum) const;
bool contextSupports (const vk::ApiVersion version) const;
bool contextSupports (const deUint32 requiredApiVersionBits) const;
- bool requireDeviceExtension (const std::string& required);
- bool requireInstanceExtension (const std::string& required);
+ bool requireDeviceFunctionality (const std::string& required);
+ bool requireInstanceFunctionality (const std::string& required);
bool requireDeviceCoreFeature (const DeviceCoreFeature requiredDeviceCoreFeature);
void* getInstanceProcAddr ();
bool isBufferDeviceAddressSupported (void) const;
- bool isBufferDeviceAddressKHRSupported (void) const;
- bool isBufferDeviceAddressEXTSupported (void) const;
- bool isBufferDeviceAddressWithCaptureReplaySupported (void) const;
- bool isDescriptorIndexingSupported (void) const;
bool resultSetOnValidation () const { return m_resultSetOnValidation; }
void resultSetOnValidation (bool value) { m_resultSetOnValidation = value; }
return true;
if (spirvVersion <= vk::SPIRV_VERSION_1_4)
- return vk::isDeviceExtensionSupported(m_context.getUsedApiVersion(), m_context.getDeviceExtensions(), "VK_KHR_spirv_1_4");
+ return m_context.isDeviceFunctionalitySupported("VK_KHR_spirv_1_4");
return false;
}
typedef vector<VkExtensionProperties> Extensions;
CustomInstance createInstanceWithWsi (Context& context,
- const Extensions& supportedExtensions,
Type wsiType,
const vector<string> extraExtensions,
const VkAllocationCallbacks* pAllocator = DE_NULL)
extensions.push_back(getExtensionName(wsiType));
vector<string> instanceExtensions;
-
- for (vector<string>::const_iterator extensionName = extensions.begin();
- extensionName != extensions.end();
- ++extensionName)
+ for (const auto& ext : extensions)
{
- if (!isInstanceExtensionSupported(version, supportedExtensions, RequiredExtension(*extensionName)))
- TCU_THROW(NotSupportedError, (*extensionName + " is not supported").c_str());
+ if (!context.isInstanceFunctionalitySupported(ext))
+ TCU_THROW(NotSupportedError, (ext + " is not supported").c_str());
- if (!isCoreInstanceExtension(version, *extensionName))
- instanceExtensions.push_back(*extensionName);
+ if (!isCoreInstanceExtension(version, ext))
+ instanceExtensions.push_back(ext);
}
return vkt::createCustomInstanceWithExtensions(context, instanceExtensions, pAllocator);
: supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
DE_NULL))
, instance (createInstanceWithWsi(context,
- supportedExtensions,
wsiType,
vector<string>(),
pAllocator))
: supportedExtensions (enumerateInstanceExtensionProperties(context.getPlatformInterface(),
DE_NULL))
, instance (createInstanceWithWsi(context,
- supportedExtensions,
wsiType,
extensions,
pAllocator))
DE_UNREF(deviceMask); // needed for compatibility with acquireNextImage2KHR
}
- bool featureAvailable(const deUint32 deviceVersion, const Extensions& supportedExtensions)
+ bool featureAvailable(Context&)
{
- DE_UNREF(deviceVersion);
- DE_UNREF(supportedExtensions);
return true; // needed for compatibility with acquireNextImage2KHR
}
m_info.deviceMask = deviceMask;
}
- bool featureAvailable(const deUint32 deviceVersion, const Extensions& supportedExtensions)
+ bool featureAvailable(Context& context)
{
- return isDeviceExtensionSupported(deviceVersion, supportedExtensions, RequiredExtension("VK_KHR_device_group"));
+ return context.isDeviceFunctionalitySupported("VK_KHR_device_group");
}
VkResult call(VkSemaphore semaphore, VkFence fence, deUint32* imageIndex)
const vector<VkImage> swapchainImages = getSwapchainImages(vkd, device, *swapchain);
AcquireWrapperType acquireImageWrapper(vkd, device, 1u, *swapchain, std::numeric_limits<deUint64>::max());
- if (!acquireImageWrapper.featureAvailable(context.getUsedApiVersion(), instHelper.supportedExtensions))
+ if (!acquireImageWrapper.featureAvailable(context))
TCU_THROW(NotSupportedError, "Required extension is not supported");
const TriangleRenderer renderer (vkd,
void checkSupport (Context& context, const TestConfig config)
{
#if !defined(FAKE_COLOR_CONVERSION)
- if (!vk::isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_KHR_sampler_ycbcr_conversion"))
+ if (!context.isDeviceFunctionalitySupported("VK_KHR_sampler_ycbcr_conversion"))
TCU_THROW(NotSupportedError, "Extension VK_KHR_sampler_ycbcr_conversion not supported");
try
if (params.useArrayLayers)
{
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), "VK_EXT_ycbcr_image_arrays"))
+ if (!context.isDeviceFunctionalitySupported("VK_EXT_ycbcr_image_arrays"))
TCU_THROW(NotSupportedError, "VK_EXT_ycbcr_image_arrays is not supported");
VkImageFormatProperties properties = getPhysicalDeviceImageFormatProperties(context.getInstanceInterface(), context.getPhysicalDevice(),
reqExts.push_back("VK_KHR_get_memory_requirements2");
}
- for (vector<string>::const_iterator extIter = reqExts.begin(); extIter != reqExts.end(); ++extIter)
- {
- if (!isDeviceExtensionSupported(context.getUsedApiVersion(), context.getDeviceExtensions(), *extIter))
- TCU_THROW(NotSupportedError, (*extIter + " is not supported").c_str());
- }
+ for (const string& ext : reqExts)
+ context.requireDeviceFunctionality(ext);
if (features.samplerYcbcrConversion == VK_FALSE)
{
# handle special cases
if sType == "EXCLUSIVE_SCISSOR":
sType = "SCISSOR_EXCLUSIVE"
- if sType == 'VULKAN_1_1' or sType == 'VULKAN_1_2':
+ if sType in {'VULKAN_1_1', 'VULKAN_1_2'}:
continue
# end handling special cases
ptrnExtensionName = r'^\s*#define\s+(\w+' + sSuffix + '_' + sType + '_EXTENSION_NAME).+$'
ptrnStructName = r'\s*typedef\s+struct\s+(VkPhysicalDevice' + structName + 'Properties' + sSuffix[1:] + ')'
matchStructName = re.search(ptrnStructName, src, re.M)
if matchStructName:
- if sType == 'VULKAN_1_1' or sType == 'VULKAN_1_2':
+ if sType in {'VULKAN_1_1', 'VULKAN_1_2'}:
continue
extType = sType
if extType == "MAINTENANCE_3":
matchSpecVersion.group (1) if matchSpecVersion else '0') )
return defs
-def writeDeviceFeatures(dfDefs, filename):
+def writeDeviceFeatures(api, dfDefs, filename):
+ # find VkPhysicalDeviceVulkan[1-9][0-9]Features blob structurs
+ # and construct dictionary with all of their attributes
+ blobMembers = {}
+ blobStructs = {}
+ blobPattern = re.compile("^VkPhysicalDeviceVulkan([1-9][0-9])Features$")
+ for structureType in api.compositeTypes:
+ match = blobPattern.match(structureType.name)
+ if match:
+ allMembers = [member.name for member in structureType.members]
+ vkVersion = match.group(1)
+ blobMembers[vkVersion] = allMembers[2:]
+ blobStructs[vkVersion] = set()
+ initFromBlobDefinitions = []
+ emptyInitDefinitions = []
+ # iterate over all feature structures
+ allFeaturesPattern = re.compile("^VkPhysicalDevice\w+Features")
+ nonExtFeaturesPattern = re.compile("^VkPhysicalDevice\w+Features$")
+ for structureType in api.compositeTypes:
+ # skip structures that are not feature structures
+ if not allFeaturesPattern.match(structureType.name):
+ continue
+ # skip structures that were previously identified as blobs
+ if blobPattern.match(structureType.name):
+ continue
+ if structureType.isAlias:
+ continue
+ # skip sType and pNext and just grab third and next attributes
+ structureMembers = structureType.members[2:]
+ notPartOfBlob = True
+ if nonExtFeaturesPattern.match(structureType.name):
+ # check if this member is part of any of the blobs
+ for blobName, blobMemberList in blobMembers.items():
+ # if just one member is not part of this blob go to the next blob
+ # (we asume that all members are part of blob - no need to check all)
+ if structureMembers[0].name not in blobMemberList:
+ continue
+ # add another feature structure name to this blob
+ blobStructs[blobName].add(structureType)
+ # add specialization for this feature structure
+ memberCopying = ""
+ for member in structureMembers:
+ memberCopying += "\tfeatureType.{0} = allBlobs.vk{1}.{0};\n".format(member.name, blobName)
+ wholeFunction = \
+ "template<> void initFromBlob<{0}>({0}& featureType, const AllBlobs& allBlobs)\n" \
+ "{{\n" \
+ "{1}" \
+ "}}".format(structureType.name, memberCopying)
+ initFromBlobDefinitions.append(wholeFunction)
+ notPartOfBlob = False
+ # assuming that all members are part of blob, goto next
+ break
+ # add empty template definition as on Fedora there are issue with
+ # linking using just generic template - all specializations are needed
+ if notPartOfBlob:
+ emptyFunction = "template<> void initFromBlob<{0}>({0}&, const AllBlobs&) {{}}"
+ emptyInitDefinitions.append(emptyFunction.format(structureType.name))
extensionDefines = []
makeFeatureDescDefinitions = []
featureStructWrappers = []
# construct makeFeatureDesc template function definitions
sTypeName = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_{0}_FEATURES{1}".format(sType, sSuffix)
makeFeatureDescDefinitions.append("template<> FeatureDesc makeFeatureDesc<{0}>(void) " \
- "{{ return FeatureDesc({1}, {2}, {3}, {4}); }}".format(extStruct, sTypeName, extensionNameDefinition, specVer, len(dfDefs)-idx))
+ "{{ return FeatureDesc{{{1}, {2}, {3}, {4}}}; }}".format(extStruct, sTypeName, extensionNameDefinition, specVer, len(dfDefs)-idx))
# construct CreateFeatureStruct wrapper block
featureStructWrappers.append("\t{{ createFeatureStructWrapper<{0}>, {1}, {2} }},".format(extStruct, extensionNameDefinition, specVer))
+ # construct method that will check if structure sType is part of blob
+ blobChecker = "bool isPartOfBlobFeatures (VkStructureType sType)\n{\n" \
+ "\tconst std::vector<VkStructureType> sTypeVect =" \
+ "\t{\n"
+ # iterate over blobs with list of structures
+ for blobName in sorted(blobStructs.keys()):
+ blobChecker += "\t\t// Vulkan{0}\n".format(blobName)
+ # iterate over all feature structures in current blob
+ structuresList = list(blobStructs[blobName])
+ structuresList = sorted(structuresList, key=lambda s: s.name)
+ for structType in structuresList:
+ # find definition of this structure in dfDefs
+ structName = structType.name
+ # handle special cases
+ if structName == 'VkPhysicalDeviceShaderDrawParameterFeatures':
+ structName = 'VkPhysicalDeviceShaderDrawParametersFeatures'
+ # end handling special cases
+ structDef = [s for s in dfDefs if s[2] == structName][0]
+ sType = structDef[0]
+ sSuffix = structDef[1]
+ # handle special cases
+ if sType == "SCISSOR_EXCLUSIVE":
+ sType = "EXCLUSIVE_SCISSOR"
+ # end handling special cases
+ sTypeName = "VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_{0}_FEATURES{1}".format(sType, sSuffix)
+ blobChecker += "\t\t{0},\n".format(sTypeName)
+ blobChecker += "\t};\n" \
+ "\treturn de::contains(sTypeVect.begin(), sTypeVect.end(), sType);\n" \
+ "}\n"
# combine all definition lists
stream = [
'#include "vkDeviceFeatures.hpp"\n',
'namespace vk\n{']
stream.extend(extensionDefines)
stream.append('\n')
+ stream.extend(initFromBlobDefinitions)
+ stream.append('\n// generic template is not enough for some compilers')
+ stream.extend(emptyInitDefinitions)
+ stream.append('\n')
stream.extend(makeFeatureDescDefinitions)
stream.append('\n')
- stream.append('static const FeatureStructMapItem featureStructCreatorMap[] =\n{')
+ stream.append('static const FeatureStructCreationData featureStructCreationArray[] =\n{')
stream.extend(featureStructWrappers)
- stream.append('};\n} // vk\n')
+ stream.append('};\n')
+ stream.append(blobChecker)
+ stream.append('} // vk\n')
writeInlFile(filename, INL_HEADER, stream)
def writeDeviceProperties(dfDefs, filename):
dictStructs[m[0]].append(allRequirements[0])
stream.extend(['bool checkMandatoryFeatures(const vkt::Context& context)\n{',
- '\tif ( !vk::isInstanceExtensionSupported(context.getUsedApiVersion(), context.getInstanceExtensions(), "VK_KHR_get_physical_device_properties2") )',
+ '\tif (!context.isInstanceFunctionalitySupported("VK_KHR_get_physical_device_properties2"))',
'\t\tTCU_THROW(NotSupportedError, "Extension VK_KHR_get_physical_device_properties2 is not present");',
'',
'\tVkPhysicalDevice\t\t\t\t\tphysicalDevice\t\t= context.getPhysicalDevice();',
deviceFuncs = [Function.TYPE_DEVICE]
dfd = generateDeviceFeaturesDefs(src)
- writeDeviceFeatures (dfd, os.path.join(VULKAN_DIR, "vkDeviceFeatures.inl"))
+ writeDeviceFeatures (api, dfd, os.path.join(VULKAN_DIR, "vkDeviceFeatures.inl"))
writeDeviceFeaturesDefaultDeviceDefs (dfd, os.path.join(VULKAN_DIR, "vkDeviceFeaturesForDefaultDeviceDefs.inl"))
writeDeviceFeaturesContextDecl (dfd, os.path.join(VULKAN_DIR, "vkDeviceFeaturesForContextDecl.inl"))
writeDeviceFeaturesContextDefs (dfd, os.path.join(VULKAN_DIR, "vkDeviceFeaturesForContextDefs.inl"))
projects / platform / upstream / VK-GL-CTS.git / commitdiff