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