Add Mandatory extension features

Along with adding new feature checks, had to add logic to allow
OR cases where at least 1 feature for an extension needs to be
supported.

https://gitlab.khronos.org/vulkan/vulkan/merge_requests/3685
This CL updates the test to align with the MR.

Components: Vulkan

Affects: dEQP-VK.info.device_mandatory_features

VK-GL-CTS issue: 2287

Change-Id: I4e8a04f30cf15d016072252cf137fc16e3c28a34

diff --git a/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl b/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
index 4ba806f..460feee 100644 (file)
--- a/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
+++ b/external/vulkancts/framework/vulkan/vkMandatoryFeatures.inl
@@ -26,6 +26,36 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDevice8BitStorageFeaturesKHR.pNext;
        }
 
+       vk::VkPhysicalDeviceBufferDeviceAddressFeaturesKHR physicalDeviceBufferDeviceAddressFeaturesKHR;
+       deMemset(&physicalDeviceBufferDeviceAddressFeaturesKHR, 0, sizeof(physicalDeviceBufferDeviceAddressFeaturesKHR));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_buffer_device_address")) )
+       {
+               physicalDeviceBufferDeviceAddressFeaturesKHR.sType = getStructureType<VkPhysicalDeviceBufferDeviceAddressFeaturesKHR>();
+               *nextPtr = &physicalDeviceBufferDeviceAddressFeaturesKHR;
+               nextPtr  = &physicalDeviceBufferDeviceAddressFeaturesKHR.pNext;
+       }
+
+       vk::VkPhysicalDeviceConditionalRenderingFeaturesEXT physicalDeviceConditionalRenderingFeaturesEXT;
+       deMemset(&physicalDeviceConditionalRenderingFeaturesEXT, 0, sizeof(physicalDeviceConditionalRenderingFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_conditional_rendering")) )
+       {
+               physicalDeviceConditionalRenderingFeaturesEXT.sType = getStructureType<VkPhysicalDeviceConditionalRenderingFeaturesEXT>();
+               *nextPtr = &physicalDeviceConditionalRenderingFeaturesEXT;
+               nextPtr  = &physicalDeviceConditionalRenderingFeaturesEXT.pNext;
+       }
+
+       vk::VkPhysicalDeviceDepthClipEnableFeaturesEXT physicalDeviceDepthClipEnableFeaturesEXT;
+       deMemset(&physicalDeviceDepthClipEnableFeaturesEXT, 0, sizeof(physicalDeviceDepthClipEnableFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clip_enable")) )
+       {
+               physicalDeviceDepthClipEnableFeaturesEXT.sType = getStructureType<VkPhysicalDeviceDepthClipEnableFeaturesEXT>();
+               *nextPtr = &physicalDeviceDepthClipEnableFeaturesEXT;
+               nextPtr  = &physicalDeviceDepthClipEnableFeaturesEXT.pNext;
+       }
+
        vk::VkPhysicalDeviceDescriptorIndexingFeaturesEXT physicalDeviceDescriptorIndexingFeaturesEXT;
        deMemset(&physicalDeviceDescriptorIndexingFeaturesEXT, 0, sizeof(physicalDeviceDescriptorIndexingFeaturesEXT));
 
@@ -36,6 +66,56 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceDescriptorIndexingFeaturesEXT.pNext;
        }
 
+       vk::VkPhysicalDeviceFragmentDensityMapFeaturesEXT physicalDeviceFragmentDensityMapFeaturesEXT;
+       deMemset(&physicalDeviceFragmentDensityMapFeaturesEXT, 0, sizeof(physicalDeviceFragmentDensityMapFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_density_map")) )
+       {
+               physicalDeviceFragmentDensityMapFeaturesEXT.sType = getStructureType<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>();
+               *nextPtr = &physicalDeviceFragmentDensityMapFeaturesEXT;
+               nextPtr  = &physicalDeviceFragmentDensityMapFeaturesEXT.pNext;
+       }
+
+       vk::VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT physicalDeviceFragmentShaderInterlockFeaturesEXT;
+       deMemset(&physicalDeviceFragmentShaderInterlockFeaturesEXT, 0, sizeof(physicalDeviceFragmentShaderInterlockFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_shader_interlock")) )
+       {
+               physicalDeviceFragmentShaderInterlockFeaturesEXT.sType = getStructureType<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>();
+               *nextPtr = &physicalDeviceFragmentShaderInterlockFeaturesEXT;
+               nextPtr  = &physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext;
+       }
+
+       vk::VkPhysicalDeviceHostQueryResetFeaturesEXT physicalDeviceHostQueryResetFeaturesEXT;
+       deMemset(&physicalDeviceHostQueryResetFeaturesEXT, 0, sizeof(physicalDeviceHostQueryResetFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_host_query_reset")) )
+       {
+               physicalDeviceHostQueryResetFeaturesEXT.sType = getStructureType<VkPhysicalDeviceHostQueryResetFeaturesEXT>();
+               *nextPtr = &physicalDeviceHostQueryResetFeaturesEXT;
+               nextPtr  = &physicalDeviceHostQueryResetFeaturesEXT.pNext;
+       }
+
+       vk::VkPhysicalDeviceImagelessFramebufferFeaturesKHR physicalDeviceImagelessFramebufferFeaturesKHR;
+       deMemset(&physicalDeviceImagelessFramebufferFeaturesKHR, 0, sizeof(physicalDeviceImagelessFramebufferFeaturesKHR));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_imageless_framebuffer")) )
+       {
+               physicalDeviceImagelessFramebufferFeaturesKHR.sType = getStructureType<VkPhysicalDeviceImagelessFramebufferFeaturesKHR>();
+               *nextPtr = &physicalDeviceImagelessFramebufferFeaturesKHR;
+               nextPtr  = &physicalDeviceImagelessFramebufferFeaturesKHR.pNext;
+       }
+
+       vk::VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT;
+       deMemset(&physicalDeviceIndexTypeUint8FeaturesEXT, 0, sizeof(physicalDeviceIndexTypeUint8FeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_index_type_uint8")) )
+       {
+               physicalDeviceIndexTypeUint8FeaturesEXT.sType = getStructureType<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>();
+               *nextPtr = &physicalDeviceIndexTypeUint8FeaturesEXT;
+               nextPtr  = &physicalDeviceIndexTypeUint8FeaturesEXT.pNext;
+       }
+
        vk::VkPhysicalDeviceInlineUniformBlockFeaturesEXT physicalDeviceInlineUniformBlockFeaturesEXT;
        deMemset(&physicalDeviceInlineUniformBlockFeaturesEXT, 0, sizeof(physicalDeviceInlineUniformBlockFeaturesEXT));
 
@@ -46,6 +126,26 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceInlineUniformBlockFeaturesEXT.pNext;
        }
 
+       vk::VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT;
+       deMemset(&physicalDeviceLineRasterizationFeaturesEXT, 0, sizeof(physicalDeviceLineRasterizationFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_line_rasterization")) )
+       {
+               physicalDeviceLineRasterizationFeaturesEXT.sType = getStructureType<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
+               *nextPtr = &physicalDeviceLineRasterizationFeaturesEXT;
+               nextPtr  = &physicalDeviceLineRasterizationFeaturesEXT.pNext;
+       }
+
+       vk::VkPhysicalDeviceMemoryPriorityFeaturesEXT physicalDeviceMemoryPriorityFeaturesEXT;
+       deMemset(&physicalDeviceMemoryPriorityFeaturesEXT, 0, sizeof(physicalDeviceMemoryPriorityFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_memory_priority")) )
+       {
+               physicalDeviceMemoryPriorityFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMemoryPriorityFeaturesEXT>();
+               *nextPtr = &physicalDeviceMemoryPriorityFeaturesEXT;
+               nextPtr  = &physicalDeviceMemoryPriorityFeaturesEXT.pNext;
+       }
+
        vk::VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures;
        deMemset(&physicalDeviceMultiviewFeatures, 0, sizeof(physicalDeviceMultiviewFeatures));
 
@@ -56,6 +156,16 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceMultiviewFeatures.pNext;
        }
 
+       vk::VkPhysicalDevicePerformanceQueryFeaturesKHR physicalDevicePerformanceQueryFeaturesKHR;
+       deMemset(&physicalDevicePerformanceQueryFeaturesKHR, 0, sizeof(physicalDevicePerformanceQueryFeaturesKHR));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_performance_query")) )
+       {
+               physicalDevicePerformanceQueryFeaturesKHR.sType = getStructureType<VkPhysicalDevicePerformanceQueryFeaturesKHR>();
+               *nextPtr = &physicalDevicePerformanceQueryFeaturesKHR;
+               nextPtr  = &physicalDevicePerformanceQueryFeaturesKHR.pNext;
+       }
+
        vk::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR physicalDevicePipelineExecutablePropertiesFeaturesKHR;
        deMemset(&physicalDevicePipelineExecutablePropertiesFeaturesKHR, 0, sizeof(physicalDevicePipelineExecutablePropertiesFeaturesKHR));
 
@@ -76,6 +186,66 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceScalarBlockLayoutFeaturesEXT.pNext;
        }
 
+       vk::VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR physicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
+       deMemset(&physicalDeviceSeparateDepthStencilLayoutsFeaturesKHR, 0, sizeof(physicalDeviceSeparateDepthStencilLayoutsFeaturesKHR));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_separate_depth_stencil_layouts")) )
+       {
+               physicalDeviceSeparateDepthStencilLayoutsFeaturesKHR.sType = getStructureType<VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR>();
+               *nextPtr = &physicalDeviceSeparateDepthStencilLayoutsFeaturesKHR;
+               nextPtr  = &physicalDeviceSeparateDepthStencilLayoutsFeaturesKHR.pNext;
+       }
+
+       vk::VkPhysicalDeviceShaderAtomicInt64FeaturesKHR physicalDeviceShaderAtomicInt64FeaturesKHR;
+       deMemset(&physicalDeviceShaderAtomicInt64FeaturesKHR, 0, sizeof(physicalDeviceShaderAtomicInt64FeaturesKHR));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_atomic_int64")) )
+       {
+               physicalDeviceShaderAtomicInt64FeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderAtomicInt64FeaturesKHR>();
+               *nextPtr = &physicalDeviceShaderAtomicInt64FeaturesKHR;
+               nextPtr  = &physicalDeviceShaderAtomicInt64FeaturesKHR.pNext;
+       }
+
+       vk::VkPhysicalDeviceShaderClockFeaturesKHR physicalDeviceShaderClockFeaturesKHR;
+       deMemset(&physicalDeviceShaderClockFeaturesKHR, 0, sizeof(physicalDeviceShaderClockFeaturesKHR));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_clock")) )
+       {
+               physicalDeviceShaderClockFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderClockFeaturesKHR>();
+               *nextPtr = &physicalDeviceShaderClockFeaturesKHR;
+               nextPtr  = &physicalDeviceShaderClockFeaturesKHR.pNext;
+       }
+
+       vk::VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+       deMemset(&physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, 0, sizeof(physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_demote_to_helper_invocation")) )
+       {
+               physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>();
+               *nextPtr = &physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
+               nextPtr  = &physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.pNext;
+       }
+
+       vk::VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features;
+       deMemset(&physicalDeviceShaderFloat16Int8Features, 0, sizeof(physicalDeviceShaderFloat16Int8Features));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_float16_int8")) )
+       {
+               physicalDeviceShaderFloat16Int8Features.sType = getStructureType<VkPhysicalDeviceShaderFloat16Int8Features>();
+               *nextPtr = &physicalDeviceShaderFloat16Int8Features;
+               nextPtr  = &physicalDeviceShaderFloat16Int8Features.pNext;
+       }
+
+       vk::VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR physicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
+       deMemset(&physicalDeviceShaderSubgroupExtendedTypesFeaturesKHR, 0, sizeof(physicalDeviceShaderSubgroupExtendedTypesFeaturesKHR));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_subgroup_extended_types")) )
+       {
+               physicalDeviceShaderSubgroupExtendedTypesFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR>();
+               *nextPtr = &physicalDeviceShaderSubgroupExtendedTypesFeaturesKHR;
+               nextPtr  = &physicalDeviceShaderSubgroupExtendedTypesFeaturesKHR.pNext;
+       }
+
        vk::VkPhysicalDeviceSubgroupSizeControlFeaturesEXT physicalDeviceSubgroupSizeControlFeaturesEXT;
        deMemset(&physicalDeviceSubgroupSizeControlFeaturesEXT, 0, sizeof(physicalDeviceSubgroupSizeControlFeaturesEXT));
 
@@ -86,6 +256,26 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceSubgroupSizeControlFeaturesEXT.pNext;
        }
 
+       vk::VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT;
+       deMemset(&physicalDeviceTexelBufferAlignmentFeaturesEXT, 0, sizeof(physicalDeviceTexelBufferAlignmentFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_texel_buffer_alignment")) )
+       {
+               physicalDeviceTexelBufferAlignmentFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>();
+               *nextPtr = &physicalDeviceTexelBufferAlignmentFeaturesEXT;
+               nextPtr  = &physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext;
+       }
+
+       vk::VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT physicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+       deMemset(&physicalDeviceTextureCompressionASTCHDRFeaturesEXT, 0, sizeof(physicalDeviceTextureCompressionASTCHDRFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_texture_compression_astc_hdr")) )
+       {
+               physicalDeviceTextureCompressionASTCHDRFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>();
+               *nextPtr = &physicalDeviceTextureCompressionASTCHDRFeaturesEXT;
+               nextPtr  = &physicalDeviceTextureCompressionASTCHDRFeaturesEXT.pNext;
+       }
+
        vk::VkPhysicalDeviceTimelineSemaphoreFeaturesKHR physicalDeviceTimelineSemaphoreFeaturesKHR;
        deMemset(&physicalDeviceTimelineSemaphoreFeaturesKHR, 0, sizeof(physicalDeviceTimelineSemaphoreFeaturesKHR));
 
@@ -96,6 +286,16 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceTimelineSemaphoreFeaturesKHR.pNext;
        }
 
+       vk::VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT;
+       deMemset(&physicalDeviceTransformFeedbackFeaturesEXT, 0, sizeof(physicalDeviceTransformFeedbackFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_transform_feedback")) )
+       {
+               physicalDeviceTransformFeedbackFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
+               *nextPtr = &physicalDeviceTransformFeedbackFeaturesEXT;
+               nextPtr  = &physicalDeviceTransformFeedbackFeaturesEXT.pNext;
+       }
+
        vk::VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR physicalDeviceUniformBufferStandardLayoutFeaturesKHR;
        deMemset(&physicalDeviceUniformBufferStandardLayoutFeaturesKHR, 0, sizeof(physicalDeviceUniformBufferStandardLayoutFeaturesKHR));
 
@@ -116,6 +316,16 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceVariablePointersFeatures.pNext;
        }
 
+       vk::VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT;
+       deMemset(&physicalDeviceVertexAttributeDivisorFeaturesEXT, 0, sizeof(physicalDeviceVertexAttributeDivisorFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_vertex_attribute_divisor")) )
+       {
+               physicalDeviceVertexAttributeDivisorFeaturesEXT.sType = getStructureType<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>();
+               *nextPtr = &physicalDeviceVertexAttributeDivisorFeaturesEXT;
+               nextPtr  = &physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext;
+       }
+
        vk::VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features;
        deMemset(&physicalDeviceVulkan11Features, 0, sizeof(physicalDeviceVulkan11Features));
 
@@ -136,6 +346,26 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                nextPtr  = &physicalDeviceVulkan12Features.pNext;
        }
 
+       vk::VkPhysicalDeviceVulkanMemoryModelFeaturesKHR physicalDeviceVulkanMemoryModelFeaturesKHR;
+       deMemset(&physicalDeviceVulkanMemoryModelFeaturesKHR, 0, sizeof(physicalDeviceVulkanMemoryModelFeaturesKHR));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_vulkan_memory_model")) )
+       {
+               physicalDeviceVulkanMemoryModelFeaturesKHR.sType = getStructureType<VkPhysicalDeviceVulkanMemoryModelFeaturesKHR>();
+               *nextPtr = &physicalDeviceVulkanMemoryModelFeaturesKHR;
+               nextPtr  = &physicalDeviceVulkanMemoryModelFeaturesKHR.pNext;
+       }
+
+       vk::VkPhysicalDeviceYcbcrImageArraysFeaturesEXT physicalDeviceYcbcrImageArraysFeaturesEXT;
+       deMemset(&physicalDeviceYcbcrImageArraysFeaturesEXT, 0, sizeof(physicalDeviceYcbcrImageArraysFeaturesEXT));
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_ycbcr_image_arrays")) )
+       {
+               physicalDeviceYcbcrImageArraysFeaturesEXT.sType = getStructureType<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>();
+               *nextPtr = &physicalDeviceYcbcrImageArraysFeaturesEXT;
+               nextPtr  = &physicalDeviceYcbcrImageArraysFeaturesEXT.pNext;
+       }
+
        context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &coreFeatures);
        bool result = true;
 
@@ -399,6 +629,15 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                }
        }
 
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_subgroup_extended_types")) )
+       {
+               if ( physicalDeviceShaderSubgroupExtendedTypesFeaturesKHR.shaderSubgroupExtendedTypes == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupExtendedTypes not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
        if ( context.contextSupports(vk::ApiVersion(1, 2, 0)) )
        {
                if ( physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes == VK_FALSE )
@@ -408,6 +647,15 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                }
        }
 
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_imageless_framebuffer")) )
+       {
+               if ( physicalDeviceImagelessFramebufferFeaturesKHR.imagelessFramebuffer == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature imagelessFramebuffer not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
        if ( context.contextSupports(vk::ApiVersion(1, 2, 0)) )
        {
                if ( physicalDeviceVulkan12Features.imagelessFramebuffer == VK_FALSE )
@@ -426,6 +674,15 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                }
        }
 
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_separate_depth_stencil_layouts")) )
+       {
+               if ( physicalDeviceSeparateDepthStencilLayoutsFeaturesKHR.separateDepthStencilLayouts == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature separateDepthStencilLayouts not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
        if ( context.contextSupports(vk::ApiVersion(1, 2, 0)) )
        {
                if ( physicalDeviceVulkan12Features.separateDepthStencilLayouts == VK_FALSE )
@@ -435,6 +692,15 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                }
        }
 
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_host_query_reset")) )
+       {
+               if ( physicalDeviceHostQueryResetFeaturesEXT.hostQueryReset == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature hostQueryReset not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
        if ( context.contextSupports(vk::ApiVersion(1, 2, 0)) )
        {
                if ( physicalDeviceVulkan12Features.hostQueryReset == VK_FALSE )
@@ -579,6 +845,177 @@ bool checkMandatoryFeatures(const vkt::Context& context)
                }
        }
 
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_texture_compression_astc_hdr")) )
+       {
+               if ( physicalDeviceTextureCompressionASTCHDRFeaturesEXT.textureCompressionASTC_HDR == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature textureCompressionASTC_HDR not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clip_enable")) )
+       {
+               if ( physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature depthClipEnable not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_memory_priority")) )
+       {
+               if ( physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature memoryPriority not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_ycbcr_image_arrays")) )
+       {
+               if ( physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature ycbcrImageArrays not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_index_type_uint8")) )
+       {
+               if ( physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature indexTypeUint8 not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_demote_to_helper_invocation")) )
+       {
+               if ( physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.shaderDemoteToHelperInvocation == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderDemoteToHelperInvocation not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_texel_buffer_alignment")) )
+       {
+               if ( physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature texelBufferAlignment not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_vulkan_memory_model")) )
+       {
+               if ( physicalDeviceVulkanMemoryModelFeaturesKHR.vulkanMemoryModel == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature vulkanMemoryModel not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_buffer_device_address")) )
+       {
+               if ( physicalDeviceBufferDeviceAddressFeaturesKHR.bufferDeviceAddress == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_performance_query")) )
+       {
+               if ( physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature performanceCounterQueryPools not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_transform_feedback")) )
+       {
+               if ( physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature transformFeedback not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_conditional_rendering")) )
+       {
+               if ( physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature conditionalRendering not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_vertex_attribute_divisor")) )
+       {
+               if ( physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature vertexAttributeInstanceRateDivisor not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_density_map")) )
+       {
+               if ( physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature fragmentDensityMap not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_clock")) )
+       {
+               if ( physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupClock not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_atomic_int64")) )
+       {
+               if ( physicalDeviceShaderAtomicInt64FeaturesKHR.shaderBufferInt64Atomics == VK_FALSE )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderBufferInt64Atomics not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_float16_int8")) )
+       {
+               if ( ( physicalDeviceShaderFloat16Int8Features.shaderFloat16 == VK_FALSE ) && ( physicalDeviceShaderFloat16Int8Features.shaderInt8 == VK_FALSE ) )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature shaderFloat16 or shaderInt8 not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_shader_interlock")) )
+       {
+               if ( ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock == VK_FALSE ) && ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock == VK_FALSE ) && ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock == VK_FALSE ) )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature fragmentShaderSampleInterlock or fragmentShaderPixelInterlock or fragmentShaderShadingRateInterlock not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
+       if ( isExtensionSupported(deviceExtensions, RequiredExtension("VK_EXT_line_rasterization")) )
+       {
+               if ( ( physicalDeviceLineRasterizationFeaturesEXT.rectangularLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.bresenhamLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.smoothLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.stippledRectangularLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.stippledBresenhamLines == VK_FALSE ) && ( physicalDeviceLineRasterizationFeaturesEXT.stippledSmoothLines == VK_FALSE ) )
+               {
+                       log << tcu::TestLog::Message << "Mandatory feature rectangularLines or bresenhamLines or smoothLines or stippledRectangularLines or stippledBresenhamLines or stippledSmoothLines not supported" << tcu::TestLog::EndMessage;
+                       result = false;
+               }
+       }
+
        return result;
 }
 

diff --git a/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
index 907de2e..c27e10f 100644 (file)
--- a/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
+++ b/external/vulkancts/modules/vulkan/api/vktApiFeatureInfo.cpp
@@ -2847,7 +2847,7 @@ tcu::TestStatus deviceMandatoryFeatures(Context& context)
 {
        if( checkMandatoryFeatures(context) )
                return tcu::TestStatus::pass("Passed");
-       return tcu::TestStatus::fail("Not all mandatory features are supported ( see: chapter 35.1 )");
+       return tcu::TestStatus::fail("Not all mandatory features are supported ( see: vkspec.html#features-requirements )");
 }
 
 VkFormatFeatureFlags getRequiredOptimalTilingFeatures (VkFormat format)

diff --git a/external/vulkancts/scripts/gen_framework.py b/external/vulkancts/scripts/gen_framework.py
index 18fdb16..6dd1b49 100644 (file)
--- a/external/vulkancts/scripts/gen_framework.py
+++ b/external/vulkancts/scripts/gen_framework.py
@@ -1847,14 +1847,14 @@ def splitWithQuotation(line):
 
 def writeMandatoryFeatures(filename):
        stream = []
-       pattern = r'\s*([\w]+)\s+([\w]+)\s+REQUIREMENTS\s+\((.*)\)'
+       pattern = r'\s*([\w]+)\s+FEATURES\s+\((.*)\)\s+REQUIREMENTS\s+\((.*)\)'
        mandatoryFeatures = readFile(os.path.join(VULKAN_H_DIR, "mandatory_features.txt"))
        matches = re.findall(pattern, mandatoryFeatures)
        dictStructs = {}
        dictData = []
        for m in matches:
                allRequirements = splitWithQuotation(m[2])
-               dictData.append( [ m[0], m[1], allRequirements ] )
+               dictData.append( [ m[0], m[1].strip(), allRequirements ] )
                if m[0] != 'VkPhysicalDeviceFeatures' :
                        if (m[0] not in dictStructs):
                                dictStructs[m[0]] = [m[0][2:3].lower() + m[0][3:]]
@@ -1926,10 +1926,21 @@ def writeMandatoryFeatures(filename):
                                        condition = condition + ' && '
                        condition = condition + ' )'
                        stream.append('\t' + condition)
-               stream.extend(['\t{',
-                                          '\t\tif ( ' + structName + '.' + v[1] + ' == VK_FALSE )',
-                                          '\t\t{',
-                                          '\t\t\tlog << tcu::TestLog::Message << "Mandatory feature ' + v[1] + ' not supported" << tcu::TestLog::EndMessage;',
+               stream.append('\t{')
+               # Don't need to support an AND case since that would just be another line in the .txt
+               if len(v[1].split(" ")) == 1:
+                       stream.append('\t\tif ( ' + structName + '.' + v[1] + ' == VK_FALSE )')
+               else:
+                       condition = 'if ( '
+                       for i, feature in enumerate(v[1].split(" ")):
+                               if i != 0:
+                                       condition = condition + ' && '
+                               condition = condition + '( ' + structName + '.' + feature + ' == VK_FALSE )'
+                       condition = condition + ' )'
+                       stream.append('\t\t' + condition)
+               featureSet = v[1].replace(" ", " or ")
+               stream.extend(['\t\t{',
+                                          '\t\t\tlog << tcu::TestLog::Message << "Mandatory feature ' + featureSet + ' not supported" << tcu::TestLog::EndMessage;',
                                           '\t\t\tresult = false;',
                                           '\t\t}',
                                           '\t}',

diff --git a/external/vulkancts/scripts/src/mandatory_features.txt b/external/vulkancts/scripts/src/mandatory_features.txt
index cdbae99..bed79e6 100644 (file)
--- a/external/vulkancts/scripts/src/mandatory_features.txt
+++ b/external/vulkancts/scripts/src/mandatory_features.txt
@@ -6,52 +6,75 @@
 // * structure type enum
 // * required extensions that enable specified feature
 
-VkPhysicalDeviceFeatures                                                               robustBufferAccess                                                                      REQUIREMENTS ()
-VkPhysicalDeviceFeatures                                                               shaderSampledImageArrayDynamicIndexing                          REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceFeatures                                                               shaderStorageBufferArrayDynamicIndexing                         REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDevice8BitStorageFeaturesKHR                                 storageBuffer8BitAccess                                                         REQUIREMENTS ( VK_KHR_8bit_storage )
-VkPhysicalDeviceVulkan11Features                                               multiview                                                                                       REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
-VkPhysicalDeviceMultiviewFeatures                                              multiview                                                                                       REQUIREMENTS ( "ApiVersion(1, 1, 0)" )
-VkPhysicalDeviceMultiviewFeatures                                              multiview                                                                                       REQUIREMENTS ( VK_KHR_multiview )
-VkPhysicalDeviceVariablePointersFeatures                               variablePointersStorageBuffer                                           REQUIREMENTS ( VK_KHR_variable_pointers )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  shaderUniformTexelBufferArrayDynamicIndexing            REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  shaderStorageTexelBufferArrayDynamicIndexing            REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  shaderSampledImageArrayNonUniformIndexing                       REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  shaderStorageBufferArrayNonUniformIndexing                      REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  shaderUniformTexelBufferArrayNonUniformIndexing         REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  descriptorBindingSampledImageUpdateAfterBind            REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  descriptorBindingStorageImageUpdateAfterBind            REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  descriptorBindingStorageBufferUpdateAfterBind           REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  descriptorBindingUniformTexelBufferUpdateAfterBind      REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  descriptorBindingStorageTexelBufferUpdateAfterBind      REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  descriptorBindingUpdateUnusedWhilePending                       REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  descriptorBindingPartiallyBound                                         REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceDescriptorIndexingFeaturesEXT                  runtimeDescriptorArray                                                          REQUIREMENTS ( VK_EXT_descriptor_indexing )
-VkPhysicalDeviceInlineUniformBlockFeaturesEXT                  inlineUniformBlock                                                                      REQUIREMENTS ( VK_EXT_inline_uniform_block )
-VkPhysicalDeviceInlineUniformBlockFeaturesEXT                  descriptorBindingInlineUniformBlockUpdateAfterBind      REQUIREMENTS ( VK_EXT_inline_uniform_block VK_EXT_descriptor_indexing )
-VkPhysicalDeviceScalarBlockLayoutFeaturesEXT                   scalarBlockLayout                                                                       REQUIREMENTS ( VK_EXT_scalar_block_layout )
-VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR uniformBufferStandardLayout                                                     REQUIREMENTS ( VK_KHR_uniform_buffer_standard_layout )
-VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR        pipelineExecutableInfo                                                          REQUIREMENTS ( VK_KHR_pipeline_executable_properties )
-VkPhysicalDeviceSubgroupSizeControlFeaturesEXT                 subgroupSizeControl                                                                     REQUIREMENTS ( VK_EXT_subgroup_size_control )
-VkPhysicalDeviceSubgroupSizeControlFeaturesEXT                 computeFullSubgroups                                                            REQUIREMENTS ( VK_EXT_subgroup_size_control )
-VkPhysicalDeviceVulkan12Features                                               subgroupBroadcastDynamicId                                                      REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
-VkPhysicalDeviceVulkan12Features                                               shaderSubgroupExtendedTypes                                                     REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
-VkPhysicalDeviceVulkan12Features                                               imagelessFramebuffer                                                            REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
-VkPhysicalDeviceVulkan12Features                                               uniformBufferStandardLayout                                                     REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
-VkPhysicalDeviceVulkan12Features                                               separateDepthStencilLayouts                                                     REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
-VkPhysicalDeviceVulkan12Features                                               hostQueryReset                                                                          REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
-VkPhysicalDeviceTimelineSemaphoreFeaturesKHR                   timelineSemaphore                                                                       REQUIREMENTS ( VK_KHR_timeline_semaphore )
-VkPhysicalDeviceVulkan12Features                                               timelineSemaphore                                                                       REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
-VkPhysicalDeviceVulkan12Features                                               shaderUniformTexelBufferArrayDynamicIndexing            REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               shaderStorageTexelBufferArrayDynamicIndexing            REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               shaderSampledImageArrayNonUniformIndexing                       REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               shaderStorageBufferArrayNonUniformIndexing                      REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               shaderUniformTexelBufferArrayNonUniformIndexing         REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               descriptorBindingSampledImageUpdateAfterBind            REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               descriptorBindingStorageImageUpdateAfterBind            REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               descriptorBindingStorageBufferUpdateAfterBind           REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               descriptorBindingUniformTexelBufferUpdateAfterBind      REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               descriptorBindingStorageTexelBufferUpdateAfterBind      REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               descriptorBindingUpdateUnusedWhilePending                       REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               descriptorBindingPartiallyBound                                         REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
-VkPhysicalDeviceVulkan12Features                                               runtimeDescriptorArray                                                          REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceFeatures                                                                       FEATURES ( robustBufferAccess )                                                                 REQUIREMENTS ()
+VkPhysicalDeviceFeatures                                                                       FEATURES ( shaderSampledImageArrayDynamicIndexing )                             REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceFeatures                                                                       FEATURES ( shaderStorageBufferArrayDynamicIndexing )                    REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDevice8BitStorageFeaturesKHR                                         FEATURES ( storageBuffer8BitAccess )                                                    REQUIREMENTS ( VK_KHR_8bit_storage )
+VkPhysicalDeviceVulkan11Features                                                       FEATURES ( multiview )                                                                                  REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
+VkPhysicalDeviceMultiviewFeatures                                                      FEATURES ( multiview )                                                                                  REQUIREMENTS ( "ApiVersion(1, 1, 0)" )
+VkPhysicalDeviceMultiviewFeatures                                                      FEATURES ( multiview )                                                                                  REQUIREMENTS ( VK_KHR_multiview )
+VkPhysicalDeviceVariablePointersFeatures                                       FEATURES ( variablePointersStorageBuffer )                                              REQUIREMENTS ( VK_KHR_variable_pointers )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( shaderUniformTexelBufferArrayDynamicIndexing )               REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( shaderStorageTexelBufferArrayDynamicIndexing )               REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( shaderSampledImageArrayNonUniformIndexing )                  REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( shaderStorageBufferArrayNonUniformIndexing )                 REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( shaderUniformTexelBufferArrayNonUniformIndexing )    REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( descriptorBindingSampledImageUpdateAfterBind )               REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( descriptorBindingStorageImageUpdateAfterBind )               REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( descriptorBindingStorageBufferUpdateAfterBind )              REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( descriptorBindingUniformTexelBufferUpdateAfterBind ) REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( descriptorBindingStorageTexelBufferUpdateAfterBind ) REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( descriptorBindingUpdateUnusedWhilePending )                  REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( descriptorBindingPartiallyBound )                                    REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceDescriptorIndexingFeaturesEXT                          FEATURES ( runtimeDescriptorArray )                                                             REQUIREMENTS ( VK_EXT_descriptor_indexing )
+VkPhysicalDeviceInlineUniformBlockFeaturesEXT                          FEATURES ( inlineUniformBlock )                                                                 REQUIREMENTS ( VK_EXT_inline_uniform_block )
+VkPhysicalDeviceInlineUniformBlockFeaturesEXT                          FEATURES ( descriptorBindingInlineUniformBlockUpdateAfterBind ) REQUIREMENTS ( VK_EXT_inline_uniform_block VK_EXT_descriptor_indexing )
+VkPhysicalDeviceScalarBlockLayoutFeaturesEXT                           FEATURES ( scalarBlockLayout )                                                                  REQUIREMENTS ( VK_EXT_scalar_block_layout )
+VkPhysicalDeviceUniformBufferStandardLayoutFeaturesKHR         FEATURES ( uniformBufferStandardLayout )                                                REQUIREMENTS ( VK_KHR_uniform_buffer_standard_layout )
+VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR                FEATURES ( pipelineExecutableInfo )                                                             REQUIREMENTS ( VK_KHR_pipeline_executable_properties )
+VkPhysicalDeviceSubgroupSizeControlFeaturesEXT                         FEATURES ( subgroupSizeControl )                                                                REQUIREMENTS ( VK_EXT_subgroup_size_control )
+VkPhysicalDeviceSubgroupSizeControlFeaturesEXT                         FEATURES ( computeFullSubgroups )                                                               REQUIREMENTS ( VK_EXT_subgroup_size_control )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( subgroupBroadcastDynamicId )                                                 REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
+VkPhysicalDeviceShaderSubgroupExtendedTypesFeaturesKHR         FEATURES ( shaderSubgroupExtendedTypes )                                                REQUIREMENTS ( VK_KHR_shader_subgroup_extended_types )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( shaderSubgroupExtendedTypes )                                                REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
+VkPhysicalDeviceImagelessFramebufferFeaturesKHR                        FEATURES ( imagelessFramebuffer )                                                               REQUIREMENTS ( VK_KHR_imageless_framebuffer )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( imagelessFramebuffer )                                                               REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( uniformBufferStandardLayout )                                                REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
+VkPhysicalDeviceSeparateDepthStencilLayoutsFeaturesKHR         FEATURES ( separateDepthStencilLayouts )                                                REQUIREMENTS ( VK_KHR_separate_depth_stencil_layouts )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( separateDepthStencilLayouts )                                                REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
+VkPhysicalDeviceHostQueryResetFeaturesEXT                                      FEATURES ( hostQueryReset )                                                                             REQUIREMENTS ( VK_EXT_host_query_reset )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( hostQueryReset )                                                                             REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
+VkPhysicalDeviceTimelineSemaphoreFeaturesKHR                           FEATURES ( timelineSemaphore )                                                                  REQUIREMENTS ( VK_KHR_timeline_semaphore )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( timelineSemaphore )                                                                  REQUIREMENTS ( "ApiVersion(1, 2, 0)" )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( shaderUniformTexelBufferArrayDynamicIndexing )               REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( shaderStorageTexelBufferArrayDynamicIndexing )               REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( shaderSampledImageArrayNonUniformIndexing )                  REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( shaderStorageBufferArrayNonUniformIndexing )                 REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( shaderUniformTexelBufferArrayNonUniformIndexing )    REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( descriptorBindingSampledImageUpdateAfterBind )               REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( descriptorBindingStorageImageUpdateAfterBind )               REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( descriptorBindingStorageBufferUpdateAfterBind )              REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( descriptorBindingUniformTexelBufferUpdateAfterBind ) REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( descriptorBindingStorageTexelBufferUpdateAfterBind ) REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( descriptorBindingUpdateUnusedWhilePending )                  REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( descriptorBindingPartiallyBound )                                    REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceVulkan12Features                                                       FEATURES ( runtimeDescriptorArray )                                                             REQUIREMENTS ( "ApiVersion(1, 2, 0)" physicalDeviceVulkan12Features.descriptorIndexing )
+VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT           FEATURES ( textureCompressionASTC_HDR )                                                 REQUIREMENTS ( VK_EXT_texture_compression_astc_hdr )
+VkPhysicalDeviceDepthClipEnableFeaturesEXT                                     FEATURES ( depthClipEnable )                                                                    REQUIREMENTS ( VK_EXT_depth_clip_enable )
+VkPhysicalDeviceMemoryPriorityFeaturesEXT                                      FEATURES ( memoryPriority )                                                                             REQUIREMENTS ( VK_EXT_memory_priority )
+VkPhysicalDeviceYcbcrImageArraysFeaturesEXT                                    FEATURES ( ycbcrImageArrays )                                                                   REQUIREMENTS ( VK_EXT_ycbcr_image_arrays )
+VkPhysicalDeviceIndexTypeUint8FeaturesEXT                                      FEATURES ( indexTypeUint8 )                                                                             REQUIREMENTS ( VK_EXT_index_type_uint8 )
+VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT      FEATURES ( shaderDemoteToHelperInvocation )                                             REQUIREMENTS ( VK_EXT_shader_demote_to_helper_invocation )
+VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT                                FEATURES ( texelBufferAlignment )                                                               REQUIREMENTS ( VK_EXT_texel_buffer_alignment )
+VkPhysicalDeviceVulkanMemoryModelFeaturesKHR                           FEATURES ( vulkanMemoryModel )                                                                  REQUIREMENTS ( VK_KHR_vulkan_memory_model )
+VkPhysicalDeviceBufferDeviceAddressFeaturesKHR                         FEATURES ( bufferDeviceAddress )                                                                REQUIREMENTS ( VK_KHR_buffer_device_address )
+VkPhysicalDevicePerformanceQueryFeaturesKHR                                    FEATURES ( performanceCounterQueryPools )                                               REQUIREMENTS ( VK_KHR_performance_query )
+VkPhysicalDeviceTransformFeedbackFeaturesEXT                           FEATURES ( transformFeedback )                                                                  REQUIREMENTS ( VK_EXT_transform_feedback )
+VkPhysicalDeviceConditionalRenderingFeaturesEXT                                FEATURES ( conditionalRendering )                                                               REQUIREMENTS ( VK_EXT_conditional_rendering )
+VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT                      FEATURES ( vertexAttributeInstanceRateDivisor )                                 REQUIREMENTS ( VK_EXT_vertex_attribute_divisor )
+VkPhysicalDeviceFragmentDensityMapFeaturesEXT                          FEATURES ( fragmentDensityMap )                                                                 REQUIREMENTS ( VK_EXT_fragment_density_map )
+VkPhysicalDeviceShaderClockFeaturesKHR                                         FEATURES ( shaderSubgroupClock )                                                                REQUIREMENTS ( VK_KHR_shader_clock )
+VkPhysicalDeviceShaderAtomicInt64FeaturesKHR                           FEATURES ( shaderBufferInt64Atomics )                                                   REQUIREMENTS ( VK_KHR_shader_atomic_int64 )
+VkPhysicalDeviceShaderFloat16Int8Features                                      FEATURES ( shaderFloat16 shaderInt8 )                                                   REQUIREMENTS ( VK_KHR_shader_float16_int8 )
+VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT                     FEATURES ( fragmentShaderSampleInterlock fragmentShaderPixelInterlock fragmentShaderShadingRateInterlock )                                              REQUIREMENTS ( VK_EXT_fragment_shader_interlock )
+VkPhysicalDeviceLineRasterizationFeaturesEXT                           FEATURES ( rectangularLines bresenhamLines smoothLines stippledRectangularLines stippledBresenhamLines stippledSmoothLines )    REQUIREMENTS ( VK_EXT_line_rasterization )