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