external/vulkancts/framework/vulkan/generated/vulkan/vkMandatoryFeatures.inl

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  * This file was generated by /scripts/gen_framework.py
   4  */
   5
   6 bool canUseFeaturesStruct (const vector<VkExtensionProperties>& deviceExtensions, uint32_t usedApiVersion, const char* extension)
   7 {
   8         return (isExtensionStructSupported(deviceExtensions, RequiredExtension(extension))
   9                         || isCoreDeviceExtension(usedApiVersion, extension));
  10 }
  11
  12 bool checkMandatoryFeatures(const vkt::Context& context)
  13 {
  14         if (!context.isInstanceFunctionalitySupported("VK_KHR_get_physical_device_properties2"))
  15                 TCU_THROW(NotSupportedError, "Extension VK_KHR_get_physical_device_properties2 is not present");
  16
  17         VkPhysicalDevice                                        physicalDevice          = context.getPhysicalDevice();
  18         const InstanceInterface&                        vki                                     = context.getInstanceInterface();
  19         const vector<VkExtensionProperties>     deviceExtensions        = enumerateDeviceExtensionProperties(vki, physicalDevice, DE_NULL);
  20         const uint32_t                                          usedApiVersion          = context.getUsedApiVersion();
  21
  22         tcu::TestLog& log = context.getTestContext().getLog();
  23         vk::VkPhysicalDeviceFeatures2 coreFeatures;
  24         deMemset(&coreFeatures, 0, sizeof(coreFeatures));
  25         coreFeatures.sType = VK_STRUCTURE_TYPE_PHYSICAL_DEVICE_FEATURES_2;
  26         void** nextPtr = &coreFeatures.pNext;
  27
  28         vk::VkPhysicalDevice16BitStorageFeatures physicalDevice16BitStorageFeatures;
  29         deMemset(&physicalDevice16BitStorageFeatures, 0, sizeof(physicalDevice16BitStorageFeatures));
  30
  31         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_16bit_storage") )
  32         {
  33                 physicalDevice16BitStorageFeatures.sType = getStructureType<VkPhysicalDevice16BitStorageFeatures>();
  34                 *nextPtr = &physicalDevice16BitStorageFeatures;
  35                 nextPtr  = &physicalDevice16BitStorageFeatures.pNext;
  36         }
  37
  38         vk::VkPhysicalDevice4444FormatsFeaturesEXT physicalDevice4444FormatsFeaturesEXT;
  39         deMemset(&physicalDevice4444FormatsFeaturesEXT, 0, sizeof(physicalDevice4444FormatsFeaturesEXT));
  40
  41         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_4444_formats") )
  42         {
  43                 physicalDevice4444FormatsFeaturesEXT.sType = getStructureType<VkPhysicalDevice4444FormatsFeaturesEXT>();
  44                 *nextPtr = &physicalDevice4444FormatsFeaturesEXT;
  45                 nextPtr  = &physicalDevice4444FormatsFeaturesEXT.pNext;
  46         }
  47
  48         vk::VkPhysicalDevice8BitStorageFeatures physicalDevice8BitStorageFeatures;
  49         deMemset(&physicalDevice8BitStorageFeatures, 0, sizeof(physicalDevice8BitStorageFeatures));
  50
  51         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_8bit_storage") )
  52         {
  53                 physicalDevice8BitStorageFeatures.sType = getStructureType<VkPhysicalDevice8BitStorageFeatures>();
  54                 *nextPtr = &physicalDevice8BitStorageFeatures;
  55                 nextPtr  = &physicalDevice8BitStorageFeatures.pNext;
  56         }
  57
  58         vk::VkPhysicalDeviceAccelerationStructureFeaturesKHR physicalDeviceAccelerationStructureFeaturesKHR;
  59         deMemset(&physicalDeviceAccelerationStructureFeaturesKHR, 0, sizeof(physicalDeviceAccelerationStructureFeaturesKHR));
  60
  61         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_acceleration_structure") )
  62         {
  63                 physicalDeviceAccelerationStructureFeaturesKHR.sType = getStructureType<VkPhysicalDeviceAccelerationStructureFeaturesKHR>();
  64                 *nextPtr = &physicalDeviceAccelerationStructureFeaturesKHR;
  65                 nextPtr  = &physicalDeviceAccelerationStructureFeaturesKHR.pNext;
  66         }
  67
  68         vk::VkPhysicalDeviceAddressBindingReportFeaturesEXT physicalDeviceAddressBindingReportFeaturesEXT;
  69         deMemset(&physicalDeviceAddressBindingReportFeaturesEXT, 0, sizeof(physicalDeviceAddressBindingReportFeaturesEXT));
  70
  71         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_device_address_binding_report") )
  72         {
  73                 physicalDeviceAddressBindingReportFeaturesEXT.sType = getStructureType<VkPhysicalDeviceAddressBindingReportFeaturesEXT>();
  74                 *nextPtr = &physicalDeviceAddressBindingReportFeaturesEXT;
  75                 nextPtr  = &physicalDeviceAddressBindingReportFeaturesEXT.pNext;
  76         }
  77
  78 #if defined(CTS_USES_VULKAN)
  79         vk::VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
  80         deMemset(&physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT, 0, sizeof(physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT));
  81
  82         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_attachment_feedback_loop_layout") )
  83         {
  84                 physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.sType = getStructureType<VkPhysicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT>();
  85                 *nextPtr = &physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT;
  86                 nextPtr  = &physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.pNext;
  87         }
  88 #endif // defined(CTS_USES_VULKAN)
  89
  90 #if defined(CTS_USES_VULKAN)
  91         vk::VkPhysicalDeviceBorderColorSwizzleFeaturesEXT physicalDeviceBorderColorSwizzleFeaturesEXT;
  92         deMemset(&physicalDeviceBorderColorSwizzleFeaturesEXT, 0, sizeof(physicalDeviceBorderColorSwizzleFeaturesEXT));
  93
  94         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_border_color_swizzle") )
  95         {
  96                 physicalDeviceBorderColorSwizzleFeaturesEXT.sType = getStructureType<VkPhysicalDeviceBorderColorSwizzleFeaturesEXT>();
  97                 *nextPtr = &physicalDeviceBorderColorSwizzleFeaturesEXT;
  98                 nextPtr  = &physicalDeviceBorderColorSwizzleFeaturesEXT.pNext;
  99         }
 100 #endif // defined(CTS_USES_VULKAN)
 101
 102         vk::VkPhysicalDeviceBufferDeviceAddressFeatures physicalDeviceBufferDeviceAddressFeatures;
 103         deMemset(&physicalDeviceBufferDeviceAddressFeatures, 0, sizeof(physicalDeviceBufferDeviceAddressFeatures));
 104
 105         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_buffer_device_address") )
 106         {
 107                 physicalDeviceBufferDeviceAddressFeatures.sType = getStructureType<VkPhysicalDeviceBufferDeviceAddressFeatures>();
 108                 *nextPtr = &physicalDeviceBufferDeviceAddressFeatures;
 109                 nextPtr  = &physicalDeviceBufferDeviceAddressFeatures.pNext;
 110         }
 111
 112         vk::VkPhysicalDeviceColorWriteEnableFeaturesEXT physicalDeviceColorWriteEnableFeaturesEXT;
 113         deMemset(&physicalDeviceColorWriteEnableFeaturesEXT, 0, sizeof(physicalDeviceColorWriteEnableFeaturesEXT));
 114
 115         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_color_write_enable") )
 116         {
 117                 physicalDeviceColorWriteEnableFeaturesEXT.sType = getStructureType<VkPhysicalDeviceColorWriteEnableFeaturesEXT>();
 118                 *nextPtr = &physicalDeviceColorWriteEnableFeaturesEXT;
 119                 nextPtr  = &physicalDeviceColorWriteEnableFeaturesEXT.pNext;
 120         }
 121
 122         vk::VkPhysicalDeviceConditionalRenderingFeaturesEXT physicalDeviceConditionalRenderingFeaturesEXT;
 123         deMemset(&physicalDeviceConditionalRenderingFeaturesEXT, 0, sizeof(physicalDeviceConditionalRenderingFeaturesEXT));
 124
 125         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_conditional_rendering") )
 126         {
 127                 physicalDeviceConditionalRenderingFeaturesEXT.sType = getStructureType<VkPhysicalDeviceConditionalRenderingFeaturesEXT>();
 128                 *nextPtr = &physicalDeviceConditionalRenderingFeaturesEXT;
 129                 nextPtr  = &physicalDeviceConditionalRenderingFeaturesEXT.pNext;
 130         }
 131
 132         vk::VkPhysicalDeviceDepthClampZeroOneFeaturesEXT physicalDeviceDepthClampZeroOneFeaturesEXT;
 133         deMemset(&physicalDeviceDepthClampZeroOneFeaturesEXT, 0, sizeof(physicalDeviceDepthClampZeroOneFeaturesEXT));
 134
 135         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_depth_clamp_zero_one") )
 136         {
 137                 physicalDeviceDepthClampZeroOneFeaturesEXT.sType = getStructureType<VkPhysicalDeviceDepthClampZeroOneFeaturesEXT>();
 138                 *nextPtr = &physicalDeviceDepthClampZeroOneFeaturesEXT;
 139                 nextPtr  = &physicalDeviceDepthClampZeroOneFeaturesEXT.pNext;
 140         }
 141
 142         vk::VkPhysicalDeviceDepthClipControlFeaturesEXT physicalDeviceDepthClipControlFeaturesEXT;
 143         deMemset(&physicalDeviceDepthClipControlFeaturesEXT, 0, sizeof(physicalDeviceDepthClipControlFeaturesEXT));
 144
 145         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_depth_clip_control") )
 146         {
 147                 physicalDeviceDepthClipControlFeaturesEXT.sType = getStructureType<VkPhysicalDeviceDepthClipControlFeaturesEXT>();
 148                 *nextPtr = &physicalDeviceDepthClipControlFeaturesEXT;
 149                 nextPtr  = &physicalDeviceDepthClipControlFeaturesEXT.pNext;
 150         }
 151
 152         vk::VkPhysicalDeviceDepthClipEnableFeaturesEXT physicalDeviceDepthClipEnableFeaturesEXT;
 153         deMemset(&physicalDeviceDepthClipEnableFeaturesEXT, 0, sizeof(physicalDeviceDepthClipEnableFeaturesEXT));
 154
 155         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_depth_clip_enable") )
 156         {
 157                 physicalDeviceDepthClipEnableFeaturesEXT.sType = getStructureType<VkPhysicalDeviceDepthClipEnableFeaturesEXT>();
 158                 *nextPtr = &physicalDeviceDepthClipEnableFeaturesEXT;
 159                 nextPtr  = &physicalDeviceDepthClipEnableFeaturesEXT.pNext;
 160         }
 161
 162         vk::VkPhysicalDeviceDescriptorBufferFeaturesEXT physicalDeviceDescriptorBufferFeaturesEXT;
 163         deMemset(&physicalDeviceDescriptorBufferFeaturesEXT, 0, sizeof(physicalDeviceDescriptorBufferFeaturesEXT));
 164
 165         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_descriptor_buffer") )
 166         {
 167                 physicalDeviceDescriptorBufferFeaturesEXT.sType = getStructureType<VkPhysicalDeviceDescriptorBufferFeaturesEXT>();
 168                 *nextPtr = &physicalDeviceDescriptorBufferFeaturesEXT;
 169                 nextPtr  = &physicalDeviceDescriptorBufferFeaturesEXT.pNext;
 170         }
 171
 172         vk::VkPhysicalDeviceDescriptorIndexingFeatures physicalDeviceDescriptorIndexingFeatures;
 173         deMemset(&physicalDeviceDescriptorIndexingFeatures, 0, sizeof(physicalDeviceDescriptorIndexingFeatures));
 174
 175         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_descriptor_indexing") )
 176         {
 177                 physicalDeviceDescriptorIndexingFeatures.sType = getStructureType<VkPhysicalDeviceDescriptorIndexingFeatures>();
 178                 *nextPtr = &physicalDeviceDescriptorIndexingFeatures;
 179                 nextPtr  = &physicalDeviceDescriptorIndexingFeatures.pNext;
 180         }
 181
 182         vk::VkPhysicalDeviceExtendedDynamicState2FeaturesEXT physicalDeviceExtendedDynamicState2FeaturesEXT;
 183         deMemset(&physicalDeviceExtendedDynamicState2FeaturesEXT, 0, sizeof(physicalDeviceExtendedDynamicState2FeaturesEXT));
 184
 185         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_extended_dynamic_state2") )
 186         {
 187                 physicalDeviceExtendedDynamicState2FeaturesEXT.sType = getStructureType<VkPhysicalDeviceExtendedDynamicState2FeaturesEXT>();
 188                 *nextPtr = &physicalDeviceExtendedDynamicState2FeaturesEXT;
 189                 nextPtr  = &physicalDeviceExtendedDynamicState2FeaturesEXT.pNext;
 190         }
 191
 192         vk::VkPhysicalDeviceFaultFeaturesEXT physicalDeviceFaultFeaturesEXT;
 193         deMemset(&physicalDeviceFaultFeaturesEXT, 0, sizeof(physicalDeviceFaultFeaturesEXT));
 194
 195         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_device_fault") )
 196         {
 197                 physicalDeviceFaultFeaturesEXT.sType = getStructureType<VkPhysicalDeviceFaultFeaturesEXT>();
 198                 *nextPtr = &physicalDeviceFaultFeaturesEXT;
 199                 nextPtr  = &physicalDeviceFaultFeaturesEXT.pNext;
 200         }
 201
 202         vk::VkPhysicalDeviceFragmentDensityMapFeaturesEXT physicalDeviceFragmentDensityMapFeaturesEXT;
 203         deMemset(&physicalDeviceFragmentDensityMapFeaturesEXT, 0, sizeof(physicalDeviceFragmentDensityMapFeaturesEXT));
 204
 205         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_fragment_density_map") )
 206         {
 207                 physicalDeviceFragmentDensityMapFeaturesEXT.sType = getStructureType<VkPhysicalDeviceFragmentDensityMapFeaturesEXT>();
 208                 *nextPtr = &physicalDeviceFragmentDensityMapFeaturesEXT;
 209                 nextPtr  = &physicalDeviceFragmentDensityMapFeaturesEXT.pNext;
 210         }
 211
 212         vk::VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT physicalDeviceFragmentShaderInterlockFeaturesEXT;
 213         deMemset(&physicalDeviceFragmentShaderInterlockFeaturesEXT, 0, sizeof(physicalDeviceFragmentShaderInterlockFeaturesEXT));
 214
 215         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_fragment_shader_interlock") )
 216         {
 217                 physicalDeviceFragmentShaderInterlockFeaturesEXT.sType = getStructureType<VkPhysicalDeviceFragmentShaderInterlockFeaturesEXT>();
 218                 *nextPtr = &physicalDeviceFragmentShaderInterlockFeaturesEXT;
 219                 nextPtr  = &physicalDeviceFragmentShaderInterlockFeaturesEXT.pNext;
 220         }
 221
 222 #if defined(CTS_USES_VULKAN)
 223         vk::VkPhysicalDeviceFragmentShadingRateFeaturesKHR physicalDeviceFragmentShadingRateFeaturesKHR;
 224         deMemset(&physicalDeviceFragmentShadingRateFeaturesKHR, 0, sizeof(physicalDeviceFragmentShadingRateFeaturesKHR));
 225
 226         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_fragment_shading_rate") )
 227         {
 228                 physicalDeviceFragmentShadingRateFeaturesKHR.sType = getStructureType<VkPhysicalDeviceFragmentShadingRateFeaturesKHR>();
 229                 *nextPtr = &physicalDeviceFragmentShadingRateFeaturesKHR;
 230                 nextPtr  = &physicalDeviceFragmentShadingRateFeaturesKHR.pNext;
 231         }
 232 #endif // defined(CTS_USES_VULKAN)
 233
 234         vk::VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR physicalDeviceGlobalPriorityQueryFeaturesKHR;
 235         deMemset(&physicalDeviceGlobalPriorityQueryFeaturesKHR, 0, sizeof(physicalDeviceGlobalPriorityQueryFeaturesKHR));
 236
 237         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_global_priority") || canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_global_priority_query") )
 238         {
 239                 physicalDeviceGlobalPriorityQueryFeaturesKHR.sType = getStructureType<VkPhysicalDeviceGlobalPriorityQueryFeaturesKHR>();
 240                 *nextPtr = &physicalDeviceGlobalPriorityQueryFeaturesKHR;
 241                 nextPtr  = &physicalDeviceGlobalPriorityQueryFeaturesKHR.pNext;
 242         }
 243
 244         vk::VkPhysicalDeviceHostQueryResetFeatures physicalDeviceHostQueryResetFeatures;
 245         deMemset(&physicalDeviceHostQueryResetFeatures, 0, sizeof(physicalDeviceHostQueryResetFeatures));
 246
 247         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_host_query_reset") )
 248         {
 249                 physicalDeviceHostQueryResetFeatures.sType = getStructureType<VkPhysicalDeviceHostQueryResetFeatures>();
 250                 *nextPtr = &physicalDeviceHostQueryResetFeatures;
 251                 nextPtr  = &physicalDeviceHostQueryResetFeatures.pNext;
 252         }
 253
 254 #if defined(CTS_USES_VULKAN)
 255         vk::VkPhysicalDeviceImage2DViewOf3DFeaturesEXT physicalDeviceImage2DViewOf3DFeaturesEXT;
 256         deMemset(&physicalDeviceImage2DViewOf3DFeaturesEXT, 0, sizeof(physicalDeviceImage2DViewOf3DFeaturesEXT));
 257
 258         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_image_2d_view_of_3d") )
 259         {
 260                 physicalDeviceImage2DViewOf3DFeaturesEXT.sType = getStructureType<VkPhysicalDeviceImage2DViewOf3DFeaturesEXT>();
 261                 *nextPtr = &physicalDeviceImage2DViewOf3DFeaturesEXT;
 262                 nextPtr  = &physicalDeviceImage2DViewOf3DFeaturesEXT.pNext;
 263         }
 264 #endif // defined(CTS_USES_VULKAN)
 265
 266         vk::VkPhysicalDeviceImageCompressionControlFeaturesEXT physicalDeviceImageCompressionControlFeaturesEXT;
 267         deMemset(&physicalDeviceImageCompressionControlFeaturesEXT, 0, sizeof(physicalDeviceImageCompressionControlFeaturesEXT));
 268
 269         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_image_compression_control") )
 270         {
 271                 physicalDeviceImageCompressionControlFeaturesEXT.sType = getStructureType<VkPhysicalDeviceImageCompressionControlFeaturesEXT>();
 272                 *nextPtr = &physicalDeviceImageCompressionControlFeaturesEXT;
 273                 nextPtr  = &physicalDeviceImageCompressionControlFeaturesEXT.pNext;
 274         }
 275
 276         vk::VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT physicalDeviceImageCompressionControlSwapchainFeaturesEXT;
 277         deMemset(&physicalDeviceImageCompressionControlSwapchainFeaturesEXT, 0, sizeof(physicalDeviceImageCompressionControlSwapchainFeaturesEXT));
 278
 279         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_image_compression_control_swapchain") )
 280         {
 281                 physicalDeviceImageCompressionControlSwapchainFeaturesEXT.sType = getStructureType<VkPhysicalDeviceImageCompressionControlSwapchainFeaturesEXT>();
 282                 *nextPtr = &physicalDeviceImageCompressionControlSwapchainFeaturesEXT;
 283                 nextPtr  = &physicalDeviceImageCompressionControlSwapchainFeaturesEXT.pNext;
 284         }
 285
 286         vk::VkPhysicalDeviceImagelessFramebufferFeatures physicalDeviceImagelessFramebufferFeatures;
 287         deMemset(&physicalDeviceImagelessFramebufferFeatures, 0, sizeof(physicalDeviceImagelessFramebufferFeatures));
 288
 289         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_imageless_framebuffer") )
 290         {
 291                 physicalDeviceImagelessFramebufferFeatures.sType = getStructureType<VkPhysicalDeviceImagelessFramebufferFeatures>();
 292                 *nextPtr = &physicalDeviceImagelessFramebufferFeatures;
 293                 nextPtr  = &physicalDeviceImagelessFramebufferFeatures.pNext;
 294         }
 295
 296         vk::VkPhysicalDeviceIndexTypeUint8FeaturesEXT physicalDeviceIndexTypeUint8FeaturesEXT;
 297         deMemset(&physicalDeviceIndexTypeUint8FeaturesEXT, 0, sizeof(physicalDeviceIndexTypeUint8FeaturesEXT));
 298
 299         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_index_type_uint8") )
 300         {
 301                 physicalDeviceIndexTypeUint8FeaturesEXT.sType = getStructureType<VkPhysicalDeviceIndexTypeUint8FeaturesEXT>();
 302                 *nextPtr = &physicalDeviceIndexTypeUint8FeaturesEXT;
 303                 nextPtr  = &physicalDeviceIndexTypeUint8FeaturesEXT.pNext;
 304         }
 305
 306         vk::VkPhysicalDeviceInlineUniformBlockFeaturesEXT physicalDeviceInlineUniformBlockFeaturesEXT;
 307         deMemset(&physicalDeviceInlineUniformBlockFeaturesEXT, 0, sizeof(physicalDeviceInlineUniformBlockFeaturesEXT));
 308
 309         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_inline_uniform_block") )
 310         {
 311                 physicalDeviceInlineUniformBlockFeaturesEXT.sType = getStructureType<VkPhysicalDeviceInlineUniformBlockFeaturesEXT>();
 312                 *nextPtr = &physicalDeviceInlineUniformBlockFeaturesEXT;
 313                 nextPtr  = &physicalDeviceInlineUniformBlockFeaturesEXT.pNext;
 314         }
 315
 316         vk::VkPhysicalDeviceLegacyDitheringFeaturesEXT physicalDeviceLegacyDitheringFeaturesEXT;
 317         deMemset(&physicalDeviceLegacyDitheringFeaturesEXT, 0, sizeof(physicalDeviceLegacyDitheringFeaturesEXT));
 318
 319         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_legacy_dithering") )
 320         {
 321                 physicalDeviceLegacyDitheringFeaturesEXT.sType = getStructureType<VkPhysicalDeviceLegacyDitheringFeaturesEXT>();
 322                 *nextPtr = &physicalDeviceLegacyDitheringFeaturesEXT;
 323                 nextPtr  = &physicalDeviceLegacyDitheringFeaturesEXT.pNext;
 324         }
 325
 326         vk::VkPhysicalDeviceLineRasterizationFeaturesEXT physicalDeviceLineRasterizationFeaturesEXT;
 327         deMemset(&physicalDeviceLineRasterizationFeaturesEXT, 0, sizeof(physicalDeviceLineRasterizationFeaturesEXT));
 328
 329         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_line_rasterization") )
 330         {
 331                 physicalDeviceLineRasterizationFeaturesEXT.sType = getStructureType<VkPhysicalDeviceLineRasterizationFeaturesEXT>();
 332                 *nextPtr = &physicalDeviceLineRasterizationFeaturesEXT;
 333                 nextPtr  = &physicalDeviceLineRasterizationFeaturesEXT.pNext;
 334         }
 335
 336         vk::VkPhysicalDeviceMemoryPriorityFeaturesEXT physicalDeviceMemoryPriorityFeaturesEXT;
 337         deMemset(&physicalDeviceMemoryPriorityFeaturesEXT, 0, sizeof(physicalDeviceMemoryPriorityFeaturesEXT));
 338
 339         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_memory_priority") )
 340         {
 341                 physicalDeviceMemoryPriorityFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMemoryPriorityFeaturesEXT>();
 342                 *nextPtr = &physicalDeviceMemoryPriorityFeaturesEXT;
 343                 nextPtr  = &physicalDeviceMemoryPriorityFeaturesEXT.pNext;
 344         }
 345
 346 #if defined(CTS_USES_VULKAN)
 347         vk::VkPhysicalDeviceMeshShaderFeaturesEXT physicalDeviceMeshShaderFeaturesEXT;
 348         deMemset(&physicalDeviceMeshShaderFeaturesEXT, 0, sizeof(physicalDeviceMeshShaderFeaturesEXT));
 349
 350         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_mesh_shader") )
 351         {
 352                 physicalDeviceMeshShaderFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMeshShaderFeaturesEXT>();
 353                 *nextPtr = &physicalDeviceMeshShaderFeaturesEXT;
 354                 nextPtr  = &physicalDeviceMeshShaderFeaturesEXT.pNext;
 355         }
 356 #endif // defined(CTS_USES_VULKAN)
 357
 358         vk::VkPhysicalDeviceMultiDrawFeaturesEXT physicalDeviceMultiDrawFeaturesEXT;
 359         deMemset(&physicalDeviceMultiDrawFeaturesEXT, 0, sizeof(physicalDeviceMultiDrawFeaturesEXT));
 360
 361         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_multi_draw") )
 362         {
 363                 physicalDeviceMultiDrawFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMultiDrawFeaturesEXT>();
 364                 *nextPtr = &physicalDeviceMultiDrawFeaturesEXT;
 365                 nextPtr  = &physicalDeviceMultiDrawFeaturesEXT.pNext;
 366         }
 367
 368         vk::VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
 369         deMemset(&physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT, 0, sizeof(physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT));
 370
 371         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_multisampled_render_to_single_sampled") )
 372         {
 373                 physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMultisampledRenderToSingleSampledFeaturesEXT>();
 374                 *nextPtr = &physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT;
 375                 nextPtr  = &physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.pNext;
 376         }
 377
 378         vk::VkPhysicalDeviceMultiviewFeatures physicalDeviceMultiviewFeatures;
 379         deMemset(&physicalDeviceMultiviewFeatures, 0, sizeof(physicalDeviceMultiviewFeatures));
 380
 381         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_multiview") )
 382         {
 383                 physicalDeviceMultiviewFeatures.sType = getStructureType<VkPhysicalDeviceMultiviewFeatures>();
 384                 *nextPtr = &physicalDeviceMultiviewFeatures;
 385                 nextPtr  = &physicalDeviceMultiviewFeatures.pNext;
 386         }
 387
 388         vk::VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT physicalDeviceMutableDescriptorTypeFeaturesEXT;
 389         deMemset(&physicalDeviceMutableDescriptorTypeFeaturesEXT, 0, sizeof(physicalDeviceMutableDescriptorTypeFeaturesEXT));
 390
 391         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_VALVE_mutable_descriptor_type") || canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_mutable_descriptor_type") )
 392         {
 393                 physicalDeviceMutableDescriptorTypeFeaturesEXT.sType = getStructureType<VkPhysicalDeviceMutableDescriptorTypeFeaturesEXT>();
 394                 *nextPtr = &physicalDeviceMutableDescriptorTypeFeaturesEXT;
 395                 nextPtr  = &physicalDeviceMutableDescriptorTypeFeaturesEXT.pNext;
 396         }
 397
 398         vk::VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE physicalDeviceMutableDescriptorTypeFeaturesVALVE;
 399         deMemset(&physicalDeviceMutableDescriptorTypeFeaturesVALVE, 0, sizeof(physicalDeviceMutableDescriptorTypeFeaturesVALVE));
 400
 401         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_VALVE_mutable_descriptor_type") || canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_mutable_descriptor_type") )
 402         {
 403                 physicalDeviceMutableDescriptorTypeFeaturesVALVE.sType = getStructureType<VkPhysicalDeviceMutableDescriptorTypeFeaturesVALVE>();
 404                 *nextPtr = &physicalDeviceMutableDescriptorTypeFeaturesVALVE;
 405                 nextPtr  = &physicalDeviceMutableDescriptorTypeFeaturesVALVE.pNext;
 406         }
 407
 408 #if defined(CTS_USES_VULKAN)
 409         vk::VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT physicalDeviceNonSeamlessCubeMapFeaturesEXT;
 410         deMemset(&physicalDeviceNonSeamlessCubeMapFeaturesEXT, 0, sizeof(physicalDeviceNonSeamlessCubeMapFeaturesEXT));
 411
 412         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_non_seamless_cube_map") )
 413         {
 414                 physicalDeviceNonSeamlessCubeMapFeaturesEXT.sType = getStructureType<VkPhysicalDeviceNonSeamlessCubeMapFeaturesEXT>();
 415                 *nextPtr = &physicalDeviceNonSeamlessCubeMapFeaturesEXT;
 416                 nextPtr  = &physicalDeviceNonSeamlessCubeMapFeaturesEXT.pNext;
 417         }
 418 #endif // defined(CTS_USES_VULKAN)
 419
 420 #if defined(CTS_USES_VULKAN)
 421         vk::VkPhysicalDeviceOpacityMicromapFeaturesEXT physicalDeviceOpacityMicromapFeaturesEXT;
 422         deMemset(&physicalDeviceOpacityMicromapFeaturesEXT, 0, sizeof(physicalDeviceOpacityMicromapFeaturesEXT));
 423
 424         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_opacity_micromap") )
 425         {
 426                 physicalDeviceOpacityMicromapFeaturesEXT.sType = getStructureType<VkPhysicalDeviceOpacityMicromapFeaturesEXT>();
 427                 *nextPtr = &physicalDeviceOpacityMicromapFeaturesEXT;
 428                 nextPtr  = &physicalDeviceOpacityMicromapFeaturesEXT.pNext;
 429         }
 430 #endif // defined(CTS_USES_VULKAN)
 431
 432 #if defined(CTS_USES_VULKAN)
 433         vk::VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT physicalDevicePageableDeviceLocalMemoryFeaturesEXT;
 434         deMemset(&physicalDevicePageableDeviceLocalMemoryFeaturesEXT, 0, sizeof(physicalDevicePageableDeviceLocalMemoryFeaturesEXT));
 435
 436         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_pageable_device_local_memory") )
 437         {
 438                 physicalDevicePageableDeviceLocalMemoryFeaturesEXT.sType = getStructureType<VkPhysicalDevicePageableDeviceLocalMemoryFeaturesEXT>();
 439                 *nextPtr = &physicalDevicePageableDeviceLocalMemoryFeaturesEXT;
 440                 nextPtr  = &physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pNext;
 441         }
 442 #endif // defined(CTS_USES_VULKAN)
 443
 444         vk::VkPhysicalDevicePerformanceQueryFeaturesKHR physicalDevicePerformanceQueryFeaturesKHR;
 445         deMemset(&physicalDevicePerformanceQueryFeaturesKHR, 0, sizeof(physicalDevicePerformanceQueryFeaturesKHR));
 446
 447         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_performance_query") )
 448         {
 449                 physicalDevicePerformanceQueryFeaturesKHR.sType = getStructureType<VkPhysicalDevicePerformanceQueryFeaturesKHR>();
 450                 *nextPtr = &physicalDevicePerformanceQueryFeaturesKHR;
 451                 nextPtr  = &physicalDevicePerformanceQueryFeaturesKHR.pNext;
 452         }
 453
 454         vk::VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR physicalDevicePipelineExecutablePropertiesFeaturesKHR;
 455         deMemset(&physicalDevicePipelineExecutablePropertiesFeaturesKHR, 0, sizeof(physicalDevicePipelineExecutablePropertiesFeaturesKHR));
 456
 457         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_pipeline_executable_properties") )
 458         {
 459                 physicalDevicePipelineExecutablePropertiesFeaturesKHR.sType = getStructureType<VkPhysicalDevicePipelineExecutablePropertiesFeaturesKHR>();
 460                 *nextPtr = &physicalDevicePipelineExecutablePropertiesFeaturesKHR;
 461                 nextPtr  = &physicalDevicePipelineExecutablePropertiesFeaturesKHR.pNext;
 462         }
 463
 464         vk::VkPhysicalDevicePipelineProtectedAccessFeaturesEXT physicalDevicePipelineProtectedAccessFeaturesEXT;
 465         deMemset(&physicalDevicePipelineProtectedAccessFeaturesEXT, 0, sizeof(physicalDevicePipelineProtectedAccessFeaturesEXT));
 466
 467         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_pipeline_protected_access") )
 468         {
 469                 physicalDevicePipelineProtectedAccessFeaturesEXT.sType = getStructureType<VkPhysicalDevicePipelineProtectedAccessFeaturesEXT>();
 470                 *nextPtr = &physicalDevicePipelineProtectedAccessFeaturesEXT;
 471                 nextPtr  = &physicalDevicePipelineProtectedAccessFeaturesEXT.pNext;
 472         }
 473
 474 #if defined(CTS_USES_VULKAN)
 475         vk::VkPhysicalDevicePresentIdFeaturesKHR physicalDevicePresentIdFeaturesKHR;
 476         deMemset(&physicalDevicePresentIdFeaturesKHR, 0, sizeof(physicalDevicePresentIdFeaturesKHR));
 477
 478         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_present_id") )
 479         {
 480                 physicalDevicePresentIdFeaturesKHR.sType = getStructureType<VkPhysicalDevicePresentIdFeaturesKHR>();
 481                 *nextPtr = &physicalDevicePresentIdFeaturesKHR;
 482                 nextPtr  = &physicalDevicePresentIdFeaturesKHR.pNext;
 483         }
 484 #endif // defined(CTS_USES_VULKAN)
 485
 486 #if defined(CTS_USES_VULKAN)
 487         vk::VkPhysicalDevicePresentWaitFeaturesKHR physicalDevicePresentWaitFeaturesKHR;
 488         deMemset(&physicalDevicePresentWaitFeaturesKHR, 0, sizeof(physicalDevicePresentWaitFeaturesKHR));
 489
 490         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_present_wait") )
 491         {
 492                 physicalDevicePresentWaitFeaturesKHR.sType = getStructureType<VkPhysicalDevicePresentWaitFeaturesKHR>();
 493                 *nextPtr = &physicalDevicePresentWaitFeaturesKHR;
 494                 nextPtr  = &physicalDevicePresentWaitFeaturesKHR.pNext;
 495         }
 496 #endif // defined(CTS_USES_VULKAN)
 497
 498 #if defined(CTS_USES_VULKAN)
 499         vk::VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT physicalDevicePrimitiveTopologyListRestartFeaturesEXT;
 500         deMemset(&physicalDevicePrimitiveTopologyListRestartFeaturesEXT, 0, sizeof(physicalDevicePrimitiveTopologyListRestartFeaturesEXT));
 501
 502         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_primitive_topology_list_restart") )
 503         {
 504                 physicalDevicePrimitiveTopologyListRestartFeaturesEXT.sType = getStructureType<VkPhysicalDevicePrimitiveTopologyListRestartFeaturesEXT>();
 505                 *nextPtr = &physicalDevicePrimitiveTopologyListRestartFeaturesEXT;
 506                 nextPtr  = &physicalDevicePrimitiveTopologyListRestartFeaturesEXT.pNext;
 507         }
 508 #endif // defined(CTS_USES_VULKAN)
 509
 510         vk::VkPhysicalDeviceRayQueryFeaturesKHR physicalDeviceRayQueryFeaturesKHR;
 511         deMemset(&physicalDeviceRayQueryFeaturesKHR, 0, sizeof(physicalDeviceRayQueryFeaturesKHR));
 512
 513         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_ray_query") )
 514         {
 515                 physicalDeviceRayQueryFeaturesKHR.sType = getStructureType<VkPhysicalDeviceRayQueryFeaturesKHR>();
 516                 *nextPtr = &physicalDeviceRayQueryFeaturesKHR;
 517                 nextPtr  = &physicalDeviceRayQueryFeaturesKHR.pNext;
 518         }
 519
 520         vk::VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR physicalDeviceRayTracingMaintenance1FeaturesKHR;
 521         deMemset(&physicalDeviceRayTracingMaintenance1FeaturesKHR, 0, sizeof(physicalDeviceRayTracingMaintenance1FeaturesKHR));
 522
 523         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_ray_tracing_maintenance1") )
 524         {
 525                 physicalDeviceRayTracingMaintenance1FeaturesKHR.sType = getStructureType<VkPhysicalDeviceRayTracingMaintenance1FeaturesKHR>();
 526                 *nextPtr = &physicalDeviceRayTracingMaintenance1FeaturesKHR;
 527                 nextPtr  = &physicalDeviceRayTracingMaintenance1FeaturesKHR.pNext;
 528         }
 529
 530         vk::VkPhysicalDeviceRayTracingPipelineFeaturesKHR physicalDeviceRayTracingPipelineFeaturesKHR;
 531         deMemset(&physicalDeviceRayTracingPipelineFeaturesKHR, 0, sizeof(physicalDeviceRayTracingPipelineFeaturesKHR));
 532
 533         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_ray_tracing_pipeline") )
 534         {
 535                 physicalDeviceRayTracingPipelineFeaturesKHR.sType = getStructureType<VkPhysicalDeviceRayTracingPipelineFeaturesKHR>();
 536                 *nextPtr = &physicalDeviceRayTracingPipelineFeaturesKHR;
 537                 nextPtr  = &physicalDeviceRayTracingPipelineFeaturesKHR.pNext;
 538         }
 539
 540         vk::VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR physicalDeviceSamplerYcbcrConversionFeaturesKHR;
 541         deMemset(&physicalDeviceSamplerYcbcrConversionFeaturesKHR, 0, sizeof(physicalDeviceSamplerYcbcrConversionFeaturesKHR));
 542
 543         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_sampler_ycbcr_conversion") )
 544         {
 545                 physicalDeviceSamplerYcbcrConversionFeaturesKHR.sType = getStructureType<VkPhysicalDeviceSamplerYcbcrConversionFeaturesKHR>();
 546                 *nextPtr = &physicalDeviceSamplerYcbcrConversionFeaturesKHR;
 547                 nextPtr  = &physicalDeviceSamplerYcbcrConversionFeaturesKHR.pNext;
 548         }
 549
 550         vk::VkPhysicalDeviceScalarBlockLayoutFeatures physicalDeviceScalarBlockLayoutFeatures;
 551         deMemset(&physicalDeviceScalarBlockLayoutFeatures, 0, sizeof(physicalDeviceScalarBlockLayoutFeatures));
 552
 553         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_scalar_block_layout") )
 554         {
 555                 physicalDeviceScalarBlockLayoutFeatures.sType = getStructureType<VkPhysicalDeviceScalarBlockLayoutFeatures>();
 556                 *nextPtr = &physicalDeviceScalarBlockLayoutFeatures;
 557                 nextPtr  = &physicalDeviceScalarBlockLayoutFeatures.pNext;
 558         }
 559
 560         vk::VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures physicalDeviceSeparateDepthStencilLayoutsFeatures;
 561         deMemset(&physicalDeviceSeparateDepthStencilLayoutsFeatures, 0, sizeof(physicalDeviceSeparateDepthStencilLayoutsFeatures));
 562
 563         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_separate_depth_stencil_layouts") )
 564         {
 565                 physicalDeviceSeparateDepthStencilLayoutsFeatures.sType = getStructureType<VkPhysicalDeviceSeparateDepthStencilLayoutsFeatures>();
 566                 *nextPtr = &physicalDeviceSeparateDepthStencilLayoutsFeatures;
 567                 nextPtr  = &physicalDeviceSeparateDepthStencilLayoutsFeatures.pNext;
 568         }
 569
 570 #if defined(CTS_USES_VULKAN)
 571         vk::VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT physicalDeviceShaderAtomicFloat2FeaturesEXT;
 572         deMemset(&physicalDeviceShaderAtomicFloat2FeaturesEXT, 0, sizeof(physicalDeviceShaderAtomicFloat2FeaturesEXT));
 573
 574         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_shader_atomic_float2") )
 575         {
 576                 physicalDeviceShaderAtomicFloat2FeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderAtomicFloat2FeaturesEXT>();
 577                 *nextPtr = &physicalDeviceShaderAtomicFloat2FeaturesEXT;
 578                 nextPtr  = &physicalDeviceShaderAtomicFloat2FeaturesEXT.pNext;
 579         }
 580 #endif // defined(CTS_USES_VULKAN)
 581
 582         vk::VkPhysicalDeviceShaderAtomicFloatFeaturesEXT physicalDeviceShaderAtomicFloatFeaturesEXT;
 583         deMemset(&physicalDeviceShaderAtomicFloatFeaturesEXT, 0, sizeof(physicalDeviceShaderAtomicFloatFeaturesEXT));
 584
 585         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_shader_atomic_float") )
 586         {
 587                 physicalDeviceShaderAtomicFloatFeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderAtomicFloatFeaturesEXT>();
 588                 *nextPtr = &physicalDeviceShaderAtomicFloatFeaturesEXT;
 589                 nextPtr  = &physicalDeviceShaderAtomicFloatFeaturesEXT.pNext;
 590         }
 591
 592         vk::VkPhysicalDeviceShaderAtomicInt64Features physicalDeviceShaderAtomicInt64Features;
 593         deMemset(&physicalDeviceShaderAtomicInt64Features, 0, sizeof(physicalDeviceShaderAtomicInt64Features));
 594
 595         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_shader_atomic_int64") )
 596         {
 597                 physicalDeviceShaderAtomicInt64Features.sType = getStructureType<VkPhysicalDeviceShaderAtomicInt64Features>();
 598                 *nextPtr = &physicalDeviceShaderAtomicInt64Features;
 599                 nextPtr  = &physicalDeviceShaderAtomicInt64Features.pNext;
 600         }
 601
 602         vk::VkPhysicalDeviceShaderClockFeaturesKHR physicalDeviceShaderClockFeaturesKHR;
 603         deMemset(&physicalDeviceShaderClockFeaturesKHR, 0, sizeof(physicalDeviceShaderClockFeaturesKHR));
 604
 605         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_shader_clock") )
 606         {
 607                 physicalDeviceShaderClockFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderClockFeaturesKHR>();
 608                 *nextPtr = &physicalDeviceShaderClockFeaturesKHR;
 609                 nextPtr  = &physicalDeviceShaderClockFeaturesKHR.pNext;
 610         }
 611
 612         vk::VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
 613         deMemset(&physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT, 0, sizeof(physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT));
 614
 615         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_shader_demote_to_helper_invocation") )
 616         {
 617                 physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderDemoteToHelperInvocationFeaturesEXT>();
 618                 *nextPtr = &physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT;
 619                 nextPtr  = &physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.pNext;
 620         }
 621
 622         vk::VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
 623         deMemset(&physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD, 0, sizeof(physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD));
 624
 625         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_AMD_shader_early_and_late_fragment_tests") )
 626         {
 627                 physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.sType = getStructureType<VkPhysicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD>();
 628                 *nextPtr = &physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD;
 629                 nextPtr  = &physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.pNext;
 630         }
 631
 632         vk::VkPhysicalDeviceShaderFloat16Int8Features physicalDeviceShaderFloat16Int8Features;
 633         deMemset(&physicalDeviceShaderFloat16Int8Features, 0, sizeof(physicalDeviceShaderFloat16Int8Features));
 634
 635         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_shader_float16_int8") )
 636         {
 637                 physicalDeviceShaderFloat16Int8Features.sType = getStructureType<VkPhysicalDeviceShaderFloat16Int8Features>();
 638                 *nextPtr = &physicalDeviceShaderFloat16Int8Features;
 639                 nextPtr  = &physicalDeviceShaderFloat16Int8Features.pNext;
 640         }
 641
 642         vk::VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT physicalDeviceShaderImageAtomicInt64FeaturesEXT;
 643         deMemset(&physicalDeviceShaderImageAtomicInt64FeaturesEXT, 0, sizeof(physicalDeviceShaderImageAtomicInt64FeaturesEXT));
 644
 645         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_shader_image_atomic_int64") )
 646         {
 647                 physicalDeviceShaderImageAtomicInt64FeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderImageAtomicInt64FeaturesEXT>();
 648                 *nextPtr = &physicalDeviceShaderImageAtomicInt64FeaturesEXT;
 649                 nextPtr  = &physicalDeviceShaderImageAtomicInt64FeaturesEXT.pNext;
 650         }
 651
 652 #if defined(CTS_USES_VULKAN)
 653         vk::VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR physicalDeviceShaderIntegerDotProductFeaturesKHR;
 654         deMemset(&physicalDeviceShaderIntegerDotProductFeaturesKHR, 0, sizeof(physicalDeviceShaderIntegerDotProductFeaturesKHR));
 655
 656         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_shader_integer_dot_product") )
 657         {
 658                 physicalDeviceShaderIntegerDotProductFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderIntegerDotProductFeaturesKHR>();
 659                 *nextPtr = &physicalDeviceShaderIntegerDotProductFeaturesKHR;
 660                 nextPtr  = &physicalDeviceShaderIntegerDotProductFeaturesKHR.pNext;
 661         }
 662 #endif // defined(CTS_USES_VULKAN)
 663
 664         vk::VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT physicalDeviceShaderModuleIdentifierFeaturesEXT;
 665         deMemset(&physicalDeviceShaderModuleIdentifierFeaturesEXT, 0, sizeof(physicalDeviceShaderModuleIdentifierFeaturesEXT));
 666
 667         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_shader_module_identifier") )
 668         {
 669                 physicalDeviceShaderModuleIdentifierFeaturesEXT.sType = getStructureType<VkPhysicalDeviceShaderModuleIdentifierFeaturesEXT>();
 670                 *nextPtr = &physicalDeviceShaderModuleIdentifierFeaturesEXT;
 671                 nextPtr  = &physicalDeviceShaderModuleIdentifierFeaturesEXT.pNext;
 672         }
 673
 674         vk::VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures physicalDeviceShaderSubgroupExtendedTypesFeatures;
 675         deMemset(&physicalDeviceShaderSubgroupExtendedTypesFeatures, 0, sizeof(physicalDeviceShaderSubgroupExtendedTypesFeatures));
 676
 677         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_shader_subgroup_extended_types") )
 678         {
 679                 physicalDeviceShaderSubgroupExtendedTypesFeatures.sType = getStructureType<VkPhysicalDeviceShaderSubgroupExtendedTypesFeatures>();
 680                 *nextPtr = &physicalDeviceShaderSubgroupExtendedTypesFeatures;
 681                 nextPtr  = &physicalDeviceShaderSubgroupExtendedTypesFeatures.pNext;
 682         }
 683
 684         vk::VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
 685         deMemset(&physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR, 0, sizeof(physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR));
 686
 687         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_shader_subgroup_uniform_control_flow") )
 688         {
 689                 physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR>();
 690                 *nextPtr = &physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR;
 691                 nextPtr  = &physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.pNext;
 692         }
 693
 694         vk::VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR physicalDeviceShaderTerminateInvocationFeaturesKHR;
 695         deMemset(&physicalDeviceShaderTerminateInvocationFeaturesKHR, 0, sizeof(physicalDeviceShaderTerminateInvocationFeaturesKHR));
 696
 697         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_shader_terminate_invocation") )
 698         {
 699                 physicalDeviceShaderTerminateInvocationFeaturesKHR.sType = getStructureType<VkPhysicalDeviceShaderTerminateInvocationFeaturesKHR>();
 700                 *nextPtr = &physicalDeviceShaderTerminateInvocationFeaturesKHR;
 701                 nextPtr  = &physicalDeviceShaderTerminateInvocationFeaturesKHR.pNext;
 702         }
 703
 704         vk::VkPhysicalDeviceSubgroupSizeControlFeaturesEXT physicalDeviceSubgroupSizeControlFeaturesEXT;
 705         deMemset(&physicalDeviceSubgroupSizeControlFeaturesEXT, 0, sizeof(physicalDeviceSubgroupSizeControlFeaturesEXT));
 706
 707         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_subgroup_size_control") )
 708         {
 709                 physicalDeviceSubgroupSizeControlFeaturesEXT.sType = getStructureType<VkPhysicalDeviceSubgroupSizeControlFeaturesEXT>();
 710                 *nextPtr = &physicalDeviceSubgroupSizeControlFeaturesEXT;
 711                 nextPtr  = &physicalDeviceSubgroupSizeControlFeaturesEXT.pNext;
 712         }
 713
 714         vk::VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT physicalDeviceSubpassMergeFeedbackFeaturesEXT;
 715         deMemset(&physicalDeviceSubpassMergeFeedbackFeaturesEXT, 0, sizeof(physicalDeviceSubpassMergeFeedbackFeaturesEXT));
 716
 717         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_subpass_merge_feedback") )
 718         {
 719                 physicalDeviceSubpassMergeFeedbackFeaturesEXT.sType = getStructureType<VkPhysicalDeviceSubpassMergeFeedbackFeaturesEXT>();
 720                 *nextPtr = &physicalDeviceSubpassMergeFeedbackFeaturesEXT;
 721                 nextPtr  = &physicalDeviceSubpassMergeFeedbackFeaturesEXT.pNext;
 722         }
 723
 724         vk::VkPhysicalDeviceSynchronization2FeaturesKHR physicalDeviceSynchronization2FeaturesKHR;
 725         deMemset(&physicalDeviceSynchronization2FeaturesKHR, 0, sizeof(physicalDeviceSynchronization2FeaturesKHR));
 726
 727         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_synchronization2") )
 728         {
 729                 physicalDeviceSynchronization2FeaturesKHR.sType = getStructureType<VkPhysicalDeviceSynchronization2FeaturesKHR>();
 730                 *nextPtr = &physicalDeviceSynchronization2FeaturesKHR;
 731                 nextPtr  = &physicalDeviceSynchronization2FeaturesKHR.pNext;
 732         }
 733
 734         vk::VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT physicalDeviceTexelBufferAlignmentFeaturesEXT;
 735         deMemset(&physicalDeviceTexelBufferAlignmentFeaturesEXT, 0, sizeof(physicalDeviceTexelBufferAlignmentFeaturesEXT));
 736
 737         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_texel_buffer_alignment") )
 738         {
 739                 physicalDeviceTexelBufferAlignmentFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTexelBufferAlignmentFeaturesEXT>();
 740                 *nextPtr = &physicalDeviceTexelBufferAlignmentFeaturesEXT;
 741                 nextPtr  = &physicalDeviceTexelBufferAlignmentFeaturesEXT.pNext;
 742         }
 743
 744         vk::VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT physicalDeviceTextureCompressionASTCHDRFeaturesEXT;
 745         deMemset(&physicalDeviceTextureCompressionASTCHDRFeaturesEXT, 0, sizeof(physicalDeviceTextureCompressionASTCHDRFeaturesEXT));
 746
 747         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_texture_compression_astc_hdr") )
 748         {
 749                 physicalDeviceTextureCompressionASTCHDRFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTextureCompressionASTCHDRFeaturesEXT>();
 750                 *nextPtr = &physicalDeviceTextureCompressionASTCHDRFeaturesEXT;
 751                 nextPtr  = &physicalDeviceTextureCompressionASTCHDRFeaturesEXT.pNext;
 752         }
 753
 754 #if defined(CTS_USES_VULKAN)
 755         vk::VkPhysicalDeviceTimelineSemaphoreFeatures physicalDeviceTimelineSemaphoreFeatures;
 756         deMemset(&physicalDeviceTimelineSemaphoreFeatures, 0, sizeof(physicalDeviceTimelineSemaphoreFeatures));
 757
 758         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_timeline_semaphore") )
 759         {
 760                 physicalDeviceTimelineSemaphoreFeatures.sType = getStructureType<VkPhysicalDeviceTimelineSemaphoreFeatures>();
 761                 *nextPtr = &physicalDeviceTimelineSemaphoreFeatures;
 762                 nextPtr  = &physicalDeviceTimelineSemaphoreFeatures.pNext;
 763         }
 764 #endif // defined(CTS_USES_VULKAN)
 765
 766         vk::VkPhysicalDeviceTransformFeedbackFeaturesEXT physicalDeviceTransformFeedbackFeaturesEXT;
 767         deMemset(&physicalDeviceTransformFeedbackFeaturesEXT, 0, sizeof(physicalDeviceTransformFeedbackFeaturesEXT));
 768
 769         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_transform_feedback") )
 770         {
 771                 physicalDeviceTransformFeedbackFeaturesEXT.sType = getStructureType<VkPhysicalDeviceTransformFeedbackFeaturesEXT>();
 772                 *nextPtr = &physicalDeviceTransformFeedbackFeaturesEXT;
 773                 nextPtr  = &physicalDeviceTransformFeedbackFeaturesEXT.pNext;
 774         }
 775
 776         vk::VkPhysicalDeviceUniformBufferStandardLayoutFeatures physicalDeviceUniformBufferStandardLayoutFeatures;
 777         deMemset(&physicalDeviceUniformBufferStandardLayoutFeatures, 0, sizeof(physicalDeviceUniformBufferStandardLayoutFeatures));
 778
 779         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_uniform_buffer_standard_layout") )
 780         {
 781                 physicalDeviceUniformBufferStandardLayoutFeatures.sType = getStructureType<VkPhysicalDeviceUniformBufferStandardLayoutFeatures>();
 782                 *nextPtr = &physicalDeviceUniformBufferStandardLayoutFeatures;
 783                 nextPtr  = &physicalDeviceUniformBufferStandardLayoutFeatures.pNext;
 784         }
 785
 786         vk::VkPhysicalDeviceVariablePointersFeatures physicalDeviceVariablePointersFeatures;
 787         deMemset(&physicalDeviceVariablePointersFeatures, 0, sizeof(physicalDeviceVariablePointersFeatures));
 788
 789         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_variable_pointers") )
 790         {
 791                 physicalDeviceVariablePointersFeatures.sType = getStructureType<VkPhysicalDeviceVariablePointersFeatures>();
 792                 *nextPtr = &physicalDeviceVariablePointersFeatures;
 793                 nextPtr  = &physicalDeviceVariablePointersFeatures.pNext;
 794         }
 795
 796         vk::VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT physicalDeviceVertexAttributeDivisorFeaturesEXT;
 797         deMemset(&physicalDeviceVertexAttributeDivisorFeaturesEXT, 0, sizeof(physicalDeviceVertexAttributeDivisorFeaturesEXT));
 798
 799         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_vertex_attribute_divisor") )
 800         {
 801                 physicalDeviceVertexAttributeDivisorFeaturesEXT.sType = getStructureType<VkPhysicalDeviceVertexAttributeDivisorFeaturesEXT>();
 802                 *nextPtr = &physicalDeviceVertexAttributeDivisorFeaturesEXT;
 803                 nextPtr  = &physicalDeviceVertexAttributeDivisorFeaturesEXT.pNext;
 804         }
 805
 806         vk::VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT physicalDeviceVertexInputDynamicStateFeaturesEXT;
 807         deMemset(&physicalDeviceVertexInputDynamicStateFeaturesEXT, 0, sizeof(physicalDeviceVertexInputDynamicStateFeaturesEXT));
 808
 809         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_vertex_input_dynamic_state") )
 810         {
 811                 physicalDeviceVertexInputDynamicStateFeaturesEXT.sType = getStructureType<VkPhysicalDeviceVertexInputDynamicStateFeaturesEXT>();
 812                 *nextPtr = &physicalDeviceVertexInputDynamicStateFeaturesEXT;
 813                 nextPtr  = &physicalDeviceVertexInputDynamicStateFeaturesEXT.pNext;
 814         }
 815
 816 #if defined(CTS_USES_VULKAN)
 817         vk::VkPhysicalDeviceVulkan11Features physicalDeviceVulkan11Features;
 818         deMemset(&physicalDeviceVulkan11Features, 0, sizeof(physicalDeviceVulkan11Features));
 819
 820         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
 821         {
 822                 physicalDeviceVulkan11Features.sType = getStructureType<VkPhysicalDeviceVulkan11Features>();
 823                 *nextPtr = &physicalDeviceVulkan11Features;
 824                 nextPtr  = &physicalDeviceVulkan11Features.pNext;
 825         }
 826 #endif // defined(CTS_USES_VULKAN)
 827
 828         vk::VkPhysicalDeviceVulkan12Features physicalDeviceVulkan12Features;
 829         deMemset(&physicalDeviceVulkan12Features, 0, sizeof(physicalDeviceVulkan12Features));
 830
 831         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) || context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
 832         {
 833                 physicalDeviceVulkan12Features.sType = getStructureType<VkPhysicalDeviceVulkan12Features>();
 834                 *nextPtr = &physicalDeviceVulkan12Features;
 835                 nextPtr  = &physicalDeviceVulkan12Features.pNext;
 836         }
 837
 838 #if defined(CTS_USES_VULKAN)
 839         vk::VkPhysicalDeviceVulkan13Features physicalDeviceVulkan13Features;
 840         deMemset(&physicalDeviceVulkan13Features, 0, sizeof(physicalDeviceVulkan13Features));
 841
 842         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
 843         {
 844                 physicalDeviceVulkan13Features.sType = getStructureType<VkPhysicalDeviceVulkan13Features>();
 845                 *nextPtr = &physicalDeviceVulkan13Features;
 846                 nextPtr  = &physicalDeviceVulkan13Features.pNext;
 847         }
 848 #endif // defined(CTS_USES_VULKAN)
 849
 850         vk::VkPhysicalDeviceVulkanMemoryModelFeatures physicalDeviceVulkanMemoryModelFeatures;
 851         deMemset(&physicalDeviceVulkanMemoryModelFeatures, 0, sizeof(physicalDeviceVulkanMemoryModelFeatures));
 852
 853         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_vulkan_memory_model") )
 854         {
 855                 physicalDeviceVulkanMemoryModelFeatures.sType = getStructureType<VkPhysicalDeviceVulkanMemoryModelFeatures>();
 856                 *nextPtr = &physicalDeviceVulkanMemoryModelFeatures;
 857                 nextPtr  = &physicalDeviceVulkanMemoryModelFeatures.pNext;
 858         }
 859
 860         vk::VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
 861         deMemset(&physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR, 0, sizeof(physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR));
 862
 863         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_workgroup_memory_explicit_layout") )
 864         {
 865                 physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.sType = getStructureType<VkPhysicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR>();
 866                 *nextPtr = &physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR;
 867                 nextPtr  = &physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.pNext;
 868         }
 869
 870         vk::VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT physicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
 871         deMemset(&physicalDeviceYcbcr2Plane444FormatsFeaturesEXT, 0, sizeof(physicalDeviceYcbcr2Plane444FormatsFeaturesEXT));
 872
 873         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_ycbcr_2plane_444_formats") )
 874         {
 875                 physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.sType = getStructureType<VkPhysicalDeviceYcbcr2Plane444FormatsFeaturesEXT>();
 876                 *nextPtr = &physicalDeviceYcbcr2Plane444FormatsFeaturesEXT;
 877                 nextPtr  = &physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.pNext;
 878         }
 879
 880         vk::VkPhysicalDeviceYcbcrImageArraysFeaturesEXT physicalDeviceYcbcrImageArraysFeaturesEXT;
 881         deMemset(&physicalDeviceYcbcrImageArraysFeaturesEXT, 0, sizeof(physicalDeviceYcbcrImageArraysFeaturesEXT));
 882
 883         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_EXT_ycbcr_image_arrays") )
 884         {
 885                 physicalDeviceYcbcrImageArraysFeaturesEXT.sType = getStructureType<VkPhysicalDeviceYcbcrImageArraysFeaturesEXT>();
 886                 *nextPtr = &physicalDeviceYcbcrImageArraysFeaturesEXT;
 887                 nextPtr  = &physicalDeviceYcbcrImageArraysFeaturesEXT.pNext;
 888         }
 889
 890         vk::VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
 891         deMemset(&physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR, 0, sizeof(physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR));
 892
 893         if ( canUseFeaturesStruct(deviceExtensions, usedApiVersion, "VK_KHR_zero_initialize_workgroup_memory") )
 894         {
 895                 physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.sType = getStructureType<VkPhysicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR>();
 896                 *nextPtr = &physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR;
 897                 nextPtr  = &physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.pNext;
 898         }
 899
 900         context.getInstanceInterface().getPhysicalDeviceFeatures2(context.getPhysicalDevice(), &coreFeatures);
 901         bool result = true;
 902
 903         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_AMD_shader_early_and_late_fragment_tests")) )
 904         {
 905                 if ( physicalDeviceShaderEarlyAndLateFragmentTestsFeaturesAMD.shaderEarlyAndLateFragmentTests == VK_FALSE )
 906                 {
 907                         log << tcu::TestLog::Message << "Mandatory feature shaderEarlyAndLateFragmentTests not supported" << tcu::TestLog::EndMessage;
 908                         result = false;
 909                 }
 910         }
 911
 912         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_4444_formats")) )
 913         {
 914                 if ( physicalDevice4444FormatsFeaturesEXT.formatA4R4G4B4 == VK_FALSE )
 915                 {
 916                         log << tcu::TestLog::Message << "Mandatory feature formatA4R4G4B4 not supported" << tcu::TestLog::EndMessage;
 917                         result = false;
 918                 }
 919         }
 920
 921 #if defined(CTS_USES_VULKAN)
 922         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_attachment_feedback_loop_layout")) )
 923         {
 924                 if ( physicalDeviceAttachmentFeedbackLoopLayoutFeaturesEXT.attachmentFeedbackLoopLayout == VK_FALSE )
 925                 {
 926                         log << tcu::TestLog::Message << "Mandatory feature attachmentFeedbackLoopLayout not supported" << tcu::TestLog::EndMessage;
 927                         result = false;
 928                 }
 929         }
 930 #endif // defined(CTS_USES_VULKAN)
 931
 932 #if defined(CTS_USES_VULKAN)
 933         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_border_color_swizzle")) )
 934         {
 935                 if ( physicalDeviceBorderColorSwizzleFeaturesEXT.borderColorSwizzle == VK_FALSE )
 936                 {
 937                         log << tcu::TestLog::Message << "Mandatory feature borderColorSwizzle not supported" << tcu::TestLog::EndMessage;
 938                         result = false;
 939                 }
 940         }
 941 #endif // defined(CTS_USES_VULKAN)
 942
 943         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_color_write_enable")) )
 944         {
 945                 if ( physicalDeviceColorWriteEnableFeaturesEXT.colorWriteEnable == VK_FALSE )
 946                 {
 947                         log << tcu::TestLog::Message << "Mandatory feature colorWriteEnable not supported" << tcu::TestLog::EndMessage;
 948                         result = false;
 949                 }
 950         }
 951
 952         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_conditional_rendering")) )
 953         {
 954                 if ( physicalDeviceConditionalRenderingFeaturesEXT.conditionalRendering == VK_FALSE )
 955                 {
 956                         log << tcu::TestLog::Message << "Mandatory feature conditionalRendering not supported" << tcu::TestLog::EndMessage;
 957                         result = false;
 958                 }
 959         }
 960
 961         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clamp_zero_one")) )
 962         {
 963                 if ( physicalDeviceDepthClampZeroOneFeaturesEXT.depthClampZeroOne == VK_FALSE )
 964                 {
 965                         log << tcu::TestLog::Message << "Mandatory feature depthClampZeroOne not supported" << tcu::TestLog::EndMessage;
 966                         result = false;
 967                 }
 968         }
 969
 970         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clip_control")) )
 971         {
 972                 if ( physicalDeviceDepthClipControlFeaturesEXT.depthClipControl == VK_FALSE )
 973                 {
 974                         log << tcu::TestLog::Message << "Mandatory feature depthClipControl not supported" << tcu::TestLog::EndMessage;
 975                         result = false;
 976                 }
 977         }
 978
 979         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_depth_clip_enable")) )
 980         {
 981                 if ( physicalDeviceDepthClipEnableFeaturesEXT.depthClipEnable == VK_FALSE )
 982                 {
 983                         log << tcu::TestLog::Message << "Mandatory feature depthClipEnable not supported" << tcu::TestLog::EndMessage;
 984                         result = false;
 985                 }
 986         }
 987
 988         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_buffer")) )
 989         {
 990                 if ( physicalDeviceDescriptorBufferFeaturesEXT.descriptorBuffer == VK_FALSE )
 991                 {
 992                         log << tcu::TestLog::Message << "Mandatory feature descriptorBuffer not supported" << tcu::TestLog::EndMessage;
 993                         result = false;
 994                 }
 995         }
 996
 997         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
 998         {
 999                 if ( physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing == VK_FALSE )
1000                 {
1001                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1002                         result = false;
1003                 }
1004         }
1005
1006         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1007         {
1008                 if ( physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing == VK_FALSE )
1009                 {
1010                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1011                         result = false;
1012                 }
1013         }
1014
1015         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1016         {
1017                 if ( physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing == VK_FALSE )
1018                 {
1019                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1020                         result = false;
1021                 }
1022         }
1023
1024         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1025         {
1026                 if ( physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing == VK_FALSE )
1027                 {
1028                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1029                         result = false;
1030                 }
1031         }
1032
1033         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1034         {
1035                 if ( physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing == VK_FALSE )
1036                 {
1037                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1038                         result = false;
1039                 }
1040         }
1041
1042         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1043         {
1044                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind == VK_FALSE )
1045                 {
1046                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingSampledImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1047                         result = false;
1048                 }
1049         }
1050
1051         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1052         {
1053                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind == VK_FALSE )
1054                 {
1055                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1056                         result = false;
1057                 }
1058         }
1059
1060         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1061         {
1062                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind == VK_FALSE )
1063                 {
1064                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1065                         result = false;
1066                 }
1067         }
1068
1069         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1070         {
1071                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind == VK_FALSE )
1072                 {
1073                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUniformTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1074                         result = false;
1075                 }
1076         }
1077
1078         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1079         {
1080                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind == VK_FALSE )
1081                 {
1082                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1083                         result = false;
1084                 }
1085         }
1086
1087         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1088         {
1089                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending == VK_FALSE )
1090                 {
1091                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUpdateUnusedWhilePending not supported" << tcu::TestLog::EndMessage;
1092                         result = false;
1093                 }
1094         }
1095
1096         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1097         {
1098                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound == VK_FALSE )
1099                 {
1100                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingPartiallyBound not supported" << tcu::TestLog::EndMessage;
1101                         result = false;
1102                 }
1103         }
1104
1105         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1106         {
1107                 if ( physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray == VK_FALSE )
1108                 {
1109                         log << tcu::TestLog::Message << "Mandatory feature runtimeDescriptorArray not supported" << tcu::TestLog::EndMessage;
1110                         result = false;
1111                 }
1112         }
1113
1114         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1115         {
1116                 if ( physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayDynamicIndexing == VK_FALSE )
1117                 {
1118                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1119                         result = false;
1120                 }
1121         }
1122
1123         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1124         {
1125                 if ( physicalDeviceDescriptorIndexingFeatures.shaderStorageTexelBufferArrayDynamicIndexing == VK_FALSE )
1126                 {
1127                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1128                         result = false;
1129                 }
1130         }
1131
1132         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1133         {
1134                 if ( physicalDeviceDescriptorIndexingFeatures.shaderSampledImageArrayNonUniformIndexing == VK_FALSE )
1135                 {
1136                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1137                         result = false;
1138                 }
1139         }
1140
1141         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1142         {
1143                 if ( physicalDeviceDescriptorIndexingFeatures.shaderStorageBufferArrayNonUniformIndexing == VK_FALSE )
1144                 {
1145                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1146                         result = false;
1147                 }
1148         }
1149
1150         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1151         {
1152                 if ( physicalDeviceDescriptorIndexingFeatures.shaderUniformTexelBufferArrayNonUniformIndexing == VK_FALSE )
1153                 {
1154                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
1155                         result = false;
1156                 }
1157         }
1158
1159         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1160         {
1161                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingSampledImageUpdateAfterBind == VK_FALSE )
1162                 {
1163                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingSampledImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1164                         result = false;
1165                 }
1166         }
1167
1168         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1169         {
1170                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageImageUpdateAfterBind == VK_FALSE )
1171                 {
1172                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1173                         result = false;
1174                 }
1175         }
1176
1177         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1178         {
1179                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageBufferUpdateAfterBind == VK_FALSE )
1180                 {
1181                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1182                         result = false;
1183                 }
1184         }
1185
1186         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1187         {
1188                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingUniformTexelBufferUpdateAfterBind == VK_FALSE )
1189                 {
1190                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUniformTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1191                         result = false;
1192                 }
1193         }
1194
1195         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1196         {
1197                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingStorageTexelBufferUpdateAfterBind == VK_FALSE )
1198                 {
1199                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1200                         result = false;
1201                 }
1202         }
1203
1204         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1205         {
1206                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingUpdateUnusedWhilePending == VK_FALSE )
1207                 {
1208                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUpdateUnusedWhilePending not supported" << tcu::TestLog::EndMessage;
1209                         result = false;
1210                 }
1211         }
1212
1213         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1214         {
1215                 if ( physicalDeviceDescriptorIndexingFeatures.descriptorBindingPartiallyBound == VK_FALSE )
1216                 {
1217                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingPartiallyBound not supported" << tcu::TestLog::EndMessage;
1218                         result = false;
1219                 }
1220         }
1221
1222         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1223         {
1224                 if ( physicalDeviceDescriptorIndexingFeatures.runtimeDescriptorArray == VK_FALSE )
1225                 {
1226                         log << tcu::TestLog::Message << "Mandatory feature runtimeDescriptorArray not supported" << tcu::TestLog::EndMessage;
1227                         result = false;
1228                 }
1229         }
1230
1231         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1232         {
1233                 if ( coreFeatures.features.shaderSampledImageArrayDynamicIndexing == VK_FALSE )
1234                 {
1235                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1236                         result = false;
1237                 }
1238         }
1239
1240         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1241         {
1242                 if ( coreFeatures.features.shaderStorageBufferArrayDynamicIndexing == VK_FALSE )
1243                 {
1244                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1245                         result = false;
1246                 }
1247         }
1248
1249         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1250         {
1251                 if ( coreFeatures.features.shaderSampledImageArrayDynamicIndexing == VK_FALSE )
1252                 {
1253                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1254                         result = false;
1255                 }
1256         }
1257
1258         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1259         {
1260                 if ( coreFeatures.features.shaderStorageBufferArrayDynamicIndexing == VK_FALSE )
1261                 {
1262                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
1263                         result = false;
1264                 }
1265         }
1266
1267         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_device_address_binding_report")) )
1268         {
1269                 if ( physicalDeviceAddressBindingReportFeaturesEXT.reportAddressBinding == VK_FALSE )
1270                 {
1271                         log << tcu::TestLog::Message << "Mandatory feature reportAddressBinding not supported" << tcu::TestLog::EndMessage;
1272                         result = false;
1273                 }
1274         }
1275
1276         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_device_fault")) )
1277         {
1278                 if ( physicalDeviceFaultFeaturesEXT.deviceFault == VK_FALSE )
1279                 {
1280                         log << tcu::TestLog::Message << "Mandatory feature deviceFault not supported" << tcu::TestLog::EndMessage;
1281                         result = false;
1282                 }
1283         }
1284
1285         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_extended_dynamic_state2")) )
1286         {
1287                 if ( physicalDeviceExtendedDynamicState2FeaturesEXT.extendedDynamicState2 == VK_FALSE )
1288                 {
1289                         log << tcu::TestLog::Message << "Mandatory feature extendedDynamicState2 not supported" << tcu::TestLog::EndMessage;
1290                         result = false;
1291                 }
1292         }
1293
1294         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_density_map")) )
1295         {
1296                 if ( physicalDeviceFragmentDensityMapFeaturesEXT.fragmentDensityMap == VK_FALSE )
1297                 {
1298                         log << tcu::TestLog::Message << "Mandatory feature fragmentDensityMap not supported" << tcu::TestLog::EndMessage;
1299                         result = false;
1300                 }
1301         }
1302
1303         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_fragment_shader_interlock")) )
1304         {
1305                 if ( ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderSampleInterlock == VK_FALSE ) && ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderPixelInterlock == VK_FALSE ) && ( physicalDeviceFragmentShaderInterlockFeaturesEXT.fragmentShaderShadingRateInterlock == VK_FALSE ) )
1306                 {
1307                         log << tcu::TestLog::Message << "Mandatory feature fragmentShaderSampleInterlock or fragmentShaderPixelInterlock or fragmentShaderShadingRateInterlock not supported" << tcu::TestLog::EndMessage;
1308                         result = false;
1309                 }
1310         }
1311
1312         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_host_query_reset")) )
1313         {
1314                 if ( physicalDeviceHostQueryResetFeatures.hostQueryReset == VK_FALSE )
1315                 {
1316                         log << tcu::TestLog::Message << "Mandatory feature hostQueryReset not supported" << tcu::TestLog::EndMessage;
1317                         result = false;
1318                 }
1319         }
1320
1321 #if defined(CTS_USES_VULKAN)
1322         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_2d_view_of_3d")) )
1323         {
1324                 if ( physicalDeviceImage2DViewOf3DFeaturesEXT.image2DViewOf3D == VK_FALSE )
1325                 {
1326                         log << tcu::TestLog::Message << "Mandatory feature image2DViewOf3D not supported" << tcu::TestLog::EndMessage;
1327                         result = false;
1328                 }
1329         }
1330 #endif // defined(CTS_USES_VULKAN)
1331
1332         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_compression_control")) )
1333         {
1334                 if ( physicalDeviceImageCompressionControlFeaturesEXT.imageCompressionControl == VK_FALSE )
1335                 {
1336                         log << tcu::TestLog::Message << "Mandatory feature imageCompressionControl not supported" << tcu::TestLog::EndMessage;
1337                         result = false;
1338                 }
1339         }
1340
1341         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_compression_control")) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_image_compression_control_swapchain")) )
1342         {
1343                 if ( physicalDeviceImageCompressionControlSwapchainFeaturesEXT.imageCompressionControlSwapchain == VK_FALSE )
1344                 {
1345                         log << tcu::TestLog::Message << "Mandatory feature imageCompressionControlSwapchain not supported" << tcu::TestLog::EndMessage;
1346                         result = false;
1347                 }
1348         }
1349
1350         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_index_type_uint8")) )
1351         {
1352                 if ( physicalDeviceIndexTypeUint8FeaturesEXT.indexTypeUint8 == VK_FALSE )
1353                 {
1354                         log << tcu::TestLog::Message << "Mandatory feature indexTypeUint8 not supported" << tcu::TestLog::EndMessage;
1355                         result = false;
1356                 }
1357         }
1358
1359         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_inline_uniform_block")) )
1360         {
1361                 if ( physicalDeviceInlineUniformBlockFeaturesEXT.inlineUniformBlock == VK_FALSE )
1362                 {
1363                         log << tcu::TestLog::Message << "Mandatory feature inlineUniformBlock not supported" << tcu::TestLog::EndMessage;
1364                         result = false;
1365                 }
1366         }
1367
1368         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_inline_uniform_block")) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_descriptor_indexing")) )
1369         {
1370                 if ( physicalDeviceInlineUniformBlockFeaturesEXT.descriptorBindingInlineUniformBlockUpdateAfterBind == VK_FALSE )
1371                 {
1372                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingInlineUniformBlockUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1373                         result = false;
1374                 }
1375         }
1376
1377         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_legacy_dithering")) )
1378         {
1379                 if ( physicalDeviceLegacyDitheringFeaturesEXT.legacyDithering == VK_FALSE )
1380                 {
1381                         log << tcu::TestLog::Message << "Mandatory feature legacyDithering not supported" << tcu::TestLog::EndMessage;
1382                         result = false;
1383                 }
1384         }
1385
1386         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_line_rasterization")) )
1387         {
1388                 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 ) )
1389                 {
1390                         log << tcu::TestLog::Message << "Mandatory feature rectangularLines or bresenhamLines or smoothLines or stippledRectangularLines or stippledBresenhamLines or stippledSmoothLines not supported" << tcu::TestLog::EndMessage;
1391                         result = false;
1392                 }
1393         }
1394
1395         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_memory_priority")) )
1396         {
1397                 if ( physicalDeviceMemoryPriorityFeaturesEXT.memoryPriority == VK_FALSE )
1398                 {
1399                         log << tcu::TestLog::Message << "Mandatory feature memoryPriority not supported" << tcu::TestLog::EndMessage;
1400                         result = false;
1401                 }
1402         }
1403
1404 #if defined(CTS_USES_VULKAN)
1405         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_fragment_shading_rate")) && physicalDeviceMeshShaderFeaturesEXT.primitiveFragmentShadingRateMeshShader )
1406         {
1407                 if ( physicalDeviceFragmentShadingRateFeaturesKHR.primitiveFragmentShadingRate == VK_FALSE )
1408                 {
1409                         log << tcu::TestLog::Message << "Mandatory feature primitiveFragmentShadingRate not supported" << tcu::TestLog::EndMessage;
1410                         result = false;
1411                 }
1412         }
1413 #endif // defined(CTS_USES_VULKAN)
1414
1415 #if defined(CTS_USES_VULKAN)
1416         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_mesh_shader")) )
1417         {
1418                 if ( ( physicalDeviceMeshShaderFeaturesEXT.meshShader == VK_FALSE ) && ( physicalDeviceMeshShaderFeaturesEXT.taskShader == VK_FALSE ) )
1419                 {
1420                         log << tcu::TestLog::Message << "Mandatory feature meshShader or taskShader not supported" << tcu::TestLog::EndMessage;
1421                         result = false;
1422                 }
1423         }
1424 #endif // defined(CTS_USES_VULKAN)
1425
1426         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_multi_draw")) )
1427         {
1428                 if ( physicalDeviceMultiDrawFeaturesEXT.multiDraw == VK_FALSE )
1429                 {
1430                         log << tcu::TestLog::Message << "Mandatory feature multiDraw not supported" << tcu::TestLog::EndMessage;
1431                         result = false;
1432                 }
1433         }
1434
1435         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_multisampled_render_to_single_sampled")) )
1436         {
1437                 if ( physicalDeviceMultisampledRenderToSingleSampledFeaturesEXT.multisampledRenderToSingleSampled == VK_FALSE )
1438                 {
1439                         log << tcu::TestLog::Message << "Mandatory feature multisampledRenderToSingleSampled not supported" << tcu::TestLog::EndMessage;
1440                         result = false;
1441                 }
1442         }
1443
1444         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_mutable_descriptor_type")) )
1445         {
1446                 if ( physicalDeviceMutableDescriptorTypeFeaturesEXT.mutableDescriptorType == VK_FALSE )
1447                 {
1448                         log << tcu::TestLog::Message << "Mandatory feature mutableDescriptorType not supported" << tcu::TestLog::EndMessage;
1449                         result = false;
1450                 }
1451         }
1452
1453 #if defined(CTS_USES_VULKAN)
1454         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_non_seamless_cube_map")) )
1455         {
1456                 if ( physicalDeviceNonSeamlessCubeMapFeaturesEXT.nonSeamlessCubeMap == VK_FALSE )
1457                 {
1458                         log << tcu::TestLog::Message << "Mandatory feature nonSeamlessCubeMap not supported" << tcu::TestLog::EndMessage;
1459                         result = false;
1460                 }
1461         }
1462 #endif // defined(CTS_USES_VULKAN)
1463
1464 #if defined(CTS_USES_VULKAN)
1465         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_opacity_micromap")) )
1466         {
1467                 if ( physicalDeviceOpacityMicromapFeaturesEXT.micromap == VK_FALSE )
1468                 {
1469                         log << tcu::TestLog::Message << "Mandatory feature micromap not supported" << tcu::TestLog::EndMessage;
1470                         result = false;
1471                 }
1472         }
1473 #endif // defined(CTS_USES_VULKAN)
1474
1475 #if defined(CTS_USES_VULKAN)
1476         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_pageable_device_local_memory")) )
1477         {
1478                 if ( physicalDevicePageableDeviceLocalMemoryFeaturesEXT.pageableDeviceLocalMemory == VK_FALSE )
1479                 {
1480                         log << tcu::TestLog::Message << "Mandatory feature pageableDeviceLocalMemory not supported" << tcu::TestLog::EndMessage;
1481                         result = false;
1482                 }
1483         }
1484 #endif // defined(CTS_USES_VULKAN)
1485
1486         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_pipeline_protected_access")) )
1487         {
1488                 if ( physicalDevicePipelineProtectedAccessFeaturesEXT.pipelineProtectedAccess == VK_FALSE )
1489                 {
1490                         log << tcu::TestLog::Message << "Mandatory feature pipelineProtectedAccess not supported" << tcu::TestLog::EndMessage;
1491                         result = false;
1492                 }
1493         }
1494
1495 #if defined(CTS_USES_VULKAN)
1496         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_primitive_topology_list_restart")) )
1497         {
1498                 if ( physicalDevicePrimitiveTopologyListRestartFeaturesEXT.primitiveTopologyListRestart == VK_FALSE )
1499                 {
1500                         log << tcu::TestLog::Message << "Mandatory feature primitiveTopologyListRestart not supported" << tcu::TestLog::EndMessage;
1501                         result = false;
1502                 }
1503         }
1504 #endif // defined(CTS_USES_VULKAN)
1505
1506         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_scalar_block_layout")) )
1507         {
1508                 if ( physicalDeviceScalarBlockLayoutFeatures.scalarBlockLayout == VK_FALSE )
1509                 {
1510                         log << tcu::TestLog::Message << "Mandatory feature scalarBlockLayout not supported" << tcu::TestLog::EndMessage;
1511                         result = false;
1512                 }
1513         }
1514
1515         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_atomic_float")) && physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32Atomics )
1516         {
1517                 if ( physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32Atomics == VK_FALSE )
1518                 {
1519                         log << tcu::TestLog::Message << "Mandatory feature shaderImageFloat32Atomics not supported" << tcu::TestLog::EndMessage;
1520                         result = false;
1521                 }
1522         }
1523
1524         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_atomic_float")) && physicalDeviceShaderAtomicFloatFeaturesEXT.sparseImageFloat32AtomicAdd )
1525         {
1526                 if ( physicalDeviceShaderAtomicFloatFeaturesEXT.shaderImageFloat32AtomicAdd == VK_FALSE )
1527                 {
1528                         log << tcu::TestLog::Message << "Mandatory feature shaderImageFloat32AtomicAdd not supported" << tcu::TestLog::EndMessage;
1529                         result = false;
1530                 }
1531         }
1532
1533 #if defined(CTS_USES_VULKAN)
1534         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_atomic_float2")) && physicalDeviceShaderAtomicFloat2FeaturesEXT.sparseImageFloat32AtomicMinMax )
1535         {
1536                 if ( physicalDeviceShaderAtomicFloat2FeaturesEXT.shaderImageFloat32AtomicMinMax == VK_FALSE )
1537                 {
1538                         log << tcu::TestLog::Message << "Mandatory feature shaderImageFloat32AtomicMinMax not supported" << tcu::TestLog::EndMessage;
1539                         result = false;
1540                 }
1541         }
1542 #endif // defined(CTS_USES_VULKAN)
1543
1544         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_demote_to_helper_invocation")) )
1545         {
1546                 if ( physicalDeviceShaderDemoteToHelperInvocationFeaturesEXT.shaderDemoteToHelperInvocation == VK_FALSE )
1547                 {
1548                         log << tcu::TestLog::Message << "Mandatory feature shaderDemoteToHelperInvocation not supported" << tcu::TestLog::EndMessage;
1549                         result = false;
1550                 }
1551         }
1552
1553         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_image_atomic_int64")) )
1554         {
1555                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
1556                 {
1557                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
1558                         result = false;
1559                 }
1560         }
1561
1562         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_image_atomic_int64")) )
1563         {
1564                 if ( physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics == VK_FALSE )
1565                 {
1566                         log << tcu::TestLog::Message << "Mandatory feature shaderImageInt64Atomics not supported" << tcu::TestLog::EndMessage;
1567                         result = false;
1568                 }
1569         }
1570
1571         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_image_atomic_int64")) && physicalDeviceShaderImageAtomicInt64FeaturesEXT.sparseImageInt64Atomics )
1572         {
1573                 if ( physicalDeviceShaderImageAtomicInt64FeaturesEXT.shaderImageInt64Atomics == VK_FALSE )
1574                 {
1575                         log << tcu::TestLog::Message << "Mandatory feature shaderImageInt64Atomics not supported" << tcu::TestLog::EndMessage;
1576                         result = false;
1577                 }
1578         }
1579
1580         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_module_identifier")) )
1581         {
1582                 if ( physicalDeviceShaderModuleIdentifierFeaturesEXT.shaderModuleIdentifier == VK_FALSE )
1583                 {
1584                         log << tcu::TestLog::Message << "Mandatory feature shaderModuleIdentifier not supported" << tcu::TestLog::EndMessage;
1585                         result = false;
1586                 }
1587         }
1588
1589         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_subgroup_size_control")) )
1590         {
1591                 if ( physicalDeviceSubgroupSizeControlFeaturesEXT.subgroupSizeControl == VK_FALSE )
1592                 {
1593                         log << tcu::TestLog::Message << "Mandatory feature subgroupSizeControl not supported" << tcu::TestLog::EndMessage;
1594                         result = false;
1595                 }
1596         }
1597
1598         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_subgroup_size_control")) )
1599         {
1600                 if ( physicalDeviceSubgroupSizeControlFeaturesEXT.computeFullSubgroups == VK_FALSE )
1601                 {
1602                         log << tcu::TestLog::Message << "Mandatory feature computeFullSubgroups not supported" << tcu::TestLog::EndMessage;
1603                         result = false;
1604                 }
1605         }
1606
1607         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_subpass_merge_feedback")) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_create_renderpass2")) )
1608         {
1609                 if ( physicalDeviceSubpassMergeFeedbackFeaturesEXT.subpassMergeFeedback == VK_FALSE )
1610                 {
1611                         log << tcu::TestLog::Message << "Mandatory feature subpassMergeFeedback not supported" << tcu::TestLog::EndMessage;
1612                         result = false;
1613                 }
1614         }
1615
1616         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_texel_buffer_alignment")) )
1617         {
1618                 if ( physicalDeviceTexelBufferAlignmentFeaturesEXT.texelBufferAlignment == VK_FALSE )
1619                 {
1620                         log << tcu::TestLog::Message << "Mandatory feature texelBufferAlignment not supported" << tcu::TestLog::EndMessage;
1621                         result = false;
1622                 }
1623         }
1624
1625         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_texture_compression_astc_hdr")) )
1626         {
1627                 if ( physicalDeviceTextureCompressionASTCHDRFeaturesEXT.textureCompressionASTC_HDR == VK_FALSE )
1628                 {
1629                         log << tcu::TestLog::Message << "Mandatory feature textureCompressionASTC_HDR not supported" << tcu::TestLog::EndMessage;
1630                         result = false;
1631                 }
1632         }
1633
1634         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_transform_feedback")) )
1635         {
1636                 if ( physicalDeviceTransformFeedbackFeaturesEXT.transformFeedback == VK_FALSE )
1637                 {
1638                         log << tcu::TestLog::Message << "Mandatory feature transformFeedback not supported" << tcu::TestLog::EndMessage;
1639                         result = false;
1640                 }
1641         }
1642
1643         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_vertex_attribute_divisor")) )
1644         {
1645                 if ( physicalDeviceVertexAttributeDivisorFeaturesEXT.vertexAttributeInstanceRateDivisor == VK_FALSE )
1646                 {
1647                         log << tcu::TestLog::Message << "Mandatory feature vertexAttributeInstanceRateDivisor not supported" << tcu::TestLog::EndMessage;
1648                         result = false;
1649                 }
1650         }
1651
1652         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_vertex_input_dynamic_state")) )
1653         {
1654                 if ( physicalDeviceVertexInputDynamicStateFeaturesEXT.vertexInputDynamicState == VK_FALSE )
1655                 {
1656                         log << tcu::TestLog::Message << "Mandatory feature vertexInputDynamicState not supported" << tcu::TestLog::EndMessage;
1657                         result = false;
1658                 }
1659         }
1660
1661         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_ycbcr_2plane_444_formats")) )
1662         {
1663                 if ( physicalDeviceYcbcr2Plane444FormatsFeaturesEXT.ycbcr2plane444Formats == VK_FALSE )
1664                 {
1665                         log << tcu::TestLog::Message << "Mandatory feature ycbcr2plane444Formats not supported" << tcu::TestLog::EndMessage;
1666                         result = false;
1667                 }
1668         }
1669
1670         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_ycbcr_image_arrays")) )
1671         {
1672                 if ( physicalDeviceYcbcrImageArraysFeaturesEXT.ycbcrImageArrays == VK_FALSE )
1673                 {
1674                         log << tcu::TestLog::Message << "Mandatory feature ycbcrImageArrays not supported" << tcu::TestLog::EndMessage;
1675                         result = false;
1676                 }
1677         }
1678
1679         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_16bit_storage")) )
1680         {
1681                 if ( physicalDevice16BitStorageFeatures.storageBuffer16BitAccess == VK_FALSE )
1682                 {
1683                         log << tcu::TestLog::Message << "Mandatory feature storageBuffer16BitAccess not supported" << tcu::TestLog::EndMessage;
1684                         result = false;
1685                 }
1686         }
1687
1688         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_8bit_storage")) )
1689         {
1690                 if ( physicalDevice8BitStorageFeatures.storageBuffer8BitAccess == VK_FALSE )
1691                 {
1692                         log << tcu::TestLog::Message << "Mandatory feature storageBuffer8BitAccess not supported" << tcu::TestLog::EndMessage;
1693                         result = false;
1694                 }
1695         }
1696
1697         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1698         {
1699                 if ( physicalDeviceAccelerationStructureFeaturesKHR.accelerationStructure == VK_FALSE )
1700                 {
1701                         log << tcu::TestLog::Message << "Mandatory feature accelerationStructure not supported" << tcu::TestLog::EndMessage;
1702                         result = false;
1703                 }
1704         }
1705
1706         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1707         {
1708                 if ( physicalDeviceAccelerationStructureFeaturesKHR.descriptorBindingAccelerationStructureUpdateAfterBind == VK_FALSE )
1709                 {
1710                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingAccelerationStructureUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
1711                         result = false;
1712                 }
1713         }
1714
1715         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_buffer_device_address")) )
1716         {
1717                 if ( physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress == VK_FALSE )
1718                 {
1719                         log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
1720                         result = false;
1721                 }
1722         }
1723
1724         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
1725         {
1726                 if ( physicalDeviceBufferDeviceAddressFeatures.bufferDeviceAddress == VK_FALSE )
1727                 {
1728                         log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
1729                         result = false;
1730                 }
1731         }
1732
1733         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_global_priority_query")) )
1734         {
1735                 if ( physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery == VK_FALSE )
1736                 {
1737                         log << tcu::TestLog::Message << "Mandatory feature globalPriorityQuery not supported" << tcu::TestLog::EndMessage;
1738                         result = false;
1739                 }
1740         }
1741
1742         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_global_priority")) )
1743         {
1744                 if ( physicalDeviceGlobalPriorityQueryFeaturesKHR.globalPriorityQuery == VK_FALSE )
1745                 {
1746                         log << tcu::TestLog::Message << "Mandatory feature globalPriorityQuery not supported" << tcu::TestLog::EndMessage;
1747                         result = false;
1748                 }
1749         }
1750
1751         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_imageless_framebuffer")) )
1752         {
1753                 if ( physicalDeviceImagelessFramebufferFeatures.imagelessFramebuffer == VK_FALSE )
1754                 {
1755                         log << tcu::TestLog::Message << "Mandatory feature imagelessFramebuffer not supported" << tcu::TestLog::EndMessage;
1756                         result = false;
1757                 }
1758         }
1759
1760         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_multiview")) )
1761         {
1762                 if ( physicalDeviceMultiviewFeatures.multiview == VK_FALSE )
1763                 {
1764                         log << tcu::TestLog::Message << "Mandatory feature multiview not supported" << tcu::TestLog::EndMessage;
1765                         result = false;
1766                 }
1767         }
1768
1769         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_performance_query")) )
1770         {
1771                 if ( physicalDevicePerformanceQueryFeaturesKHR.performanceCounterQueryPools == VK_FALSE )
1772                 {
1773                         log << tcu::TestLog::Message << "Mandatory feature performanceCounterQueryPools not supported" << tcu::TestLog::EndMessage;
1774                         result = false;
1775                 }
1776         }
1777
1778         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_pipeline_executable_properties")) )
1779         {
1780                 if ( physicalDevicePipelineExecutablePropertiesFeaturesKHR.pipelineExecutableInfo == VK_FALSE )
1781                 {
1782                         log << tcu::TestLog::Message << "Mandatory feature pipelineExecutableInfo not supported" << tcu::TestLog::EndMessage;
1783                         result = false;
1784                 }
1785         }
1786
1787 #if defined(CTS_USES_VULKAN)
1788         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_present_id")) )
1789         {
1790                 if ( physicalDevicePresentIdFeaturesKHR.presentId == VK_FALSE )
1791                 {
1792                         log << tcu::TestLog::Message << "Mandatory feature presentId not supported" << tcu::TestLog::EndMessage;
1793                         result = false;
1794                 }
1795         }
1796 #endif // defined(CTS_USES_VULKAN)
1797
1798 #if defined(CTS_USES_VULKAN)
1799         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_present_wait")) )
1800         {
1801                 if ( physicalDevicePresentWaitFeaturesKHR.presentWait == VK_FALSE )
1802                 {
1803                         log << tcu::TestLog::Message << "Mandatory feature presentWait not supported" << tcu::TestLog::EndMessage;
1804                         result = false;
1805                 }
1806         }
1807 #endif // defined(CTS_USES_VULKAN)
1808
1809         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_query")) )
1810         {
1811                 if ( physicalDeviceRayQueryFeaturesKHR.rayQuery == VK_FALSE )
1812                 {
1813                         log << tcu::TestLog::Message << "Mandatory feature rayQuery not supported" << tcu::TestLog::EndMessage;
1814                         result = false;
1815                 }
1816         }
1817
1818         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_tracing_maintenance1")) )
1819         {
1820                 if ( physicalDeviceRayTracingMaintenance1FeaturesKHR.rayTracingMaintenance1 == VK_FALSE )
1821                 {
1822                         log << tcu::TestLog::Message << "Mandatory feature rayTracingMaintenance1 not supported" << tcu::TestLog::EndMessage;
1823                         result = false;
1824                 }
1825         }
1826
1827         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_tracing_pipeline")) )
1828         {
1829                 if ( ( physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipeline == VK_FALSE ) && ( physicalDeviceRayTracingPipelineFeaturesKHR.rayTracingPipelineTraceRaysIndirect == VK_FALSE ) )
1830                 {
1831                         log << tcu::TestLog::Message << "Mandatory feature rayTracingPipeline or rayTracingPipelineTraceRaysIndirect not supported" << tcu::TestLog::EndMessage;
1832                         result = false;
1833                 }
1834         }
1835
1836         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_tracing_pipeline")) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_ray_query")) )
1837         {
1838                 if ( physicalDeviceRayTracingPipelineFeaturesKHR.rayTraversalPrimitiveCulling == VK_FALSE )
1839                 {
1840                         log << tcu::TestLog::Message << "Mandatory feature rayTraversalPrimitiveCulling not supported" << tcu::TestLog::EndMessage;
1841                         result = false;
1842                 }
1843         }
1844
1845         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_sampler_ycbcr_conversion")) )
1846         {
1847                 if ( physicalDeviceSamplerYcbcrConversionFeaturesKHR.samplerYcbcrConversion == VK_FALSE )
1848                 {
1849                         log << tcu::TestLog::Message << "Mandatory feature samplerYcbcrConversion not supported" << tcu::TestLog::EndMessage;
1850                         result = false;
1851                 }
1852         }
1853
1854         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_separate_depth_stencil_layouts")) )
1855         {
1856                 if ( physicalDeviceSeparateDepthStencilLayoutsFeatures.separateDepthStencilLayouts == VK_FALSE )
1857                 {
1858                         log << tcu::TestLog::Message << "Mandatory feature separateDepthStencilLayouts not supported" << tcu::TestLog::EndMessage;
1859                         result = false;
1860                 }
1861         }
1862
1863         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_atomic_int64")) )
1864         {
1865                 if ( physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics == VK_FALSE )
1866                 {
1867                         log << tcu::TestLog::Message << "Mandatory feature shaderBufferInt64Atomics not supported" << tcu::TestLog::EndMessage;
1868                         result = false;
1869                 }
1870         }
1871
1872         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_clock")) )
1873         {
1874                 if ( physicalDeviceShaderClockFeaturesKHR.shaderSubgroupClock == VK_FALSE )
1875                 {
1876                         log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupClock not supported" << tcu::TestLog::EndMessage;
1877                         result = false;
1878                 }
1879         }
1880
1881         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_float16_int8")) )
1882         {
1883                 if ( ( physicalDeviceShaderFloat16Int8Features.shaderFloat16 == VK_FALSE ) && ( physicalDeviceShaderFloat16Int8Features.shaderInt8 == VK_FALSE ) )
1884                 {
1885                         log << tcu::TestLog::Message << "Mandatory feature shaderFloat16 or shaderInt8 not supported" << tcu::TestLog::EndMessage;
1886                         result = false;
1887                 }
1888         }
1889
1890 #if defined(CTS_USES_VULKAN)
1891         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_integer_dot_product")) )
1892         {
1893                 if ( physicalDeviceShaderIntegerDotProductFeaturesKHR.shaderIntegerDotProduct == VK_FALSE )
1894                 {
1895                         log << tcu::TestLog::Message << "Mandatory feature shaderIntegerDotProduct not supported" << tcu::TestLog::EndMessage;
1896                         result = false;
1897                 }
1898         }
1899 #endif // defined(CTS_USES_VULKAN)
1900
1901         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_subgroup_extended_types")) )
1902         {
1903                 if ( physicalDeviceShaderSubgroupExtendedTypesFeatures.shaderSubgroupExtendedTypes == VK_FALSE )
1904                 {
1905                         log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupExtendedTypes not supported" << tcu::TestLog::EndMessage;
1906                         result = false;
1907                 }
1908         }
1909
1910         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_subgroup_uniform_control_flow")) )
1911         {
1912                 if ( physicalDeviceShaderSubgroupUniformControlFlowFeaturesKHR.shaderSubgroupUniformControlFlow == VK_FALSE )
1913                 {
1914                         log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupUniformControlFlow not supported" << tcu::TestLog::EndMessage;
1915                         result = false;
1916                 }
1917         }
1918
1919         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_shader_terminate_invocation")) )
1920         {
1921                 if ( physicalDeviceShaderTerminateInvocationFeaturesKHR.shaderTerminateInvocation == VK_FALSE )
1922                 {
1923                         log << tcu::TestLog::Message << "Mandatory feature shaderTerminateInvocation not supported" << tcu::TestLog::EndMessage;
1924                         result = false;
1925                 }
1926         }
1927
1928         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_synchronization2")) )
1929         {
1930                 if ( physicalDeviceSynchronization2FeaturesKHR.synchronization2 == VK_FALSE )
1931                 {
1932                         log << tcu::TestLog::Message << "Mandatory feature synchronization2 not supported" << tcu::TestLog::EndMessage;
1933                         result = false;
1934                 }
1935         }
1936
1937 #if defined(CTS_USES_VULKAN)
1938         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_timeline_semaphore")) )
1939         {
1940                 if ( physicalDeviceTimelineSemaphoreFeatures.timelineSemaphore == VK_FALSE )
1941                 {
1942                         log << tcu::TestLog::Message << "Mandatory feature timelineSemaphore not supported" << tcu::TestLog::EndMessage;
1943                         result = false;
1944                 }
1945         }
1946 #endif // defined(CTS_USES_VULKAN)
1947
1948         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_uniform_buffer_standard_layout")) )
1949         {
1950                 if ( physicalDeviceUniformBufferStandardLayoutFeatures.uniformBufferStandardLayout == VK_FALSE )
1951                 {
1952                         log << tcu::TestLog::Message << "Mandatory feature uniformBufferStandardLayout not supported" << tcu::TestLog::EndMessage;
1953                         result = false;
1954                 }
1955         }
1956
1957         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_variable_pointers")) )
1958         {
1959                 if ( physicalDeviceVariablePointersFeatures.variablePointersStorageBuffer == VK_FALSE )
1960                 {
1961                         log << tcu::TestLog::Message << "Mandatory feature variablePointersStorageBuffer not supported" << tcu::TestLog::EndMessage;
1962                         result = false;
1963                 }
1964         }
1965
1966         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_vulkan_memory_model")) )
1967         {
1968                 if ( physicalDeviceVulkanMemoryModelFeatures.vulkanMemoryModel == VK_FALSE )
1969                 {
1970                         log << tcu::TestLog::Message << "Mandatory feature vulkanMemoryModel not supported" << tcu::TestLog::EndMessage;
1971                         result = false;
1972                 }
1973         }
1974
1975         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_workgroup_memory_explicit_layout")) )
1976         {
1977                 if ( ( physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout == VK_FALSE ) && ( physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayoutScalarBlockLayout == VK_FALSE ) && ( physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout8BitAccess == VK_FALSE ) && ( physicalDeviceWorkgroupMemoryExplicitLayoutFeaturesKHR.workgroupMemoryExplicitLayout16BitAccess == VK_FALSE ) )
1978                 {
1979                         log << tcu::TestLog::Message << "Mandatory feature workgroupMemoryExplicitLayout or workgroupMemoryExplicitLayoutScalarBlockLayout or workgroupMemoryExplicitLayout8BitAccess or workgroupMemoryExplicitLayout16BitAccess not supported" << tcu::TestLog::EndMessage;
1980                         result = false;
1981                 }
1982         }
1983
1984         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_zero_initialize_workgroup_memory")) )
1985         {
1986                 if ( physicalDeviceZeroInitializeWorkgroupMemoryFeaturesKHR.shaderZeroInitializeWorkgroupMemory == VK_FALSE )
1987                 {
1988                         log << tcu::TestLog::Message << "Mandatory feature shaderZeroInitializeWorkgroupMemory not supported" << tcu::TestLog::EndMessage;
1989                         result = false;
1990                 }
1991         }
1992
1993         if ( isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_VALVE_mutable_descriptor_type")) )
1994         {
1995                 if ( physicalDeviceMutableDescriptorTypeFeaturesVALVE.mutableDescriptorType == VK_FALSE )
1996                 {
1997                         log << tcu::TestLog::Message << "Mandatory feature mutableDescriptorType not supported" << tcu::TestLog::EndMessage;
1998                         result = false;
1999                 }
2000         }
2001
2002         {
2003                 if ( coreFeatures.features.robustBufferAccess == VK_FALSE )
2004                 {
2005                         log << tcu::TestLog::Message << "Mandatory feature robustBufferAccess not supported" << tcu::TestLog::EndMessage;
2006                         result = false;
2007                 }
2008         }
2009
2010         if ( physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics )
2011         {
2012                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
2013                 {
2014                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
2015                         result = false;
2016                 }
2017         }
2018
2019         if ( physicalDeviceVulkan12Features.shaderBufferInt64Atomics )
2020         {
2021                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
2022                 {
2023                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
2024                         result = false;
2025                 }
2026         }
2027
2028         if ( physicalDeviceShaderAtomicInt64Features.shaderSharedInt64Atomics )
2029         {
2030                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
2031                 {
2032                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
2033                         result = false;
2034                 }
2035         }
2036
2037         if ( physicalDeviceVulkan12Features.shaderSharedInt64Atomics )
2038         {
2039                 if ( coreFeatures.features.shaderInt64 == VK_FALSE )
2040                 {
2041                         log << tcu::TestLog::Message << "Mandatory feature shaderInt64 not supported" << tcu::TestLog::EndMessage;
2042                         result = false;
2043                 }
2044         }
2045
2046 #if defined(CTS_USES_VULKAN)
2047         if ( context.contextSupports(vk::ApiVersion(0, 1, 1, 0)) )
2048         {
2049                 if ( physicalDeviceMultiviewFeatures.multiview == VK_FALSE )
2050                 {
2051                         log << tcu::TestLog::Message << "Mandatory feature multiview not supported" << tcu::TestLog::EndMessage;
2052                         result = false;
2053                 }
2054         }
2055 #endif // defined(CTS_USES_VULKAN)
2056
2057         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2058         {
2059                 if ( coreFeatures.features.shaderSampledImageArrayDynamicIndexing == VK_FALSE )
2060                 {
2061                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2062                         result = false;
2063                 }
2064         }
2065
2066         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2067         {
2068                 if ( coreFeatures.features.shaderStorageBufferArrayDynamicIndexing == VK_FALSE )
2069                 {
2070                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2071                         result = false;
2072                 }
2073         }
2074
2075 #if defined(CTS_USES_VULKAN)
2076         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2077         {
2078                 if ( physicalDeviceVulkan11Features.multiview == VK_FALSE )
2079                 {
2080                         log << tcu::TestLog::Message << "Mandatory feature multiview not supported" << tcu::TestLog::EndMessage;
2081                         result = false;
2082                 }
2083         }
2084 #endif // defined(CTS_USES_VULKAN)
2085
2086         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2087         {
2088                 if ( physicalDeviceVulkan12Features.subgroupBroadcastDynamicId == VK_FALSE )
2089                 {
2090                         log << tcu::TestLog::Message << "Mandatory feature subgroupBroadcastDynamicId not supported" << tcu::TestLog::EndMessage;
2091                         result = false;
2092                 }
2093         }
2094
2095         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2096         {
2097                 if ( physicalDeviceVulkan12Features.shaderSubgroupExtendedTypes == VK_FALSE )
2098                 {
2099                         log << tcu::TestLog::Message << "Mandatory feature shaderSubgroupExtendedTypes not supported" << tcu::TestLog::EndMessage;
2100                         result = false;
2101                 }
2102         }
2103
2104         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2105         {
2106                 if ( physicalDeviceVulkan12Features.imagelessFramebuffer == VK_FALSE )
2107                 {
2108                         log << tcu::TestLog::Message << "Mandatory feature imagelessFramebuffer not supported" << tcu::TestLog::EndMessage;
2109                         result = false;
2110                 }
2111         }
2112
2113         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2114         {
2115                 if ( physicalDeviceVulkan12Features.uniformBufferStandardLayout == VK_FALSE )
2116                 {
2117                         log << tcu::TestLog::Message << "Mandatory feature uniformBufferStandardLayout not supported" << tcu::TestLog::EndMessage;
2118                         result = false;
2119                 }
2120         }
2121
2122         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2123         {
2124                 if ( physicalDeviceVulkan12Features.separateDepthStencilLayouts == VK_FALSE )
2125                 {
2126                         log << tcu::TestLog::Message << "Mandatory feature separateDepthStencilLayouts not supported" << tcu::TestLog::EndMessage;
2127                         result = false;
2128                 }
2129         }
2130
2131         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2132         {
2133                 if ( physicalDeviceVulkan12Features.hostQueryReset == VK_FALSE )
2134                 {
2135                         log << tcu::TestLog::Message << "Mandatory feature hostQueryReset not supported" << tcu::TestLog::EndMessage;
2136                         result = false;
2137                 }
2138         }
2139
2140 #if defined(CTS_USES_VULKAN)
2141         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) )
2142         {
2143                 if ( physicalDeviceVulkan12Features.timelineSemaphore == VK_FALSE )
2144                 {
2145                         log << tcu::TestLog::Message << "Mandatory feature timelineSemaphore not supported" << tcu::TestLog::EndMessage;
2146                         result = false;
2147                 }
2148         }
2149 #endif // defined(CTS_USES_VULKAN)
2150
2151         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2152         {
2153                 if ( physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing == VK_FALSE )
2154                 {
2155                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2156                         result = false;
2157                 }
2158         }
2159
2160         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2161         {
2162                 if ( physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing == VK_FALSE )
2163                 {
2164                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2165                         result = false;
2166                 }
2167         }
2168
2169         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2170         {
2171                 if ( physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing == VK_FALSE )
2172                 {
2173                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2174                         result = false;
2175                 }
2176         }
2177
2178         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2179         {
2180                 if ( physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing == VK_FALSE )
2181                 {
2182                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2183                         result = false;
2184                 }
2185         }
2186
2187         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2188         {
2189                 if ( physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing == VK_FALSE )
2190                 {
2191                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2192                         result = false;
2193                 }
2194         }
2195
2196         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2197         {
2198                 if ( physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind == VK_FALSE )
2199                 {
2200                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingSampledImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2201                         result = false;
2202                 }
2203         }
2204
2205         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2206         {
2207                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind == VK_FALSE )
2208                 {
2209                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2210                         result = false;
2211                 }
2212         }
2213
2214         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2215         {
2216                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind == VK_FALSE )
2217                 {
2218                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2219                         result = false;
2220                 }
2221         }
2222
2223         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2224         {
2225                 if ( physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind == VK_FALSE )
2226                 {
2227                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUniformTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2228                         result = false;
2229                 }
2230         }
2231
2232         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2233         {
2234                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind == VK_FALSE )
2235                 {
2236                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2237                         result = false;
2238                 }
2239         }
2240
2241         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2242         {
2243                 if ( physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending == VK_FALSE )
2244                 {
2245                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUpdateUnusedWhilePending not supported" << tcu::TestLog::EndMessage;
2246                         result = false;
2247                 }
2248         }
2249
2250         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2251         {
2252                 if ( physicalDeviceVulkan12Features.descriptorBindingPartiallyBound == VK_FALSE )
2253                 {
2254                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingPartiallyBound not supported" << tcu::TestLog::EndMessage;
2255                         result = false;
2256                 }
2257         }
2258
2259         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2260         {
2261                 if ( physicalDeviceVulkan12Features.runtimeDescriptorArray == VK_FALSE )
2262                 {
2263                         log << tcu::TestLog::Message << "Mandatory feature runtimeDescriptorArray not supported" << tcu::TestLog::EndMessage;
2264                         result = false;
2265                 }
2266         }
2267
2268         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && physicalDeviceShaderAtomicInt64Features.shaderBufferInt64Atomics )
2269         {
2270                 if ( physicalDeviceVulkan12Features.shaderBufferInt64Atomics == VK_FALSE )
2271                 {
2272                         log << tcu::TestLog::Message << "Mandatory feature shaderBufferInt64Atomics not supported" << tcu::TestLog::EndMessage;
2273                         result = false;
2274                 }
2275         }
2276
2277         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_draw_indirect_count")) )
2278         {
2279                 if ( physicalDeviceVulkan12Features.drawIndirectCount == VK_FALSE )
2280                 {
2281                         log << tcu::TestLog::Message << "Mandatory feature drawIndirectCount not supported" << tcu::TestLog::EndMessage;
2282                         result = false;
2283                 }
2284         }
2285
2286         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_sampler_mirror_clamp_to_edge")) )
2287         {
2288                 if ( physicalDeviceVulkan12Features.samplerMirrorClampToEdge == VK_FALSE )
2289                 {
2290                         log << tcu::TestLog::Message << "Mandatory feature samplerMirrorClampToEdge not supported" << tcu::TestLog::EndMessage;
2291                         result = false;
2292                 }
2293         }
2294
2295         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_sampler_filter_minmax")) )
2296         {
2297                 if ( physicalDeviceVulkan12Features.samplerFilterMinmax == VK_FALSE )
2298                 {
2299                         log << tcu::TestLog::Message << "Mandatory feature samplerFilterMinmax not supported" << tcu::TestLog::EndMessage;
2300                         result = false;
2301                 }
2302         }
2303
2304         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_viewport_index_layer")) )
2305         {
2306                 if ( physicalDeviceVulkan12Features.shaderOutputViewportIndex == VK_FALSE )
2307                 {
2308                         log << tcu::TestLog::Message << "Mandatory feature shaderOutputViewportIndex not supported" << tcu::TestLog::EndMessage;
2309                         result = false;
2310                 }
2311         }
2312
2313         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_EXT_shader_viewport_index_layer")) )
2314         {
2315                 if ( physicalDeviceVulkan12Features.shaderOutputLayer == VK_FALSE )
2316                 {
2317                         log << tcu::TestLog::Message << "Mandatory feature shaderOutputLayer not supported" << tcu::TestLog::EndMessage;
2318                         result = false;
2319                 }
2320         }
2321
2322         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2323         {
2324                 if ( physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayDynamicIndexing == VK_FALSE )
2325                 {
2326                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2327                         result = false;
2328                 }
2329         }
2330
2331         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2332         {
2333                 if ( physicalDeviceVulkan12Features.shaderStorageTexelBufferArrayDynamicIndexing == VK_FALSE )
2334                 {
2335                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageTexelBufferArrayDynamicIndexing not supported" << tcu::TestLog::EndMessage;
2336                         result = false;
2337                 }
2338         }
2339
2340         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2341         {
2342                 if ( physicalDeviceVulkan12Features.shaderSampledImageArrayNonUniformIndexing == VK_FALSE )
2343                 {
2344                         log << tcu::TestLog::Message << "Mandatory feature shaderSampledImageArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2345                         result = false;
2346                 }
2347         }
2348
2349         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2350         {
2351                 if ( physicalDeviceVulkan12Features.shaderStorageBufferArrayNonUniformIndexing == VK_FALSE )
2352                 {
2353                         log << tcu::TestLog::Message << "Mandatory feature shaderStorageBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2354                         result = false;
2355                 }
2356         }
2357
2358         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2359         {
2360                 if ( physicalDeviceVulkan12Features.shaderUniformTexelBufferArrayNonUniformIndexing == VK_FALSE )
2361                 {
2362                         log << tcu::TestLog::Message << "Mandatory feature shaderUniformTexelBufferArrayNonUniformIndexing not supported" << tcu::TestLog::EndMessage;
2363                         result = false;
2364                 }
2365         }
2366
2367         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2368         {
2369                 if ( physicalDeviceVulkan12Features.descriptorBindingSampledImageUpdateAfterBind == VK_FALSE )
2370                 {
2371                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingSampledImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2372                         result = false;
2373                 }
2374         }
2375
2376         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2377         {
2378                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageImageUpdateAfterBind == VK_FALSE )
2379                 {
2380                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageImageUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2381                         result = false;
2382                 }
2383         }
2384
2385         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2386         {
2387                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageBufferUpdateAfterBind == VK_FALSE )
2388                 {
2389                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2390                         result = false;
2391                 }
2392         }
2393
2394         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2395         {
2396                 if ( physicalDeviceVulkan12Features.descriptorBindingUniformTexelBufferUpdateAfterBind == VK_FALSE )
2397                 {
2398                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUniformTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2399                         result = false;
2400                 }
2401         }
2402
2403         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2404         {
2405                 if ( physicalDeviceVulkan12Features.descriptorBindingStorageTexelBufferUpdateAfterBind == VK_FALSE )
2406                 {
2407                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingStorageTexelBufferUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2408                         result = false;
2409                 }
2410         }
2411
2412         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2413         {
2414                 if ( physicalDeviceVulkan12Features.descriptorBindingUpdateUnusedWhilePending == VK_FALSE )
2415                 {
2416                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingUpdateUnusedWhilePending not supported" << tcu::TestLog::EndMessage;
2417                         result = false;
2418                 }
2419         }
2420
2421         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2422         {
2423                 if ( physicalDeviceVulkan12Features.descriptorBindingPartiallyBound == VK_FALSE )
2424                 {
2425                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingPartiallyBound not supported" << tcu::TestLog::EndMessage;
2426                         result = false;
2427                 }
2428         }
2429
2430         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2431         {
2432                 if ( physicalDeviceVulkan12Features.runtimeDescriptorArray == VK_FALSE )
2433                 {
2434                         log << tcu::TestLog::Message << "Mandatory feature runtimeDescriptorArray not supported" << tcu::TestLog::EndMessage;
2435                         result = false;
2436                 }
2437         }
2438
2439         if ( context.contextSupports(vk::ApiVersion(0, 1, 2, 0)) && isExtensionStructSupported(deviceExtensions, RequiredExtension("VK_KHR_acceleration_structure")) )
2440         {
2441                 if ( physicalDeviceVulkan12Features.bufferDeviceAddress == VK_FALSE )
2442                 {
2443                         log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
2444                         result = false;
2445                 }
2446         }
2447
2448 #if defined(CTS_USES_VULKAN)
2449         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2450         {
2451                 if ( physicalDeviceVulkan12Features.bufferDeviceAddress == VK_FALSE )
2452                 {
2453                         log << tcu::TestLog::Message << "Mandatory feature bufferDeviceAddress not supported" << tcu::TestLog::EndMessage;
2454                         result = false;
2455                 }
2456         }
2457 #endif // defined(CTS_USES_VULKAN)
2458
2459 #if defined(CTS_USES_VULKANSC)
2460         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2461         {
2462                 if ( physicalDeviceVulkan12Features.vulkanMemoryModel == VK_FALSE )
2463                 {
2464                         log << tcu::TestLog::Message << "Mandatory feature vulkanMemoryModel not supported" << tcu::TestLog::EndMessage;
2465                         result = false;
2466                 }
2467         }
2468 #endif // defined(CTS_USES_VULKANSC)
2469
2470 #if defined(CTS_USES_VULKAN)
2471         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2472         {
2473                 if ( physicalDeviceVulkan12Features.vulkanMemoryModelDeviceScope == VK_FALSE )
2474                 {
2475                         log << tcu::TestLog::Message << "Mandatory feature vulkanMemoryModelDeviceScope not supported" << tcu::TestLog::EndMessage;
2476                         result = false;
2477                 }
2478         }
2479 #endif // defined(CTS_USES_VULKAN)
2480
2481 #if defined(CTS_USES_VULKAN)
2482         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2483         {
2484                 if ( physicalDeviceVulkan13Features.robustImageAccess == VK_FALSE )
2485                 {
2486                         log << tcu::TestLog::Message << "Mandatory feature robustImageAccess not supported" << tcu::TestLog::EndMessage;
2487                         result = false;
2488                 }
2489         }
2490 #endif // defined(CTS_USES_VULKAN)
2491
2492 #if defined(CTS_USES_VULKAN)
2493         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2494         {
2495                 if ( physicalDeviceVulkan13Features.inlineUniformBlock == VK_FALSE )
2496                 {
2497                         log << tcu::TestLog::Message << "Mandatory feature inlineUniformBlock not supported" << tcu::TestLog::EndMessage;
2498                         result = false;
2499                 }
2500         }
2501 #endif // defined(CTS_USES_VULKAN)
2502
2503 #if defined(CTS_USES_VULKAN)
2504         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) && physicalDeviceVulkan12Features.descriptorIndexing )
2505         {
2506                 if ( physicalDeviceVulkan13Features.descriptorBindingInlineUniformBlockUpdateAfterBind == VK_FALSE )
2507                 {
2508                         log << tcu::TestLog::Message << "Mandatory feature descriptorBindingInlineUniformBlockUpdateAfterBind not supported" << tcu::TestLog::EndMessage;
2509                         result = false;
2510                 }
2511         }
2512 #endif // defined(CTS_USES_VULKAN)
2513
2514 #if defined(CTS_USES_VULKAN)
2515         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2516         {
2517                 if ( physicalDeviceVulkan13Features.pipelineCreationCacheControl == VK_FALSE )
2518                 {
2519                         log << tcu::TestLog::Message << "Mandatory feature pipelineCreationCacheControl not supported" << tcu::TestLog::EndMessage;
2520                         result = false;
2521                 }
2522         }
2523 #endif // defined(CTS_USES_VULKAN)
2524
2525 #if defined(CTS_USES_VULKAN)
2526         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2527         {
2528                 if ( physicalDeviceVulkan13Features.privateData == VK_FALSE )
2529                 {
2530                         log << tcu::TestLog::Message << "Mandatory feature privateData not supported" << tcu::TestLog::EndMessage;
2531                         result = false;
2532                 }
2533         }
2534 #endif // defined(CTS_USES_VULKAN)
2535
2536 #if defined(CTS_USES_VULKAN)
2537         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2538         {
2539                 if ( physicalDeviceVulkan13Features.shaderDemoteToHelperInvocation == VK_FALSE )
2540                 {
2541                         log << tcu::TestLog::Message << "Mandatory feature shaderDemoteToHelperInvocation not supported" << tcu::TestLog::EndMessage;
2542                         result = false;
2543                 }
2544         }
2545 #endif // defined(CTS_USES_VULKAN)
2546
2547 #if defined(CTS_USES_VULKAN)
2548         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2549         {
2550                 if ( physicalDeviceVulkan13Features.shaderTerminateInvocation == VK_FALSE )
2551                 {
2552                         log << tcu::TestLog::Message << "Mandatory feature shaderTerminateInvocation not supported" << tcu::TestLog::EndMessage;
2553                         result = false;
2554                 }
2555         }
2556 #endif // defined(CTS_USES_VULKAN)
2557
2558 #if defined(CTS_USES_VULKAN)
2559         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2560         {
2561                 if ( physicalDeviceVulkan13Features.subgroupSizeControl == VK_FALSE )
2562                 {
2563                         log << tcu::TestLog::Message << "Mandatory feature subgroupSizeControl not supported" << tcu::TestLog::EndMessage;
2564                         result = false;
2565                 }
2566         }
2567 #endif // defined(CTS_USES_VULKAN)
2568
2569 #if defined(CTS_USES_VULKAN)
2570         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2571         {
2572                 if ( physicalDeviceVulkan13Features.computeFullSubgroups == VK_FALSE )
2573                 {
2574                         log << tcu::TestLog::Message << "Mandatory feature computeFullSubgroups not supported" << tcu::TestLog::EndMessage;
2575                         result = false;
2576                 }
2577         }
2578 #endif // defined(CTS_USES_VULKAN)
2579
2580 #if defined(CTS_USES_VULKAN)
2581         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2582         {
2583                 if ( physicalDeviceVulkan13Features.synchronization2 == VK_FALSE )
2584                 {
2585                         log << tcu::TestLog::Message << "Mandatory feature synchronization2 not supported" << tcu::TestLog::EndMessage;
2586                         result = false;
2587                 }
2588         }
2589 #endif // defined(CTS_USES_VULKAN)
2590
2591 #if defined(CTS_USES_VULKAN)
2592         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2593         {
2594                 if ( physicalDeviceVulkan13Features.shaderZeroInitializeWorkgroupMemory == VK_FALSE )
2595                 {
2596                         log << tcu::TestLog::Message << "Mandatory feature shaderZeroInitializeWorkgroupMemory not supported" << tcu::TestLog::EndMessage;
2597                         result = false;
2598                 }
2599         }
2600 #endif // defined(CTS_USES_VULKAN)
2601
2602 #if defined(CTS_USES_VULKAN)
2603         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2604         {
2605                 if ( physicalDeviceVulkan13Features.dynamicRendering == VK_FALSE )
2606                 {
2607                         log << tcu::TestLog::Message << "Mandatory feature dynamicRendering not supported" << tcu::TestLog::EndMessage;
2608                         result = false;
2609                 }
2610         }
2611 #endif // defined(CTS_USES_VULKAN)
2612
2613 #if defined(CTS_USES_VULKAN)
2614         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2615         {
2616                 if ( physicalDeviceVulkan13Features.shaderIntegerDotProduct == VK_FALSE )
2617                 {
2618                         log << tcu::TestLog::Message << "Mandatory feature shaderIntegerDotProduct not supported" << tcu::TestLog::EndMessage;
2619                         result = false;
2620                 }
2621         }
2622 #endif // defined(CTS_USES_VULKAN)
2623
2624 #if defined(CTS_USES_VULKAN)
2625         if ( context.contextSupports(vk::ApiVersion(0, 1, 3, 0)) )
2626         {
2627                 if ( physicalDeviceVulkan13Features.maintenance4 == VK_FALSE )
2628                 {
2629                         log << tcu::TestLog::Message << "Mandatory feature maintenance4 not supported" << tcu::TestLog::EndMessage;
2630                         result = false;
2631                 }
2632         }
2633 #endif // defined(CTS_USES_VULKAN)
2634
2635         return result;
2636 }
2637