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