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

   1 /* WARNING: This is auto-generated file. Do not modify, since changes will
   2  * be lost! Modify the generating script instead.
   3  * This file was generated by /scripts/gen_framework.py
   4  */
   5
   6
   7 void getInstanceExtensionFunctions (uint32_t apiVersion, ::std::string extName, ::std::vector<const char*>& functions)
   8 {
   9         if (extName == "VK_KHR_surface")
  10         {
  11                 functions.push_back("vkDestroySurfaceKHR");
  12                 functions.push_back("vkGetPhysicalDeviceSurfaceSupportKHR");
  13                 functions.push_back("vkGetPhysicalDeviceSurfaceCapabilitiesKHR");
  14                 functions.push_back("vkGetPhysicalDeviceSurfaceFormatsKHR");
  15                 functions.push_back("vkGetPhysicalDeviceSurfacePresentModesKHR");
  16                 return;
  17         }
  18         if (extName == "VK_KHR_swapchain")
  19         {
  20                 if(apiVersion >= VK_API_VERSION_1_1) functions.push_back("vkGetPhysicalDevicePresentRectanglesKHR");
  21                 return;
  22         }
  23         if (extName == "VK_KHR_display")
  24         {
  25                 functions.push_back("vkGetPhysicalDeviceDisplayPropertiesKHR");
  26                 functions.push_back("vkGetPhysicalDeviceDisplayPlanePropertiesKHR");
  27                 functions.push_back("vkGetDisplayPlaneSupportedDisplaysKHR");
  28                 functions.push_back("vkGetDisplayModePropertiesKHR");
  29                 functions.push_back("vkCreateDisplayModeKHR");
  30                 functions.push_back("vkGetDisplayPlaneCapabilitiesKHR");
  31                 functions.push_back("vkCreateDisplayPlaneSurfaceKHR");
  32                 return;
  33         }
  34         if (extName == "VK_KHR_display_swapchain")
  35         {
  36                 return;
  37         }
  38         if (extName == "VK_KHR_xlib_surface")
  39         {
  40                 functions.push_back("vkCreateXlibSurfaceKHR");
  41                 functions.push_back("vkGetPhysicalDeviceXlibPresentationSupportKHR");
  42                 return;
  43         }
  44         if (extName == "VK_KHR_xcb_surface")
  45         {
  46                 functions.push_back("vkCreateXcbSurfaceKHR");
  47                 functions.push_back("vkGetPhysicalDeviceXcbPresentationSupportKHR");
  48                 return;
  49         }
  50         if (extName == "VK_KHR_wayland_surface")
  51         {
  52                 functions.push_back("vkCreateWaylandSurfaceKHR");
  53                 functions.push_back("vkGetPhysicalDeviceWaylandPresentationSupportKHR");
  54                 return;
  55         }
  56         if (extName == "VK_KHR_android_surface")
  57         {
  58                 functions.push_back("vkCreateAndroidSurfaceKHR");
  59                 return;
  60         }
  61         if (extName == "VK_KHR_win32_surface")
  62         {
  63                 functions.push_back("vkCreateWin32SurfaceKHR");
  64                 functions.push_back("vkGetPhysicalDeviceWin32PresentationSupportKHR");
  65                 return;
  66         }
  67         if (extName == "VK_EXT_debug_report")
  68         {
  69                 functions.push_back("vkCreateDebugReportCallbackEXT");
  70                 functions.push_back("vkDestroyDebugReportCallbackEXT");
  71                 functions.push_back("vkDebugReportMessageEXT");
  72                 return;
  73         }
  74         if (extName == "VK_NV_glsl_shader")
  75         {
  76                 return;
  77         }
  78         if (extName == "VK_EXT_depth_range_unrestricted")
  79         {
  80                 return;
  81         }
  82         if (extName == "VK_KHR_sampler_mirror_clamp_to_edge")
  83         {
  84                 return;
  85         }
  86         if (extName == "VK_IMG_filter_cubic")
  87         {
  88                 return;
  89         }
  90         if (extName == "VK_AMD_rasterization_order")
  91         {
  92                 return;
  93         }
  94         if (extName == "VK_AMD_shader_trinary_minmax")
  95         {
  96                 return;
  97         }
  98         if (extName == "VK_AMD_shader_explicit_vertex_parameter")
  99         {
 100                 return;
 101         }
 102         if (extName == "VK_EXT_debug_marker")
 103         {
 104                 return;
 105         }
 106         if (extName == "VK_KHR_video_queue")
 107         {
 108                 functions.push_back("vkGetPhysicalDeviceVideoCapabilitiesKHR");
 109                 functions.push_back("vkGetPhysicalDeviceVideoFormatPropertiesKHR");
 110                 return;
 111         }
 112         if (extName == "VK_KHR_video_decode_queue")
 113         {
 114                 return;
 115         }
 116         if (extName == "VK_AMD_gcn_shader")
 117         {
 118                 return;
 119         }
 120         if (extName == "VK_NV_dedicated_allocation")
 121         {
 122                 return;
 123         }
 124         if (extName == "VK_EXT_transform_feedback")
 125         {
 126                 return;
 127         }
 128         if (extName == "VK_NVX_binary_import")
 129         {
 130                 return;
 131         }
 132         if (extName == "VK_NVX_image_view_handle")
 133         {
 134                 return;
 135         }
 136         if (extName == "VK_AMD_draw_indirect_count")
 137         {
 138                 return;
 139         }
 140         if (extName == "VK_AMD_negative_viewport_height")
 141         {
 142                 return;
 143         }
 144         if (extName == "VK_AMD_gpu_shader_half_float")
 145         {
 146                 return;
 147         }
 148         if (extName == "VK_AMD_shader_ballot")
 149         {
 150                 return;
 151         }
 152         if (extName == "VK_EXT_video_encode_h264")
 153         {
 154                 return;
 155         }
 156         if (extName == "VK_EXT_video_encode_h265")
 157         {
 158                 return;
 159         }
 160         if (extName == "VK_EXT_video_decode_h264")
 161         {
 162                 return;
 163         }
 164         if (extName == "VK_AMD_texture_gather_bias_lod")
 165         {
 166                 return;
 167         }
 168         if (extName == "VK_AMD_shader_info")
 169         {
 170                 return;
 171         }
 172         if (extName == "VK_KHR_dynamic_rendering")
 173         {
 174                 return;
 175         }
 176         if (extName == "VK_AMD_shader_image_load_store_lod")
 177         {
 178                 return;
 179         }
 180         if (extName == "VK_GGP_stream_descriptor_surface")
 181         {
 182                 functions.push_back("vkCreateStreamDescriptorSurfaceGGP");
 183                 return;
 184         }
 185         if (extName == "VK_NV_corner_sampled_image")
 186         {
 187                 return;
 188         }
 189         if (extName == "VK_KHR_multiview")
 190         {
 191                 return;
 192         }
 193         if (extName == "VK_IMG_format_pvrtc")
 194         {
 195                 return;
 196         }
 197         if (extName == "VK_NV_external_memory_capabilities")
 198         {
 199                 functions.push_back("vkGetPhysicalDeviceExternalImageFormatPropertiesNV");
 200                 return;
 201         }
 202         if (extName == "VK_NV_external_memory")
 203         {
 204                 return;
 205         }
 206         if (extName == "VK_NV_external_memory_win32")
 207         {
 208                 return;
 209         }
 210         if (extName == "VK_NV_win32_keyed_mutex")
 211         {
 212                 return;
 213         }
 214         if (extName == "VK_KHR_get_physical_device_properties2")
 215         {
 216                 return;
 217         }
 218         if (extName == "VK_KHR_device_group")
 219         {
 220                 if(apiVersion >= VK_API_VERSION_1_1) functions.push_back("vkGetPhysicalDevicePresentRectanglesKHR");
 221                 if(apiVersion < VK_API_VERSION_1_1) functions.push_back("vkGetPhysicalDevicePresentRectanglesKHR");
 222                 return;
 223         }
 224         if (extName == "VK_EXT_validation_flags")
 225         {
 226                 return;
 227         }
 228         if (extName == "VK_NN_vi_surface")
 229         {
 230                 functions.push_back("vkCreateViSurfaceNN");
 231                 return;
 232         }
 233         if (extName == "VK_KHR_shader_draw_parameters")
 234         {
 235                 return;
 236         }
 237         if (extName == "VK_EXT_shader_subgroup_ballot")
 238         {
 239                 return;
 240         }
 241         if (extName == "VK_EXT_shader_subgroup_vote")
 242         {
 243                 return;
 244         }
 245         if (extName == "VK_EXT_texture_compression_astc_hdr")
 246         {
 247                 return;
 248         }
 249         if (extName == "VK_EXT_astc_decode_mode")
 250         {
 251                 return;
 252         }
 253         if (extName == "VK_EXT_pipeline_robustness")
 254         {
 255                 return;
 256         }
 257         if (extName == "VK_KHR_maintenance1")
 258         {
 259                 return;
 260         }
 261         if (extName == "VK_KHR_device_group_creation")
 262         {
 263                 return;
 264         }
 265         if (extName == "VK_KHR_external_memory_capabilities")
 266         {
 267                 return;
 268         }
 269         if (extName == "VK_KHR_external_memory")
 270         {
 271                 return;
 272         }
 273         if (extName == "VK_KHR_external_memory_win32")
 274         {
 275                 return;
 276         }
 277         if (extName == "VK_KHR_external_memory_fd")
 278         {
 279                 return;
 280         }
 281         if (extName == "VK_KHR_win32_keyed_mutex")
 282         {
 283                 return;
 284         }
 285         if (extName == "VK_KHR_external_semaphore_capabilities")
 286         {
 287                 return;
 288         }
 289         if (extName == "VK_KHR_external_semaphore")
 290         {
 291                 return;
 292         }
 293         if (extName == "VK_KHR_external_semaphore_win32")
 294         {
 295                 return;
 296         }
 297         if (extName == "VK_KHR_external_semaphore_fd")
 298         {
 299                 return;
 300         }
 301         if (extName == "VK_KHR_push_descriptor")
 302         {
 303                 return;
 304         }
 305         if (extName == "VK_EXT_conditional_rendering")
 306         {
 307                 return;
 308         }
 309         if (extName == "VK_KHR_shader_float16_int8")
 310         {
 311                 return;
 312         }
 313         if (extName == "VK_KHR_16bit_storage")
 314         {
 315                 return;
 316         }
 317         if (extName == "VK_KHR_incremental_present")
 318         {
 319                 return;
 320         }
 321         if (extName == "VK_KHR_descriptor_update_template")
 322         {
 323                 return;
 324         }
 325         if (extName == "VK_NV_clip_space_w_scaling")
 326         {
 327                 return;
 328         }
 329         if (extName == "VK_EXT_direct_mode_display")
 330         {
 331                 functions.push_back("vkReleaseDisplayEXT");
 332                 return;
 333         }
 334         if (extName == "VK_EXT_acquire_xlib_display")
 335         {
 336                 functions.push_back("vkAcquireXlibDisplayEXT");
 337                 functions.push_back("vkGetRandROutputDisplayEXT");
 338                 return;
 339         }
 340         if (extName == "VK_EXT_display_surface_counter")
 341         {
 342                 functions.push_back("vkGetPhysicalDeviceSurfaceCapabilities2EXT");
 343                 return;
 344         }
 345         if (extName == "VK_EXT_display_control")
 346         {
 347                 return;
 348         }
 349         if (extName == "VK_GOOGLE_display_timing")
 350         {
 351                 return;
 352         }
 353         if (extName == "VK_NV_sample_mask_override_coverage")
 354         {
 355                 return;
 356         }
 357         if (extName == "VK_NV_geometry_shader_passthrough")
 358         {
 359                 return;
 360         }
 361         if (extName == "VK_NV_viewport_array2")
 362         {
 363                 return;
 364         }
 365         if (extName == "VK_NVX_multiview_per_view_attributes")
 366         {
 367                 return;
 368         }
 369         if (extName == "VK_NV_viewport_swizzle")
 370         {
 371                 return;
 372         }
 373         if (extName == "VK_EXT_discard_rectangles")
 374         {
 375                 return;
 376         }
 377         if (extName == "VK_EXT_conservative_rasterization")
 378         {
 379                 return;
 380         }
 381         if (extName == "VK_EXT_depth_clip_enable")
 382         {
 383                 return;
 384         }
 385         if (extName == "VK_EXT_swapchain_colorspace")
 386         {
 387                 return;
 388         }
 389         if (extName == "VK_EXT_hdr_metadata")
 390         {
 391                 return;
 392         }
 393         if (extName == "VK_KHR_imageless_framebuffer")
 394         {
 395                 return;
 396         }
 397         if (extName == "VK_KHR_create_renderpass2")
 398         {
 399                 return;
 400         }
 401         if (extName == "VK_KHR_shared_presentable_image")
 402         {
 403                 return;
 404         }
 405         if (extName == "VK_KHR_external_fence_capabilities")
 406         {
 407                 return;
 408         }
 409         if (extName == "VK_KHR_external_fence")
 410         {
 411                 return;
 412         }
 413         if (extName == "VK_KHR_external_fence_win32")
 414         {
 415                 return;
 416         }
 417         if (extName == "VK_KHR_external_fence_fd")
 418         {
 419                 return;
 420         }
 421         if (extName == "VK_KHR_performance_query")
 422         {
 423                 functions.push_back("vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR");
 424                 functions.push_back("vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR");
 425                 return;
 426         }
 427         if (extName == "VK_KHR_maintenance2")
 428         {
 429                 return;
 430         }
 431         if (extName == "VK_KHR_get_surface_capabilities2")
 432         {
 433                 functions.push_back("vkGetPhysicalDeviceSurfaceCapabilities2KHR");
 434                 functions.push_back("vkGetPhysicalDeviceSurfaceFormats2KHR");
 435                 return;
 436         }
 437         if (extName == "VK_KHR_variable_pointers")
 438         {
 439                 return;
 440         }
 441         if (extName == "VK_KHR_get_display_properties2")
 442         {
 443                 functions.push_back("vkGetPhysicalDeviceDisplayProperties2KHR");
 444                 functions.push_back("vkGetPhysicalDeviceDisplayPlaneProperties2KHR");
 445                 functions.push_back("vkGetDisplayModeProperties2KHR");
 446                 functions.push_back("vkGetDisplayPlaneCapabilities2KHR");
 447                 return;
 448         }
 449         if (extName == "VK_MVK_ios_surface")
 450         {
 451                 functions.push_back("vkCreateIOSSurfaceMVK");
 452                 return;
 453         }
 454         if (extName == "VK_MVK_macos_surface")
 455         {
 456                 functions.push_back("vkCreateMacOSSurfaceMVK");
 457                 return;
 458         }
 459         if (extName == "VK_EXT_external_memory_dma_buf")
 460         {
 461                 return;
 462         }
 463         if (extName == "VK_EXT_queue_family_foreign")
 464         {
 465                 return;
 466         }
 467         if (extName == "VK_KHR_dedicated_allocation")
 468         {
 469                 return;
 470         }
 471         if (extName == "VK_EXT_debug_utils")
 472         {
 473                 functions.push_back("vkCreateDebugUtilsMessengerEXT");
 474                 functions.push_back("vkDestroyDebugUtilsMessengerEXT");
 475                 functions.push_back("vkSubmitDebugUtilsMessageEXT");
 476                 return;
 477         }
 478         if (extName == "VK_ANDROID_external_memory_android_hardware_buffer")
 479         {
 480                 return;
 481         }
 482         if (extName == "VK_EXT_sampler_filter_minmax")
 483         {
 484                 return;
 485         }
 486         if (extName == "VK_KHR_storage_buffer_storage_class")
 487         {
 488                 return;
 489         }
 490         if (extName == "VK_AMD_gpu_shader_int16")
 491         {
 492                 return;
 493         }
 494         if (extName == "VK_AMD_mixed_attachment_samples")
 495         {
 496                 return;
 497         }
 498         if (extName == "VK_AMD_shader_fragment_mask")
 499         {
 500                 return;
 501         }
 502         if (extName == "VK_EXT_inline_uniform_block")
 503         {
 504                 return;
 505         }
 506         if (extName == "VK_EXT_shader_stencil_export")
 507         {
 508                 return;
 509         }
 510         if (extName == "VK_EXT_sample_locations")
 511         {
 512                 functions.push_back("vkGetPhysicalDeviceMultisamplePropertiesEXT");
 513                 return;
 514         }
 515         if (extName == "VK_KHR_relaxed_block_layout")
 516         {
 517                 return;
 518         }
 519         if (extName == "VK_KHR_get_memory_requirements2")
 520         {
 521                 return;
 522         }
 523         if (extName == "VK_KHR_image_format_list")
 524         {
 525                 return;
 526         }
 527         if (extName == "VK_EXT_blend_operation_advanced")
 528         {
 529                 return;
 530         }
 531         if (extName == "VK_NV_fragment_coverage_to_color")
 532         {
 533                 return;
 534         }
 535         if (extName == "VK_KHR_acceleration_structure")
 536         {
 537                 return;
 538         }
 539         if (extName == "VK_KHR_ray_tracing_pipeline")
 540         {
 541                 return;
 542         }
 543         if (extName == "VK_KHR_ray_query")
 544         {
 545                 return;
 546         }
 547         if (extName == "VK_NV_framebuffer_mixed_samples")
 548         {
 549                 return;
 550         }
 551         if (extName == "VK_NV_fill_rectangle")
 552         {
 553                 return;
 554         }
 555         if (extName == "VK_NV_shader_sm_builtins")
 556         {
 557                 return;
 558         }
 559         if (extName == "VK_EXT_post_depth_coverage")
 560         {
 561                 return;
 562         }
 563         if (extName == "VK_KHR_sampler_ycbcr_conversion")
 564         {
 565                 return;
 566         }
 567         if (extName == "VK_KHR_bind_memory2")
 568         {
 569                 return;
 570         }
 571         if (extName == "VK_EXT_image_drm_format_modifier")
 572         {
 573                 return;
 574         }
 575         if (extName == "VK_EXT_validation_cache")
 576         {
 577                 return;
 578         }
 579         if (extName == "VK_EXT_descriptor_indexing")
 580         {
 581                 return;
 582         }
 583         if (extName == "VK_EXT_shader_viewport_index_layer")
 584         {
 585                 return;
 586         }
 587         if (extName == "VK_KHR_portability_subset")
 588         {
 589                 return;
 590         }
 591         if (extName == "VK_NV_shading_rate_image")
 592         {
 593                 return;
 594         }
 595         if (extName == "VK_NV_ray_tracing")
 596         {
 597                 return;
 598         }
 599         if (extName == "VK_NV_representative_fragment_test")
 600         {
 601                 return;
 602         }
 603         if (extName == "VK_KHR_maintenance3")
 604         {
 605                 return;
 606         }
 607         if (extName == "VK_KHR_draw_indirect_count")
 608         {
 609                 return;
 610         }
 611         if (extName == "VK_EXT_filter_cubic")
 612         {
 613                 return;
 614         }
 615         if (extName == "VK_QCOM_render_pass_shader_resolve")
 616         {
 617                 return;
 618         }
 619         if (extName == "VK_EXT_global_priority")
 620         {
 621                 return;
 622         }
 623         if (extName == "VK_KHR_shader_subgroup_extended_types")
 624         {
 625                 return;
 626         }
 627         if (extName == "VK_KHR_8bit_storage")
 628         {
 629                 return;
 630         }
 631         if (extName == "VK_EXT_external_memory_host")
 632         {
 633                 return;
 634         }
 635         if (extName == "VK_AMD_buffer_marker")
 636         {
 637                 return;
 638         }
 639         if (extName == "VK_KHR_shader_atomic_int64")
 640         {
 641                 return;
 642         }
 643         if (extName == "VK_KHR_shader_clock")
 644         {
 645                 return;
 646         }
 647         if (extName == "VK_AMD_pipeline_compiler_control")
 648         {
 649                 return;
 650         }
 651         if (extName == "VK_EXT_calibrated_timestamps")
 652         {
 653                 functions.push_back("vkGetPhysicalDeviceCalibrateableTimeDomainsEXT");
 654                 return;
 655         }
 656         if (extName == "VK_AMD_shader_core_properties")
 657         {
 658                 return;
 659         }
 660         if (extName == "VK_EXT_video_decode_h265")
 661         {
 662                 return;
 663         }
 664         if (extName == "VK_KHR_global_priority")
 665         {
 666                 return;
 667         }
 668         if (extName == "VK_AMD_memory_overallocation_behavior")
 669         {
 670                 return;
 671         }
 672         if (extName == "VK_EXT_vertex_attribute_divisor")
 673         {
 674                 return;
 675         }
 676         if (extName == "VK_GGP_frame_token")
 677         {
 678                 return;
 679         }
 680         if (extName == "VK_EXT_pipeline_creation_feedback")
 681         {
 682                 return;
 683         }
 684         if (extName == "VK_KHR_driver_properties")
 685         {
 686                 return;
 687         }
 688         if (extName == "VK_KHR_shader_float_controls")
 689         {
 690                 return;
 691         }
 692         if (extName == "VK_NV_shader_subgroup_partitioned")
 693         {
 694                 return;
 695         }
 696         if (extName == "VK_KHR_depth_stencil_resolve")
 697         {
 698                 return;
 699         }
 700         if (extName == "VK_KHR_swapchain_mutable_format")
 701         {
 702                 return;
 703         }
 704         if (extName == "VK_NV_compute_shader_derivatives")
 705         {
 706                 return;
 707         }
 708         if (extName == "VK_NV_mesh_shader")
 709         {
 710                 return;
 711         }
 712         if (extName == "VK_NV_fragment_shader_barycentric")
 713         {
 714                 return;
 715         }
 716         if (extName == "VK_NV_shader_image_footprint")
 717         {
 718                 return;
 719         }
 720         if (extName == "VK_NV_scissor_exclusive")
 721         {
 722                 return;
 723         }
 724         if (extName == "VK_NV_device_diagnostic_checkpoints")
 725         {
 726                 return;
 727         }
 728         if (extName == "VK_KHR_timeline_semaphore")
 729         {
 730                 return;
 731         }
 732         if (extName == "VK_INTEL_shader_integer_functions2")
 733         {
 734                 return;
 735         }
 736         if (extName == "VK_INTEL_performance_query")
 737         {
 738                 return;
 739         }
 740         if (extName == "VK_KHR_vulkan_memory_model")
 741         {
 742                 return;
 743         }
 744         if (extName == "VK_EXT_pci_bus_info")
 745         {
 746                 return;
 747         }
 748         if (extName == "VK_AMD_display_native_hdr")
 749         {
 750                 return;
 751         }
 752         if (extName == "VK_FUCHSIA_imagepipe_surface")
 753         {
 754                 functions.push_back("vkCreateImagePipeSurfaceFUCHSIA");
 755                 return;
 756         }
 757         if (extName == "VK_KHR_shader_terminate_invocation")
 758         {
 759                 return;
 760         }
 761         if (extName == "VK_EXT_metal_surface")
 762         {
 763                 functions.push_back("vkCreateMetalSurfaceEXT");
 764                 return;
 765         }
 766         if (extName == "VK_EXT_fragment_density_map")
 767         {
 768                 return;
 769         }
 770         if (extName == "VK_EXT_scalar_block_layout")
 771         {
 772                 return;
 773         }
 774         if (extName == "VK_GOOGLE_hlsl_functionality1")
 775         {
 776                 return;
 777         }
 778         if (extName == "VK_GOOGLE_decorate_string")
 779         {
 780                 return;
 781         }
 782         if (extName == "VK_EXT_subgroup_size_control")
 783         {
 784                 return;
 785         }
 786         if (extName == "VK_KHR_fragment_shading_rate")
 787         {
 788                 functions.push_back("vkGetPhysicalDeviceFragmentShadingRatesKHR");
 789                 return;
 790         }
 791         if (extName == "VK_AMD_shader_core_properties2")
 792         {
 793                 return;
 794         }
 795         if (extName == "VK_AMD_device_coherent_memory")
 796         {
 797                 return;
 798         }
 799         if (extName == "VK_EXT_shader_image_atomic_int64")
 800         {
 801                 return;
 802         }
 803         if (extName == "VK_KHR_spirv_1_4")
 804         {
 805                 return;
 806         }
 807         if (extName == "VK_EXT_memory_budget")
 808         {
 809                 return;
 810         }
 811         if (extName == "VK_EXT_memory_priority")
 812         {
 813                 return;
 814         }
 815         if (extName == "VK_KHR_surface_protected_capabilities")
 816         {
 817                 return;
 818         }
 819         if (extName == "VK_NV_dedicated_allocation_image_aliasing")
 820         {
 821                 return;
 822         }
 823         if (extName == "VK_KHR_separate_depth_stencil_layouts")
 824         {
 825                 return;
 826         }
 827         if (extName == "VK_EXT_buffer_device_address")
 828         {
 829                 return;
 830         }
 831         if (extName == "VK_EXT_tooling_info")
 832         {
 833                 return;
 834         }
 835         if (extName == "VK_EXT_separate_stencil_usage")
 836         {
 837                 return;
 838         }
 839         if (extName == "VK_EXT_validation_features")
 840         {
 841                 return;
 842         }
 843         if (extName == "VK_KHR_present_wait")
 844         {
 845                 return;
 846         }
 847         if (extName == "VK_NV_cooperative_matrix")
 848         {
 849                 functions.push_back("vkGetPhysicalDeviceCooperativeMatrixPropertiesNV");
 850                 return;
 851         }
 852         if (extName == "VK_NV_coverage_reduction_mode")
 853         {
 854                 functions.push_back("vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV");
 855                 return;
 856         }
 857         if (extName == "VK_EXT_fragment_shader_interlock")
 858         {
 859                 return;
 860         }
 861         if (extName == "VK_EXT_ycbcr_image_arrays")
 862         {
 863                 return;
 864         }
 865         if (extName == "VK_KHR_uniform_buffer_standard_layout")
 866         {
 867                 return;
 868         }
 869         if (extName == "VK_EXT_provoking_vertex")
 870         {
 871                 return;
 872         }
 873         if (extName == "VK_EXT_full_screen_exclusive")
 874         {
 875                 functions.push_back("vkGetPhysicalDeviceSurfacePresentModes2EXT");
 876                 return;
 877         }
 878         if (extName == "VK_EXT_headless_surface")
 879         {
 880                 functions.push_back("vkCreateHeadlessSurfaceEXT");
 881                 return;
 882         }
 883         if (extName == "VK_KHR_buffer_device_address")
 884         {
 885                 return;
 886         }
 887         if (extName == "VK_EXT_line_rasterization")
 888         {
 889                 return;
 890         }
 891         if (extName == "VK_EXT_shader_atomic_float")
 892         {
 893                 return;
 894         }
 895         if (extName == "VK_EXT_host_query_reset")
 896         {
 897                 return;
 898         }
 899         if (extName == "VK_EXT_index_type_uint8")
 900         {
 901                 return;
 902         }
 903         if (extName == "VK_EXT_extended_dynamic_state")
 904         {
 905                 return;
 906         }
 907         if (extName == "VK_KHR_deferred_host_operations")
 908         {
 909                 return;
 910         }
 911         if (extName == "VK_KHR_pipeline_executable_properties")
 912         {
 913                 return;
 914         }
 915         if (extName == "VK_EXT_shader_atomic_float2")
 916         {
 917                 return;
 918         }
 919         if (extName == "VK_EXT_shader_demote_to_helper_invocation")
 920         {
 921                 return;
 922         }
 923         if (extName == "VK_NV_device_generated_commands")
 924         {
 925                 return;
 926         }
 927         if (extName == "VK_NV_inherited_viewport_scissor")
 928         {
 929                 return;
 930         }
 931         if (extName == "VK_KHR_shader_integer_dot_product")
 932         {
 933                 return;
 934         }
 935         if (extName == "VK_EXT_texel_buffer_alignment")
 936         {
 937                 return;
 938         }
 939         if (extName == "VK_QCOM_render_pass_transform")
 940         {
 941                 return;
 942         }
 943         if (extName == "VK_EXT_device_memory_report")
 944         {
 945                 return;
 946         }
 947         if (extName == "VK_EXT_acquire_drm_display")
 948         {
 949                 functions.push_back("vkAcquireDrmDisplayEXT");
 950                 functions.push_back("vkGetDrmDisplayEXT");
 951                 return;
 952         }
 953         if (extName == "VK_EXT_robustness2")
 954         {
 955                 return;
 956         }
 957         if (extName == "VK_EXT_custom_border_color")
 958         {
 959                 return;
 960         }
 961         if (extName == "VK_GOOGLE_user_type")
 962         {
 963                 return;
 964         }
 965         if (extName == "VK_KHR_pipeline_library")
 966         {
 967                 return;
 968         }
 969         if (extName == "VK_KHR_shader_non_semantic_info")
 970         {
 971                 return;
 972         }
 973         if (extName == "VK_KHR_present_id")
 974         {
 975                 return;
 976         }
 977         if (extName == "VK_EXT_private_data")
 978         {
 979                 return;
 980         }
 981         if (extName == "VK_EXT_pipeline_creation_cache_control")
 982         {
 983                 return;
 984         }
 985         if (extName == "VK_KHR_video_encode_queue")
 986         {
 987                 return;
 988         }
 989         if (extName == "VK_NV_device_diagnostics_config")
 990         {
 991                 return;
 992         }
 993         if (extName == "VK_QCOM_render_pass_store_ops")
 994         {
 995                 return;
 996         }
 997         if (extName == "VK_EXT_metal_objects")
 998         {
 999                 return;
1000         }
1001         if (extName == "VK_KHR_synchronization2")
1002         {
1003                 return;
1004         }
1005         if (extName == "VK_EXT_graphics_pipeline_library")
1006         {
1007                 return;
1008         }
1009         if (extName == "VK_AMD_shader_early_and_late_fragment_tests")
1010         {
1011                 return;
1012         }
1013         if (extName == "VK_KHR_fragment_shader_barycentric")
1014         {
1015                 return;
1016         }
1017         if (extName == "VK_KHR_shader_subgroup_uniform_control_flow")
1018         {
1019                 return;
1020         }
1021         if (extName == "VK_KHR_zero_initialize_workgroup_memory")
1022         {
1023                 return;
1024         }
1025         if (extName == "VK_NV_fragment_shading_rate_enums")
1026         {
1027                 return;
1028         }
1029         if (extName == "VK_NV_ray_tracing_motion_blur")
1030         {
1031                 return;
1032         }
1033         if (extName == "VK_EXT_mesh_shader")
1034         {
1035                 return;
1036         }
1037         if (extName == "VK_EXT_ycbcr_2plane_444_formats")
1038         {
1039                 return;
1040         }
1041         if (extName == "VK_EXT_fragment_density_map2")
1042         {
1043                 return;
1044         }
1045         if (extName == "VK_QCOM_rotated_copy_commands")
1046         {
1047                 return;
1048         }
1049         if (extName == "VK_EXT_image_robustness")
1050         {
1051                 return;
1052         }
1053         if (extName == "VK_KHR_workgroup_memory_explicit_layout")
1054         {
1055                 return;
1056         }
1057         if (extName == "VK_KHR_copy_commands2")
1058         {
1059                 return;
1060         }
1061         if (extName == "VK_EXT_image_compression_control")
1062         {
1063                 return;
1064         }
1065         if (extName == "VK_EXT_attachment_feedback_loop_layout")
1066         {
1067                 return;
1068         }
1069         if (extName == "VK_EXT_4444_formats")
1070         {
1071                 return;
1072         }
1073         if (extName == "VK_ARM_rasterization_order_attachment_access")
1074         {
1075                 return;
1076         }
1077         if (extName == "VK_EXT_rgba10x6_formats")
1078         {
1079                 return;
1080         }
1081         if (extName == "VK_NV_acquire_winrt_display")
1082         {
1083                 functions.push_back("vkAcquireWinrtDisplayNV");
1084                 functions.push_back("vkGetWinrtDisplayNV");
1085                 return;
1086         }
1087         if (extName == "VK_VALVE_mutable_descriptor_type")
1088         {
1089                 return;
1090         }
1091         if (extName == "VK_EXT_vertex_input_dynamic_state")
1092         {
1093                 return;
1094         }
1095         if (extName == "VK_EXT_physical_device_drm")
1096         {
1097                 return;
1098         }
1099         if (extName == "VK_EXT_depth_clip_control")
1100         {
1101                 return;
1102         }
1103         if (extName == "VK_EXT_primitive_topology_list_restart")
1104         {
1105                 return;
1106         }
1107         if (extName == "VK_KHR_format_feature_flags2")
1108         {
1109                 return;
1110         }
1111         if (extName == "VK_FUCHSIA_external_memory")
1112         {
1113                 return;
1114         }
1115         if (extName == "VK_FUCHSIA_external_semaphore")
1116         {
1117                 return;
1118         }
1119         if (extName == "VK_FUCHSIA_buffer_collection")
1120         {
1121                 return;
1122         }
1123         if (extName == "VK_HUAWEI_subpass_shading")
1124         {
1125                 return;
1126         }
1127         if (extName == "VK_HUAWEI_invocation_mask")
1128         {
1129                 return;
1130         }
1131         if (extName == "VK_NV_external_memory_rdma")
1132         {
1133                 return;
1134         }
1135         if (extName == "VK_EXT_pipeline_properties")
1136         {
1137                 return;
1138         }
1139         if (extName == "VK_EXT_multisampled_render_to_single_sampled")
1140         {
1141                 return;
1142         }
1143         if (extName == "VK_EXT_extended_dynamic_state2")
1144         {
1145                 return;
1146         }
1147         if (extName == "VK_QNX_screen_surface")
1148         {
1149                 functions.push_back("vkCreateScreenSurfaceQNX");
1150                 functions.push_back("vkGetPhysicalDeviceScreenPresentationSupportQNX");
1151                 return;
1152         }
1153         if (extName == "VK_EXT_color_write_enable")
1154         {
1155                 return;
1156         }
1157         if (extName == "VK_EXT_primitives_generated_query")
1158         {
1159                 return;
1160         }
1161         if (extName == "VK_KHR_ray_tracing_maintenance1")
1162         {
1163                 return;
1164         }
1165         if (extName == "VK_EXT_global_priority_query")
1166         {
1167                 return;
1168         }
1169         if (extName == "VK_EXT_image_view_min_lod")
1170         {
1171                 return;
1172         }
1173         if (extName == "VK_EXT_multi_draw")
1174         {
1175                 return;
1176         }
1177         if (extName == "VK_EXT_image_2d_view_of_3d")
1178         {
1179                 return;
1180         }
1181         if (extName == "VK_KHR_portability_enumeration")
1182         {
1183                 return;
1184         }
1185         if (extName == "VK_EXT_load_store_op_none")
1186         {
1187                 return;
1188         }
1189         if (extName == "VK_EXT_border_color_swizzle")
1190         {
1191                 return;
1192         }
1193         if (extName == "VK_EXT_pageable_device_local_memory")
1194         {
1195                 return;
1196         }
1197         if (extName == "VK_KHR_maintenance4")
1198         {
1199                 return;
1200         }
1201         if (extName == "VK_VALVE_descriptor_set_host_mapping")
1202         {
1203                 return;
1204         }
1205         if (extName == "VK_EXT_depth_clamp_zero_one")
1206         {
1207                 return;
1208         }
1209         if (extName == "VK_EXT_non_seamless_cube_map")
1210         {
1211                 return;
1212         }
1213         if (extName == "VK_QCOM_fragment_density_map_offset")
1214         {
1215                 return;
1216         }
1217         if (extName == "VK_NV_linear_color_attachment")
1218         {
1219                 return;
1220         }
1221         if (extName == "VK_GOOGLE_surfaceless_query")
1222         {
1223                 return;
1224         }
1225         if (extName == "VK_EXT_image_compression_control_swapchain")
1226         {
1227                 return;
1228         }
1229         if (extName == "VK_QCOM_image_processing")
1230         {
1231                 return;
1232         }
1233         if (extName == "VK_EXT_subpass_merge_feedback")
1234         {
1235                 return;
1236         }
1237         if (extName == "VK_EXT_shader_module_identifier")
1238         {
1239                 return;
1240         }
1241         if (extName == "VK_EXT_rasterization_order_attachment_access")
1242         {
1243                 return;
1244         }
1245         if (extName == "VK_EXT_legacy_dithering")
1246         {
1247                 return;
1248         }
1249         if (extName == "VK_QCOM_tile_properties")
1250         {
1251                 return;
1252         }
1253         if (extName == "VK_SEC_amigo_profiling")
1254         {
1255                 return;
1256         }
1257         if (extName == "vulkan_video_codecs_common")
1258         {
1259                 return;
1260         }
1261         if (extName == "vulkan_video_codec_h264std")
1262         {
1263                 return;
1264         }
1265         if (extName == "vulkan_video_codec_h264std_decode")
1266         {
1267                 return;
1268         }
1269         if (extName == "vulkan_video_codec_h264std_encode")
1270         {
1271                 return;
1272         }
1273         if (extName == "vulkan_video_codec_h265std")
1274         {
1275                 return;
1276         }
1277         if (extName == "vulkan_video_codec_h265std_decode")
1278         {
1279                 return;
1280         }
1281         if (extName == "vulkan_video_codec_h265std_encode")
1282         {
1283                 return;
1284         }
1285         DE_FATAL("Extension name not found");
1286 }
1287
1288 void getDeviceExtensionFunctions (uint32_t apiVersion, ::std::string extName, ::std::vector<const char*>& functions)
1289 {
1290         if (extName == "VK_KHR_surface")
1291         {
1292                 return;
1293         }
1294         if (extName == "VK_KHR_swapchain")
1295         {
1296                 functions.push_back("vkCreateSwapchainKHR");
1297                 functions.push_back("vkDestroySwapchainKHR");
1298                 functions.push_back("vkGetSwapchainImagesKHR");
1299                 functions.push_back("vkAcquireNextImageKHR");
1300                 functions.push_back("vkQueuePresentKHR");
1301                 if(apiVersion >= VK_API_VERSION_1_1) functions.push_back("vkGetDeviceGroupPresentCapabilitiesKHR");
1302                 if(apiVersion >= VK_API_VERSION_1_1) functions.push_back("vkGetDeviceGroupSurfacePresentModesKHR");
1303                 if(apiVersion >= VK_API_VERSION_1_1) functions.push_back("vkAcquireNextImage2KHR");
1304                 return;
1305         }
1306         if (extName == "VK_KHR_display")
1307         {
1308                 return;
1309         }
1310         if (extName == "VK_KHR_display_swapchain")
1311         {
1312                 functions.push_back("vkCreateSharedSwapchainsKHR");
1313                 return;
1314         }
1315         if (extName == "VK_KHR_xlib_surface")
1316         {
1317                 return;
1318         }
1319         if (extName == "VK_KHR_xcb_surface")
1320         {
1321                 return;
1322         }
1323         if (extName == "VK_KHR_wayland_surface")
1324         {
1325                 return;
1326         }
1327         if (extName == "VK_KHR_android_surface")
1328         {
1329                 return;
1330         }
1331         if (extName == "VK_KHR_win32_surface")
1332         {
1333                 return;
1334         }
1335         if (extName == "VK_EXT_debug_report")
1336         {
1337                 return;
1338         }
1339         if (extName == "VK_NV_glsl_shader")
1340         {
1341                 return;
1342         }
1343         if (extName == "VK_EXT_depth_range_unrestricted")
1344         {
1345                 return;
1346         }
1347         if (extName == "VK_KHR_sampler_mirror_clamp_to_edge")
1348         {
1349                 return;
1350         }
1351         if (extName == "VK_IMG_filter_cubic")
1352         {
1353                 return;
1354         }
1355         if (extName == "VK_AMD_rasterization_order")
1356         {
1357                 return;
1358         }
1359         if (extName == "VK_AMD_shader_trinary_minmax")
1360         {
1361                 return;
1362         }
1363         if (extName == "VK_AMD_shader_explicit_vertex_parameter")
1364         {
1365                 return;
1366         }
1367         if (extName == "VK_EXT_debug_marker")
1368         {
1369                 functions.push_back("vkDebugMarkerSetObjectTagEXT");
1370                 functions.push_back("vkDebugMarkerSetObjectNameEXT");
1371                 functions.push_back("vkCmdDebugMarkerBeginEXT");
1372                 functions.push_back("vkCmdDebugMarkerEndEXT");
1373                 functions.push_back("vkCmdDebugMarkerInsertEXT");
1374                 return;
1375         }
1376         if (extName == "VK_KHR_video_queue")
1377         {
1378                 functions.push_back("vkCreateVideoSessionKHR");
1379                 functions.push_back("vkDestroyVideoSessionKHR");
1380                 functions.push_back("vkGetVideoSessionMemoryRequirementsKHR");
1381                 functions.push_back("vkBindVideoSessionMemoryKHR");
1382                 functions.push_back("vkCreateVideoSessionParametersKHR");
1383                 functions.push_back("vkUpdateVideoSessionParametersKHR");
1384                 functions.push_back("vkDestroyVideoSessionParametersKHR");
1385                 functions.push_back("vkCmdBeginVideoCodingKHR");
1386                 functions.push_back("vkCmdEndVideoCodingKHR");
1387                 functions.push_back("vkCmdControlVideoCodingKHR");
1388                 return;
1389         }
1390         if (extName == "VK_KHR_video_decode_queue")
1391         {
1392                 functions.push_back("vkCmdDecodeVideoKHR");
1393                 return;
1394         }
1395         if (extName == "VK_AMD_gcn_shader")
1396         {
1397                 return;
1398         }
1399         if (extName == "VK_NV_dedicated_allocation")
1400         {
1401                 return;
1402         }
1403         if (extName == "VK_EXT_transform_feedback")
1404         {
1405                 functions.push_back("vkCmdBindTransformFeedbackBuffersEXT");
1406                 functions.push_back("vkCmdBeginTransformFeedbackEXT");
1407                 functions.push_back("vkCmdEndTransformFeedbackEXT");
1408                 functions.push_back("vkCmdBeginQueryIndexedEXT");
1409                 functions.push_back("vkCmdEndQueryIndexedEXT");
1410                 functions.push_back("vkCmdDrawIndirectByteCountEXT");
1411                 return;
1412         }
1413         if (extName == "VK_NVX_binary_import")
1414         {
1415                 functions.push_back("vkCreateCuModuleNVX");
1416                 functions.push_back("vkCreateCuFunctionNVX");
1417                 functions.push_back("vkDestroyCuModuleNVX");
1418                 functions.push_back("vkDestroyCuFunctionNVX");
1419                 functions.push_back("vkCmdCuLaunchKernelNVX");
1420                 return;
1421         }
1422         if (extName == "VK_NVX_image_view_handle")
1423         {
1424                 functions.push_back("vkGetImageViewHandleNVX");
1425                 functions.push_back("vkGetImageViewAddressNVX");
1426                 return;
1427         }
1428         if (extName == "VK_AMD_draw_indirect_count")
1429         {
1430                 return;
1431         }
1432         if (extName == "VK_AMD_negative_viewport_height")
1433         {
1434                 return;
1435         }
1436         if (extName == "VK_AMD_gpu_shader_half_float")
1437         {
1438                 return;
1439         }
1440         if (extName == "VK_AMD_shader_ballot")
1441         {
1442                 return;
1443         }
1444         if (extName == "VK_EXT_video_encode_h264")
1445         {
1446                 return;
1447         }
1448         if (extName == "VK_EXT_video_encode_h265")
1449         {
1450                 return;
1451         }
1452         if (extName == "VK_EXT_video_decode_h264")
1453         {
1454                 return;
1455         }
1456         if (extName == "VK_AMD_texture_gather_bias_lod")
1457         {
1458                 return;
1459         }
1460         if (extName == "VK_AMD_shader_info")
1461         {
1462                 functions.push_back("vkGetShaderInfoAMD");
1463                 return;
1464         }
1465         if (extName == "VK_KHR_dynamic_rendering")
1466         {
1467                 return;
1468         }
1469         if (extName == "VK_AMD_shader_image_load_store_lod")
1470         {
1471                 return;
1472         }
1473         if (extName == "VK_GGP_stream_descriptor_surface")
1474         {
1475                 return;
1476         }
1477         if (extName == "VK_NV_corner_sampled_image")
1478         {
1479                 return;
1480         }
1481         if (extName == "VK_KHR_multiview")
1482         {
1483                 return;
1484         }
1485         if (extName == "VK_IMG_format_pvrtc")
1486         {
1487                 return;
1488         }
1489         if (extName == "VK_NV_external_memory_capabilities")
1490         {
1491                 return;
1492         }
1493         if (extName == "VK_NV_external_memory")
1494         {
1495                 return;
1496         }
1497         if (extName == "VK_NV_external_memory_win32")
1498         {
1499                 functions.push_back("vkGetMemoryWin32HandleNV");
1500                 return;
1501         }
1502         if (extName == "VK_NV_win32_keyed_mutex")
1503         {
1504                 return;
1505         }
1506         if (extName == "VK_KHR_get_physical_device_properties2")
1507         {
1508                 return;
1509         }
1510         if (extName == "VK_KHR_device_group")
1511         {
1512                 if(apiVersion >= VK_API_VERSION_1_1) functions.push_back("vkGetDeviceGroupPresentCapabilitiesKHR");
1513                 if(apiVersion >= VK_API_VERSION_1_1) functions.push_back("vkGetDeviceGroupSurfacePresentModesKHR");
1514                 if(apiVersion >= VK_API_VERSION_1_1) functions.push_back("vkAcquireNextImage2KHR");
1515                 if(apiVersion < VK_API_VERSION_1_1) functions.push_back("vkGetDeviceGroupPresentCapabilitiesKHR");
1516                 if(apiVersion < VK_API_VERSION_1_1) functions.push_back("vkGetDeviceGroupSurfacePresentModesKHR");
1517                 if(apiVersion < VK_API_VERSION_1_1) functions.push_back("vkAcquireNextImage2KHR");
1518                 return;
1519         }
1520         if (extName == "VK_EXT_validation_flags")
1521         {
1522                 return;
1523         }
1524         if (extName == "VK_NN_vi_surface")
1525         {
1526                 return;
1527         }
1528         if (extName == "VK_KHR_shader_draw_parameters")
1529         {
1530                 return;
1531         }
1532         if (extName == "VK_EXT_shader_subgroup_ballot")
1533         {
1534                 return;
1535         }
1536         if (extName == "VK_EXT_shader_subgroup_vote")
1537         {
1538                 return;
1539         }
1540         if (extName == "VK_EXT_texture_compression_astc_hdr")
1541         {
1542                 return;
1543         }
1544         if (extName == "VK_EXT_astc_decode_mode")
1545         {
1546                 return;
1547         }
1548         if (extName == "VK_EXT_pipeline_robustness")
1549         {
1550                 return;
1551         }
1552         if (extName == "VK_KHR_maintenance1")
1553         {
1554                 return;
1555         }
1556         if (extName == "VK_KHR_device_group_creation")
1557         {
1558                 return;
1559         }
1560         if (extName == "VK_KHR_external_memory_capabilities")
1561         {
1562                 return;
1563         }
1564         if (extName == "VK_KHR_external_memory")
1565         {
1566                 return;
1567         }
1568         if (extName == "VK_KHR_external_memory_win32")
1569         {
1570                 functions.push_back("vkGetMemoryWin32HandleKHR");
1571                 functions.push_back("vkGetMemoryWin32HandlePropertiesKHR");
1572                 return;
1573         }
1574         if (extName == "VK_KHR_external_memory_fd")
1575         {
1576                 functions.push_back("vkGetMemoryFdKHR");
1577                 functions.push_back("vkGetMemoryFdPropertiesKHR");
1578                 return;
1579         }
1580         if (extName == "VK_KHR_win32_keyed_mutex")
1581         {
1582                 return;
1583         }
1584         if (extName == "VK_KHR_external_semaphore_capabilities")
1585         {
1586                 return;
1587         }
1588         if (extName == "VK_KHR_external_semaphore")
1589         {
1590                 return;
1591         }
1592         if (extName == "VK_KHR_external_semaphore_win32")
1593         {
1594                 functions.push_back("vkImportSemaphoreWin32HandleKHR");
1595                 functions.push_back("vkGetSemaphoreWin32HandleKHR");
1596                 return;
1597         }
1598         if (extName == "VK_KHR_external_semaphore_fd")
1599         {
1600                 functions.push_back("vkImportSemaphoreFdKHR");
1601                 functions.push_back("vkGetSemaphoreFdKHR");
1602                 return;
1603         }
1604         if (extName == "VK_KHR_push_descriptor")
1605         {
1606                 functions.push_back("vkCmdPushDescriptorSetKHR");
1607                 functions.push_back("vkCmdPushDescriptorSetWithTemplateKHR");
1608                 functions.push_back("vkCmdPushDescriptorSetWithTemplateKHR");
1609                 return;
1610         }
1611         if (extName == "VK_EXT_conditional_rendering")
1612         {
1613                 functions.push_back("vkCmdBeginConditionalRenderingEXT");
1614                 functions.push_back("vkCmdEndConditionalRenderingEXT");
1615                 return;
1616         }
1617         if (extName == "VK_KHR_shader_float16_int8")
1618         {
1619                 return;
1620         }
1621         if (extName == "VK_KHR_16bit_storage")
1622         {
1623                 return;
1624         }
1625         if (extName == "VK_KHR_incremental_present")
1626         {
1627                 return;
1628         }
1629         if (extName == "VK_KHR_descriptor_update_template")
1630         {
1631                 functions.push_back("vkCmdPushDescriptorSetWithTemplateKHR");
1632                 return;
1633         }
1634         if (extName == "VK_NV_clip_space_w_scaling")
1635         {
1636                 functions.push_back("vkCmdSetViewportWScalingNV");
1637                 return;
1638         }
1639         if (extName == "VK_EXT_direct_mode_display")
1640         {
1641                 return;
1642         }
1643         if (extName == "VK_EXT_acquire_xlib_display")
1644         {
1645                 return;
1646         }
1647         if (extName == "VK_EXT_display_surface_counter")
1648         {
1649                 return;
1650         }
1651         if (extName == "VK_EXT_display_control")
1652         {
1653                 functions.push_back("vkDisplayPowerControlEXT");
1654                 functions.push_back("vkRegisterDeviceEventEXT");
1655                 functions.push_back("vkRegisterDisplayEventEXT");
1656                 functions.push_back("vkGetSwapchainCounterEXT");
1657                 return;
1658         }
1659         if (extName == "VK_GOOGLE_display_timing")
1660         {
1661                 functions.push_back("vkGetRefreshCycleDurationGOOGLE");
1662                 functions.push_back("vkGetPastPresentationTimingGOOGLE");
1663                 return;
1664         }
1665         if (extName == "VK_NV_sample_mask_override_coverage")
1666         {
1667                 return;
1668         }
1669         if (extName == "VK_NV_geometry_shader_passthrough")
1670         {
1671                 return;
1672         }
1673         if (extName == "VK_NV_viewport_array2")
1674         {
1675                 return;
1676         }
1677         if (extName == "VK_NVX_multiview_per_view_attributes")
1678         {
1679                 return;
1680         }
1681         if (extName == "VK_NV_viewport_swizzle")
1682         {
1683                 return;
1684         }
1685         if (extName == "VK_EXT_discard_rectangles")
1686         {
1687                 functions.push_back("vkCmdSetDiscardRectangleEXT");
1688                 return;
1689         }
1690         if (extName == "VK_EXT_conservative_rasterization")
1691         {
1692                 return;
1693         }
1694         if (extName == "VK_EXT_depth_clip_enable")
1695         {
1696                 return;
1697         }
1698         if (extName == "VK_EXT_swapchain_colorspace")
1699         {
1700                 return;
1701         }
1702         if (extName == "VK_EXT_hdr_metadata")
1703         {
1704                 functions.push_back("vkSetHdrMetadataEXT");
1705                 return;
1706         }
1707         if (extName == "VK_KHR_imageless_framebuffer")
1708         {
1709                 return;
1710         }
1711         if (extName == "VK_KHR_create_renderpass2")
1712         {
1713                 return;
1714         }
1715         if (extName == "VK_KHR_shared_presentable_image")
1716         {
1717                 functions.push_back("vkGetSwapchainStatusKHR");
1718                 return;
1719         }
1720         if (extName == "VK_KHR_external_fence_capabilities")
1721         {
1722                 return;
1723         }
1724         if (extName == "VK_KHR_external_fence")
1725         {
1726                 return;
1727         }
1728         if (extName == "VK_KHR_external_fence_win32")
1729         {
1730                 functions.push_back("vkImportFenceWin32HandleKHR");
1731                 functions.push_back("vkGetFenceWin32HandleKHR");
1732                 return;
1733         }
1734         if (extName == "VK_KHR_external_fence_fd")
1735         {
1736                 functions.push_back("vkImportFenceFdKHR");
1737                 functions.push_back("vkGetFenceFdKHR");
1738                 return;
1739         }
1740         if (extName == "VK_KHR_performance_query")
1741         {
1742                 functions.push_back("vkAcquireProfilingLockKHR");
1743                 functions.push_back("vkReleaseProfilingLockKHR");
1744                 return;
1745         }
1746         if (extName == "VK_KHR_maintenance2")
1747         {
1748                 return;
1749         }
1750         if (extName == "VK_KHR_get_surface_capabilities2")
1751         {
1752                 return;
1753         }
1754         if (extName == "VK_KHR_variable_pointers")
1755         {
1756                 return;
1757         }
1758         if (extName == "VK_KHR_get_display_properties2")
1759         {
1760                 return;
1761         }
1762         if (extName == "VK_MVK_ios_surface")
1763         {
1764                 return;
1765         }
1766         if (extName == "VK_MVK_macos_surface")
1767         {
1768                 return;
1769         }
1770         if (extName == "VK_EXT_external_memory_dma_buf")
1771         {
1772                 return;
1773         }
1774         if (extName == "VK_EXT_queue_family_foreign")
1775         {
1776                 return;
1777         }
1778         if (extName == "VK_KHR_dedicated_allocation")
1779         {
1780                 return;
1781         }
1782         if (extName == "VK_EXT_debug_utils")
1783         {
1784                 functions.push_back("vkSetDebugUtilsObjectNameEXT");
1785                 functions.push_back("vkSetDebugUtilsObjectTagEXT");
1786                 functions.push_back("vkQueueBeginDebugUtilsLabelEXT");
1787                 functions.push_back("vkQueueEndDebugUtilsLabelEXT");
1788                 functions.push_back("vkQueueInsertDebugUtilsLabelEXT");
1789                 functions.push_back("vkCmdBeginDebugUtilsLabelEXT");
1790                 functions.push_back("vkCmdEndDebugUtilsLabelEXT");
1791                 functions.push_back("vkCmdInsertDebugUtilsLabelEXT");
1792                 return;
1793         }
1794         if (extName == "VK_ANDROID_external_memory_android_hardware_buffer")
1795         {
1796                 functions.push_back("vkGetAndroidHardwareBufferPropertiesANDROID");
1797                 functions.push_back("vkGetMemoryAndroidHardwareBufferANDROID");
1798                 return;
1799         }
1800         if (extName == "VK_EXT_sampler_filter_minmax")
1801         {
1802                 return;
1803         }
1804         if (extName == "VK_KHR_storage_buffer_storage_class")
1805         {
1806                 return;
1807         }
1808         if (extName == "VK_AMD_gpu_shader_int16")
1809         {
1810                 return;
1811         }
1812         if (extName == "VK_AMD_mixed_attachment_samples")
1813         {
1814                 return;
1815         }
1816         if (extName == "VK_AMD_shader_fragment_mask")
1817         {
1818                 return;
1819         }
1820         if (extName == "VK_EXT_inline_uniform_block")
1821         {
1822                 return;
1823         }
1824         if (extName == "VK_EXT_shader_stencil_export")
1825         {
1826                 return;
1827         }
1828         if (extName == "VK_EXT_sample_locations")
1829         {
1830                 functions.push_back("vkCmdSetSampleLocationsEXT");
1831                 return;
1832         }
1833         if (extName == "VK_KHR_relaxed_block_layout")
1834         {
1835                 return;
1836         }
1837         if (extName == "VK_KHR_get_memory_requirements2")
1838         {
1839                 return;
1840         }
1841         if (extName == "VK_KHR_image_format_list")
1842         {
1843                 return;
1844         }
1845         if (extName == "VK_EXT_blend_operation_advanced")
1846         {
1847                 return;
1848         }
1849         if (extName == "VK_NV_fragment_coverage_to_color")
1850         {
1851                 return;
1852         }
1853         if (extName == "VK_KHR_acceleration_structure")
1854         {
1855                 functions.push_back("vkCreateAccelerationStructureKHR");
1856                 functions.push_back("vkDestroyAccelerationStructureKHR");
1857                 functions.push_back("vkCmdBuildAccelerationStructuresKHR");
1858                 functions.push_back("vkCmdBuildAccelerationStructuresIndirectKHR");
1859                 functions.push_back("vkBuildAccelerationStructuresKHR");
1860                 functions.push_back("vkCopyAccelerationStructureKHR");
1861                 functions.push_back("vkCopyAccelerationStructureToMemoryKHR");
1862                 functions.push_back("vkCopyMemoryToAccelerationStructureKHR");
1863                 functions.push_back("vkWriteAccelerationStructuresPropertiesKHR");
1864                 functions.push_back("vkCmdCopyAccelerationStructureKHR");
1865                 functions.push_back("vkCmdCopyAccelerationStructureToMemoryKHR");
1866                 functions.push_back("vkCmdCopyMemoryToAccelerationStructureKHR");
1867                 functions.push_back("vkGetAccelerationStructureDeviceAddressKHR");
1868                 functions.push_back("vkCmdWriteAccelerationStructuresPropertiesKHR");
1869                 functions.push_back("vkGetDeviceAccelerationStructureCompatibilityKHR");
1870                 functions.push_back("vkGetAccelerationStructureBuildSizesKHR");
1871                 return;
1872         }
1873         if (extName == "VK_KHR_ray_tracing_pipeline")
1874         {
1875                 functions.push_back("vkCmdTraceRaysKHR");
1876                 functions.push_back("vkCreateRayTracingPipelinesKHR");
1877                 functions.push_back("vkGetRayTracingShaderGroupHandlesKHR");
1878                 functions.push_back("vkGetRayTracingCaptureReplayShaderGroupHandlesKHR");
1879                 functions.push_back("vkCmdTraceRaysIndirectKHR");
1880                 functions.push_back("vkGetRayTracingShaderGroupStackSizeKHR");
1881                 functions.push_back("vkCmdSetRayTracingPipelineStackSizeKHR");
1882                 return;
1883         }
1884         if (extName == "VK_KHR_ray_query")
1885         {
1886                 return;
1887         }
1888         if (extName == "VK_NV_framebuffer_mixed_samples")
1889         {
1890                 return;
1891         }
1892         if (extName == "VK_NV_fill_rectangle")
1893         {
1894                 return;
1895         }
1896         if (extName == "VK_NV_shader_sm_builtins")
1897         {
1898                 return;
1899         }
1900         if (extName == "VK_EXT_post_depth_coverage")
1901         {
1902                 return;
1903         }
1904         if (extName == "VK_KHR_sampler_ycbcr_conversion")
1905         {
1906                 return;
1907         }
1908         if (extName == "VK_KHR_bind_memory2")
1909         {
1910                 return;
1911         }
1912         if (extName == "VK_EXT_image_drm_format_modifier")
1913         {
1914                 functions.push_back("vkGetImageDrmFormatModifierPropertiesEXT");
1915                 return;
1916         }
1917         if (extName == "VK_EXT_validation_cache")
1918         {
1919                 functions.push_back("vkCreateValidationCacheEXT");
1920                 functions.push_back("vkDestroyValidationCacheEXT");
1921                 functions.push_back("vkMergeValidationCachesEXT");
1922                 functions.push_back("vkGetValidationCacheDataEXT");
1923                 return;
1924         }
1925         if (extName == "VK_EXT_descriptor_indexing")
1926         {
1927                 return;
1928         }
1929         if (extName == "VK_EXT_shader_viewport_index_layer")
1930         {
1931                 return;
1932         }
1933         if (extName == "VK_KHR_portability_subset")
1934         {
1935                 return;
1936         }
1937         if (extName == "VK_NV_shading_rate_image")
1938         {
1939                 functions.push_back("vkCmdBindShadingRateImageNV");
1940                 functions.push_back("vkCmdSetViewportShadingRatePaletteNV");
1941                 functions.push_back("vkCmdSetCoarseSampleOrderNV");
1942                 return;
1943         }
1944         if (extName == "VK_NV_ray_tracing")
1945         {
1946                 functions.push_back("vkCreateAccelerationStructureNV");
1947                 functions.push_back("vkDestroyAccelerationStructureNV");
1948                 functions.push_back("vkGetAccelerationStructureMemoryRequirementsNV");
1949                 functions.push_back("vkBindAccelerationStructureMemoryNV");
1950                 functions.push_back("vkCmdBuildAccelerationStructureNV");
1951                 functions.push_back("vkCmdCopyAccelerationStructureNV");
1952                 functions.push_back("vkCmdTraceRaysNV");
1953                 functions.push_back("vkCreateRayTracingPipelinesNV");
1954                 functions.push_back("vkGetAccelerationStructureHandleNV");
1955                 functions.push_back("vkCmdWriteAccelerationStructuresPropertiesNV");
1956                 functions.push_back("vkCompileDeferredNV");
1957                 return;
1958         }
1959         if (extName == "VK_NV_representative_fragment_test")
1960         {
1961                 return;
1962         }
1963         if (extName == "VK_KHR_maintenance3")
1964         {
1965                 return;
1966         }
1967         if (extName == "VK_KHR_draw_indirect_count")
1968         {
1969                 return;
1970         }
1971         if (extName == "VK_EXT_filter_cubic")
1972         {
1973                 return;
1974         }
1975         if (extName == "VK_QCOM_render_pass_shader_resolve")
1976         {
1977                 return;
1978         }
1979         if (extName == "VK_EXT_global_priority")
1980         {
1981                 return;
1982         }
1983         if (extName == "VK_KHR_shader_subgroup_extended_types")
1984         {
1985                 return;
1986         }
1987         if (extName == "VK_KHR_8bit_storage")
1988         {
1989                 return;
1990         }
1991         if (extName == "VK_EXT_external_memory_host")
1992         {
1993                 functions.push_back("vkGetMemoryHostPointerPropertiesEXT");
1994                 return;
1995         }
1996         if (extName == "VK_AMD_buffer_marker")
1997         {
1998                 functions.push_back("vkCmdWriteBufferMarkerAMD");
1999                 return;
2000         }
2001         if (extName == "VK_KHR_shader_atomic_int64")
2002         {
2003                 return;
2004         }
2005         if (extName == "VK_KHR_shader_clock")
2006         {
2007                 return;
2008         }
2009         if (extName == "VK_AMD_pipeline_compiler_control")
2010         {
2011                 return;
2012         }
2013         if (extName == "VK_EXT_calibrated_timestamps")
2014         {
2015                 functions.push_back("vkGetCalibratedTimestampsEXT");
2016                 return;
2017         }
2018         if (extName == "VK_AMD_shader_core_properties")
2019         {
2020                 return;
2021         }
2022         if (extName == "VK_EXT_video_decode_h265")
2023         {
2024                 return;
2025         }
2026         if (extName == "VK_KHR_global_priority")
2027         {
2028                 return;
2029         }
2030         if (extName == "VK_AMD_memory_overallocation_behavior")
2031         {
2032                 return;
2033         }
2034         if (extName == "VK_EXT_vertex_attribute_divisor")
2035         {
2036                 return;
2037         }
2038         if (extName == "VK_GGP_frame_token")
2039         {
2040                 return;
2041         }
2042         if (extName == "VK_EXT_pipeline_creation_feedback")
2043         {
2044                 return;
2045         }
2046         if (extName == "VK_KHR_driver_properties")
2047         {
2048                 return;
2049         }
2050         if (extName == "VK_KHR_shader_float_controls")
2051         {
2052                 return;
2053         }
2054         if (extName == "VK_NV_shader_subgroup_partitioned")
2055         {
2056                 return;
2057         }
2058         if (extName == "VK_KHR_depth_stencil_resolve")
2059         {
2060                 return;
2061         }
2062         if (extName == "VK_KHR_swapchain_mutable_format")
2063         {
2064                 return;
2065         }
2066         if (extName == "VK_NV_compute_shader_derivatives")
2067         {
2068                 return;
2069         }
2070         if (extName == "VK_NV_mesh_shader")
2071         {
2072                 functions.push_back("vkCmdDrawMeshTasksNV");
2073                 functions.push_back("vkCmdDrawMeshTasksIndirectNV");
2074                 functions.push_back("vkCmdDrawMeshTasksIndirectCountNV");
2075                 return;
2076         }
2077         if (extName == "VK_NV_fragment_shader_barycentric")
2078         {
2079                 return;
2080         }
2081         if (extName == "VK_NV_shader_image_footprint")
2082         {
2083                 return;
2084         }
2085         if (extName == "VK_NV_scissor_exclusive")
2086         {
2087                 functions.push_back("vkCmdSetExclusiveScissorNV");
2088                 return;
2089         }
2090         if (extName == "VK_NV_device_diagnostic_checkpoints")
2091         {
2092                 functions.push_back("vkCmdSetCheckpointNV");
2093                 functions.push_back("vkGetQueueCheckpointDataNV");
2094                 return;
2095         }
2096         if (extName == "VK_KHR_timeline_semaphore")
2097         {
2098                 return;
2099         }
2100         if (extName == "VK_INTEL_shader_integer_functions2")
2101         {
2102                 return;
2103         }
2104         if (extName == "VK_INTEL_performance_query")
2105         {
2106                 functions.push_back("vkInitializePerformanceApiINTEL");
2107                 functions.push_back("vkUninitializePerformanceApiINTEL");
2108                 functions.push_back("vkCmdSetPerformanceMarkerINTEL");
2109                 functions.push_back("vkCmdSetPerformanceStreamMarkerINTEL");
2110                 functions.push_back("vkCmdSetPerformanceOverrideINTEL");
2111                 functions.push_back("vkAcquirePerformanceConfigurationINTEL");
2112                 functions.push_back("vkReleasePerformanceConfigurationINTEL");
2113                 functions.push_back("vkQueueSetPerformanceConfigurationINTEL");
2114                 functions.push_back("vkGetPerformanceParameterINTEL");
2115                 return;
2116         }
2117         if (extName == "VK_KHR_vulkan_memory_model")
2118         {
2119                 return;
2120         }
2121         if (extName == "VK_EXT_pci_bus_info")
2122         {
2123                 return;
2124         }
2125         if (extName == "VK_AMD_display_native_hdr")
2126         {
2127                 functions.push_back("vkSetLocalDimmingAMD");
2128                 return;
2129         }
2130         if (extName == "VK_FUCHSIA_imagepipe_surface")
2131         {
2132                 return;
2133         }
2134         if (extName == "VK_KHR_shader_terminate_invocation")
2135         {
2136                 return;
2137         }
2138         if (extName == "VK_EXT_metal_surface")
2139         {
2140                 return;
2141         }
2142         if (extName == "VK_EXT_fragment_density_map")
2143         {
2144                 return;
2145         }
2146         if (extName == "VK_EXT_scalar_block_layout")
2147         {
2148                 return;
2149         }
2150         if (extName == "VK_GOOGLE_hlsl_functionality1")
2151         {
2152                 return;
2153         }
2154         if (extName == "VK_GOOGLE_decorate_string")
2155         {
2156                 return;
2157         }
2158         if (extName == "VK_EXT_subgroup_size_control")
2159         {
2160                 return;
2161         }
2162         if (extName == "VK_KHR_fragment_shading_rate")
2163         {
2164                 functions.push_back("vkCmdSetFragmentShadingRateKHR");
2165                 return;
2166         }
2167         if (extName == "VK_AMD_shader_core_properties2")
2168         {
2169                 return;
2170         }
2171         if (extName == "VK_AMD_device_coherent_memory")
2172         {
2173                 return;
2174         }
2175         if (extName == "VK_EXT_shader_image_atomic_int64")
2176         {
2177                 return;
2178         }
2179         if (extName == "VK_KHR_spirv_1_4")
2180         {
2181                 return;
2182         }
2183         if (extName == "VK_EXT_memory_budget")
2184         {
2185                 return;
2186         }
2187         if (extName == "VK_EXT_memory_priority")
2188         {
2189                 return;
2190         }
2191         if (extName == "VK_KHR_surface_protected_capabilities")
2192         {
2193                 return;
2194         }
2195         if (extName == "VK_NV_dedicated_allocation_image_aliasing")
2196         {
2197                 return;
2198         }
2199         if (extName == "VK_KHR_separate_depth_stencil_layouts")
2200         {
2201                 return;
2202         }
2203         if (extName == "VK_EXT_buffer_device_address")
2204         {
2205                 return;
2206         }
2207         if (extName == "VK_EXT_tooling_info")
2208         {
2209                 return;
2210         }
2211         if (extName == "VK_EXT_separate_stencil_usage")
2212         {
2213                 return;
2214         }
2215         if (extName == "VK_EXT_validation_features")
2216         {
2217                 return;
2218         }
2219         if (extName == "VK_KHR_present_wait")
2220         {
2221                 functions.push_back("vkWaitForPresentKHR");
2222                 return;
2223         }
2224         if (extName == "VK_NV_cooperative_matrix")
2225         {
2226                 return;
2227         }
2228         if (extName == "VK_NV_coverage_reduction_mode")
2229         {
2230                 return;
2231         }
2232         if (extName == "VK_EXT_fragment_shader_interlock")
2233         {
2234                 return;
2235         }
2236         if (extName == "VK_EXT_ycbcr_image_arrays")
2237         {
2238                 return;
2239         }
2240         if (extName == "VK_KHR_uniform_buffer_standard_layout")
2241         {
2242                 return;
2243         }
2244         if (extName == "VK_EXT_provoking_vertex")
2245         {
2246                 return;
2247         }
2248         if (extName == "VK_EXT_full_screen_exclusive")
2249         {
2250                 functions.push_back("vkAcquireFullScreenExclusiveModeEXT");
2251                 functions.push_back("vkReleaseFullScreenExclusiveModeEXT");
2252                 functions.push_back("vkGetDeviceGroupSurfacePresentModes2EXT");
2253                 functions.push_back("vkGetDeviceGroupSurfacePresentModes2EXT");
2254                 return;
2255         }
2256         if (extName == "VK_EXT_headless_surface")
2257         {
2258                 return;
2259         }
2260         if (extName == "VK_KHR_buffer_device_address")
2261         {
2262                 return;
2263         }
2264         if (extName == "VK_EXT_line_rasterization")
2265         {
2266                 functions.push_back("vkCmdSetLineStippleEXT");
2267                 return;
2268         }
2269         if (extName == "VK_EXT_shader_atomic_float")
2270         {
2271                 return;
2272         }
2273         if (extName == "VK_EXT_host_query_reset")
2274         {
2275                 return;
2276         }
2277         if (extName == "VK_EXT_index_type_uint8")
2278         {
2279                 return;
2280         }
2281         if (extName == "VK_EXT_extended_dynamic_state")
2282         {
2283                 return;
2284         }
2285         if (extName == "VK_KHR_deferred_host_operations")
2286         {
2287                 functions.push_back("vkCreateDeferredOperationKHR");
2288                 functions.push_back("vkDestroyDeferredOperationKHR");
2289                 functions.push_back("vkGetDeferredOperationMaxConcurrencyKHR");
2290                 functions.push_back("vkGetDeferredOperationResultKHR");
2291                 functions.push_back("vkDeferredOperationJoinKHR");
2292                 return;
2293         }
2294         if (extName == "VK_KHR_pipeline_executable_properties")
2295         {
2296                 functions.push_back("vkGetPipelineExecutablePropertiesKHR");
2297                 functions.push_back("vkGetPipelineExecutableStatisticsKHR");
2298                 functions.push_back("vkGetPipelineExecutableInternalRepresentationsKHR");
2299                 return;
2300         }
2301         if (extName == "VK_EXT_shader_atomic_float2")
2302         {
2303                 return;
2304         }
2305         if (extName == "VK_EXT_shader_demote_to_helper_invocation")
2306         {
2307                 return;
2308         }
2309         if (extName == "VK_NV_device_generated_commands")
2310         {
2311                 functions.push_back("vkGetGeneratedCommandsMemoryRequirementsNV");
2312                 functions.push_back("vkCmdPreprocessGeneratedCommandsNV");
2313                 functions.push_back("vkCmdExecuteGeneratedCommandsNV");
2314                 functions.push_back("vkCmdBindPipelineShaderGroupNV");
2315                 functions.push_back("vkCreateIndirectCommandsLayoutNV");
2316                 functions.push_back("vkDestroyIndirectCommandsLayoutNV");
2317                 return;
2318         }
2319         if (extName == "VK_NV_inherited_viewport_scissor")
2320         {
2321                 return;
2322         }
2323         if (extName == "VK_KHR_shader_integer_dot_product")
2324         {
2325                 return;
2326         }
2327         if (extName == "VK_EXT_texel_buffer_alignment")
2328         {
2329                 return;
2330         }
2331         if (extName == "VK_QCOM_render_pass_transform")
2332         {
2333                 return;
2334         }
2335         if (extName == "VK_EXT_device_memory_report")
2336         {
2337                 return;
2338         }
2339         if (extName == "VK_EXT_acquire_drm_display")
2340         {
2341                 return;
2342         }
2343         if (extName == "VK_EXT_robustness2")
2344         {
2345                 return;
2346         }
2347         if (extName == "VK_EXT_custom_border_color")
2348         {
2349                 return;
2350         }
2351         if (extName == "VK_GOOGLE_user_type")
2352         {
2353                 return;
2354         }
2355         if (extName == "VK_KHR_pipeline_library")
2356         {
2357                 return;
2358         }
2359         if (extName == "VK_KHR_shader_non_semantic_info")
2360         {
2361                 return;
2362         }
2363         if (extName == "VK_KHR_present_id")
2364         {
2365                 return;
2366         }
2367         if (extName == "VK_EXT_private_data")
2368         {
2369                 return;
2370         }
2371         if (extName == "VK_EXT_pipeline_creation_cache_control")
2372         {
2373                 return;
2374         }
2375         if (extName == "VK_KHR_video_encode_queue")
2376         {
2377                 functions.push_back("vkCmdEncodeVideoKHR");
2378                 return;
2379         }
2380         if (extName == "VK_NV_device_diagnostics_config")
2381         {
2382                 return;
2383         }
2384         if (extName == "VK_QCOM_render_pass_store_ops")
2385         {
2386                 return;
2387         }
2388         if (extName == "VK_EXT_metal_objects")
2389         {
2390                 functions.push_back("vkExportMetalObjectsEXT");
2391                 return;
2392         }
2393         if (extName == "VK_KHR_synchronization2")
2394         {
2395                 return;
2396         }
2397         if (extName == "VK_EXT_graphics_pipeline_library")
2398         {
2399                 return;
2400         }
2401         if (extName == "VK_AMD_shader_early_and_late_fragment_tests")
2402         {
2403                 return;
2404         }
2405         if (extName == "VK_KHR_fragment_shader_barycentric")
2406         {
2407                 return;
2408         }
2409         if (extName == "VK_KHR_shader_subgroup_uniform_control_flow")
2410         {
2411                 return;
2412         }
2413         if (extName == "VK_KHR_zero_initialize_workgroup_memory")
2414         {
2415                 return;
2416         }
2417         if (extName == "VK_NV_fragment_shading_rate_enums")
2418         {
2419                 functions.push_back("vkCmdSetFragmentShadingRateEnumNV");
2420                 return;
2421         }
2422         if (extName == "VK_NV_ray_tracing_motion_blur")
2423         {
2424                 return;
2425         }
2426         if (extName == "VK_EXT_mesh_shader")
2427         {
2428                 functions.push_back("vkCmdDrawMeshTasksEXT");
2429                 functions.push_back("vkCmdDrawMeshTasksIndirectEXT");
2430                 functions.push_back("vkCmdDrawMeshTasksIndirectCountEXT");
2431                 return;
2432         }
2433         if (extName == "VK_EXT_ycbcr_2plane_444_formats")
2434         {
2435                 return;
2436         }
2437         if (extName == "VK_EXT_fragment_density_map2")
2438         {
2439                 return;
2440         }
2441         if (extName == "VK_QCOM_rotated_copy_commands")
2442         {
2443                 return;
2444         }
2445         if (extName == "VK_EXT_image_robustness")
2446         {
2447                 return;
2448         }
2449         if (extName == "VK_KHR_workgroup_memory_explicit_layout")
2450         {
2451                 return;
2452         }
2453         if (extName == "VK_KHR_copy_commands2")
2454         {
2455                 return;
2456         }
2457         if (extName == "VK_EXT_image_compression_control")
2458         {
2459                 functions.push_back("vkGetImageSubresourceLayout2EXT");
2460                 return;
2461         }
2462         if (extName == "VK_EXT_attachment_feedback_loop_layout")
2463         {
2464                 return;
2465         }
2466         if (extName == "VK_EXT_4444_formats")
2467         {
2468                 return;
2469         }
2470         if (extName == "VK_ARM_rasterization_order_attachment_access")
2471         {
2472                 return;
2473         }
2474         if (extName == "VK_EXT_rgba10x6_formats")
2475         {
2476                 return;
2477         }
2478         if (extName == "VK_NV_acquire_winrt_display")
2479         {
2480                 return;
2481         }
2482         if (extName == "VK_VALVE_mutable_descriptor_type")
2483         {
2484                 return;
2485         }
2486         if (extName == "VK_EXT_vertex_input_dynamic_state")
2487         {
2488                 functions.push_back("vkCmdSetVertexInputEXT");
2489                 return;
2490         }
2491         if (extName == "VK_EXT_physical_device_drm")
2492         {
2493                 return;
2494         }
2495         if (extName == "VK_EXT_depth_clip_control")
2496         {
2497                 return;
2498         }
2499         if (extName == "VK_EXT_primitive_topology_list_restart")
2500         {
2501                 return;
2502         }
2503         if (extName == "VK_KHR_format_feature_flags2")
2504         {
2505                 return;
2506         }
2507         if (extName == "VK_FUCHSIA_external_memory")
2508         {
2509                 functions.push_back("vkGetMemoryZirconHandleFUCHSIA");
2510                 functions.push_back("vkGetMemoryZirconHandlePropertiesFUCHSIA");
2511                 return;
2512         }
2513         if (extName == "VK_FUCHSIA_external_semaphore")
2514         {
2515                 functions.push_back("vkImportSemaphoreZirconHandleFUCHSIA");
2516                 functions.push_back("vkGetSemaphoreZirconHandleFUCHSIA");
2517                 return;
2518         }
2519         if (extName == "VK_FUCHSIA_buffer_collection")
2520         {
2521                 functions.push_back("vkCreateBufferCollectionFUCHSIA");
2522                 functions.push_back("vkSetBufferCollectionImageConstraintsFUCHSIA");
2523                 functions.push_back("vkSetBufferCollectionBufferConstraintsFUCHSIA");
2524                 functions.push_back("vkDestroyBufferCollectionFUCHSIA");
2525                 functions.push_back("vkGetBufferCollectionPropertiesFUCHSIA");
2526                 return;
2527         }
2528         if (extName == "VK_HUAWEI_subpass_shading")
2529         {
2530                 functions.push_back("vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI");
2531                 functions.push_back("vkCmdSubpassShadingHUAWEI");
2532                 return;
2533         }
2534         if (extName == "VK_HUAWEI_invocation_mask")
2535         {
2536                 functions.push_back("vkCmdBindInvocationMaskHUAWEI");
2537                 return;
2538         }
2539         if (extName == "VK_NV_external_memory_rdma")
2540         {
2541                 functions.push_back("vkGetMemoryRemoteAddressNV");
2542                 return;
2543         }
2544         if (extName == "VK_EXT_pipeline_properties")
2545         {
2546                 functions.push_back("vkGetPipelinePropertiesEXT");
2547                 return;
2548         }
2549         if (extName == "VK_EXT_multisampled_render_to_single_sampled")
2550         {
2551                 return;
2552         }
2553         if (extName == "VK_EXT_extended_dynamic_state2")
2554         {
2555                 functions.push_back("vkCmdSetPatchControlPointsEXT");
2556                 functions.push_back("vkCmdSetLogicOpEXT");
2557                 return;
2558         }
2559         if (extName == "VK_QNX_screen_surface")
2560         {
2561                 return;
2562         }
2563         if (extName == "VK_EXT_color_write_enable")
2564         {
2565                 functions.push_back("vkCmdSetColorWriteEnableEXT");
2566                 return;
2567         }
2568         if (extName == "VK_EXT_primitives_generated_query")
2569         {
2570                 return;
2571         }
2572         if (extName == "VK_KHR_ray_tracing_maintenance1")
2573         {
2574                 functions.push_back("vkCmdTraceRaysIndirect2KHR");
2575                 return;
2576         }
2577         if (extName == "VK_EXT_global_priority_query")
2578         {
2579                 return;
2580         }
2581         if (extName == "VK_EXT_image_view_min_lod")
2582         {
2583                 return;
2584         }
2585         if (extName == "VK_EXT_multi_draw")
2586         {
2587                 functions.push_back("vkCmdDrawMultiEXT");
2588                 functions.push_back("vkCmdDrawMultiIndexedEXT");
2589                 return;
2590         }
2591         if (extName == "VK_EXT_image_2d_view_of_3d")
2592         {
2593                 return;
2594         }
2595         if (extName == "VK_KHR_portability_enumeration")
2596         {
2597                 return;
2598         }
2599         if (extName == "VK_EXT_load_store_op_none")
2600         {
2601                 return;
2602         }
2603         if (extName == "VK_EXT_border_color_swizzle")
2604         {
2605                 return;
2606         }
2607         if (extName == "VK_EXT_pageable_device_local_memory")
2608         {
2609                 functions.push_back("vkSetDeviceMemoryPriorityEXT");
2610                 return;
2611         }
2612         if (extName == "VK_KHR_maintenance4")
2613         {
2614                 return;
2615         }
2616         if (extName == "VK_VALVE_descriptor_set_host_mapping")
2617         {
2618                 functions.push_back("vkGetDescriptorSetLayoutHostMappingInfoVALVE");
2619                 functions.push_back("vkGetDescriptorSetHostMappingVALVE");
2620                 return;
2621         }
2622         if (extName == "VK_EXT_depth_clamp_zero_one")
2623         {
2624                 return;
2625         }
2626         if (extName == "VK_EXT_non_seamless_cube_map")
2627         {
2628                 return;
2629         }
2630         if (extName == "VK_QCOM_fragment_density_map_offset")
2631         {
2632                 return;
2633         }
2634         if (extName == "VK_NV_linear_color_attachment")
2635         {
2636                 return;
2637         }
2638         if (extName == "VK_GOOGLE_surfaceless_query")
2639         {
2640                 return;
2641         }
2642         if (extName == "VK_EXT_image_compression_control_swapchain")
2643         {
2644                 return;
2645         }
2646         if (extName == "VK_QCOM_image_processing")
2647         {
2648                 return;
2649         }
2650         if (extName == "VK_EXT_subpass_merge_feedback")
2651         {
2652                 return;
2653         }
2654         if (extName == "VK_EXT_shader_module_identifier")
2655         {
2656                 functions.push_back("vkGetShaderModuleIdentifierEXT");
2657                 functions.push_back("vkGetShaderModuleCreateInfoIdentifierEXT");
2658                 return;
2659         }
2660         if (extName == "VK_EXT_rasterization_order_attachment_access")
2661         {
2662                 return;
2663         }
2664         if (extName == "VK_EXT_legacy_dithering")
2665         {
2666                 return;
2667         }
2668         if (extName == "VK_QCOM_tile_properties")
2669         {
2670                 functions.push_back("vkGetFramebufferTilePropertiesQCOM");
2671                 functions.push_back("vkGetDynamicRenderingTilePropertiesQCOM");
2672                 return;
2673         }
2674         if (extName == "VK_SEC_amigo_profiling")
2675         {
2676                 return;
2677         }
2678         if (extName == "vulkan_video_codecs_common")
2679         {
2680                 return;
2681         }
2682         if (extName == "vulkan_video_codec_h264std")
2683         {
2684                 return;
2685         }
2686         if (extName == "vulkan_video_codec_h264std_decode")
2687         {
2688                 return;
2689         }
2690         if (extName == "vulkan_video_codec_h264std_encode")
2691         {
2692                 return;
2693         }
2694         if (extName == "vulkan_video_codec_h265std")
2695         {
2696                 return;
2697         }
2698         if (extName == "vulkan_video_codec_h265std_decode")
2699         {
2700                 return;
2701         }
2702         if (extName == "vulkan_video_codec_h265std_encode")
2703         {
2704                 return;
2705         }
2706         DE_FATAL("Extension name not found");
2707 }
2708
2709 ::std::string instanceExtensionNames[] =
2710 {
2711         "VK_KHR_surface",
2712         "VK_KHR_display",
2713         "VK_KHR_xlib_surface",
2714         "VK_KHR_xcb_surface",
2715         "VK_KHR_wayland_surface",
2716         "VK_KHR_android_surface",
2717         "VK_KHR_win32_surface",
2718         "VK_EXT_debug_report",
2719         "VK_GGP_stream_descriptor_surface",
2720         "VK_NV_external_memory_capabilities",
2721         "VK_KHR_get_physical_device_properties2",
2722         "VK_EXT_validation_flags",
2723         "VK_NN_vi_surface",
2724         "VK_KHR_device_group_creation",
2725         "VK_KHR_external_memory_capabilities",
2726         "VK_KHR_external_semaphore_capabilities",
2727         "VK_EXT_direct_mode_display",
2728         "VK_EXT_acquire_xlib_display",
2729         "VK_EXT_display_surface_counter",
2730         "VK_EXT_swapchain_colorspace",
2731         "VK_KHR_external_fence_capabilities",
2732         "VK_KHR_get_surface_capabilities2",
2733         "VK_KHR_get_display_properties2",
2734         "VK_MVK_ios_surface",
2735         "VK_MVK_macos_surface",
2736         "VK_EXT_debug_utils",
2737         "VK_FUCHSIA_imagepipe_surface",
2738         "VK_EXT_metal_surface",
2739         "VK_KHR_surface_protected_capabilities",
2740         "VK_EXT_validation_features",
2741         "VK_EXT_headless_surface",
2742         "VK_EXT_acquire_drm_display",
2743         "VK_QNX_screen_surface",
2744         "VK_KHR_portability_enumeration",
2745         "VK_GOOGLE_surfaceless_query",
2746 };
2747
2748 ::std::string deviceExtensionNames[] =
2749 {
2750         "VK_KHR_swapchain",
2751         "VK_KHR_display_swapchain",
2752         "VK_NV_glsl_shader",
2753         "VK_EXT_depth_range_unrestricted",
2754         "VK_KHR_sampler_mirror_clamp_to_edge",
2755         "VK_IMG_filter_cubic",
2756         "VK_AMD_rasterization_order",
2757         "VK_AMD_shader_trinary_minmax",
2758         "VK_AMD_shader_explicit_vertex_parameter",
2759         "VK_EXT_debug_marker",
2760         "VK_KHR_video_queue",
2761         "VK_KHR_video_decode_queue",
2762         "VK_AMD_gcn_shader",
2763         "VK_NV_dedicated_allocation",
2764         "VK_EXT_transform_feedback",
2765         "VK_NVX_binary_import",
2766         "VK_NVX_image_view_handle",
2767         "VK_AMD_draw_indirect_count",
2768         "VK_AMD_negative_viewport_height",
2769         "VK_AMD_gpu_shader_half_float",
2770         "VK_AMD_shader_ballot",
2771         "VK_EXT_video_encode_h264",
2772         "VK_EXT_video_encode_h265",
2773         "VK_EXT_video_decode_h264",
2774         "VK_AMD_texture_gather_bias_lod",
2775         "VK_AMD_shader_info",
2776         "VK_KHR_dynamic_rendering",
2777         "VK_AMD_shader_image_load_store_lod",
2778         "VK_NV_corner_sampled_image",
2779         "VK_KHR_multiview",
2780         "VK_IMG_format_pvrtc",
2781         "VK_NV_external_memory",
2782         "VK_NV_external_memory_win32",
2783         "VK_NV_win32_keyed_mutex",
2784         "VK_KHR_device_group",
2785         "VK_KHR_shader_draw_parameters",
2786         "VK_EXT_shader_subgroup_ballot",
2787         "VK_EXT_shader_subgroup_vote",
2788         "VK_EXT_texture_compression_astc_hdr",
2789         "VK_EXT_astc_decode_mode",
2790         "VK_EXT_pipeline_robustness",
2791         "VK_KHR_maintenance1",
2792         "VK_KHR_external_memory",
2793         "VK_KHR_external_memory_win32",
2794         "VK_KHR_external_memory_fd",
2795         "VK_KHR_win32_keyed_mutex",
2796         "VK_KHR_external_semaphore",
2797         "VK_KHR_external_semaphore_win32",
2798         "VK_KHR_external_semaphore_fd",
2799         "VK_KHR_push_descriptor",
2800         "VK_EXT_conditional_rendering",
2801         "VK_KHR_shader_float16_int8",
2802         "VK_KHR_16bit_storage",
2803         "VK_KHR_incremental_present",
2804         "VK_KHR_descriptor_update_template",
2805         "VK_NV_clip_space_w_scaling",
2806         "VK_EXT_display_control",
2807         "VK_GOOGLE_display_timing",
2808         "VK_NV_sample_mask_override_coverage",
2809         "VK_NV_geometry_shader_passthrough",
2810         "VK_NV_viewport_array2",
2811         "VK_NVX_multiview_per_view_attributes",
2812         "VK_NV_viewport_swizzle",
2813         "VK_EXT_discard_rectangles",
2814         "VK_EXT_conservative_rasterization",
2815         "VK_EXT_depth_clip_enable",
2816         "VK_EXT_hdr_metadata",
2817         "VK_KHR_imageless_framebuffer",
2818         "VK_KHR_create_renderpass2",
2819         "VK_KHR_shared_presentable_image",
2820         "VK_KHR_external_fence",
2821         "VK_KHR_external_fence_win32",
2822         "VK_KHR_external_fence_fd",
2823         "VK_KHR_performance_query",
2824         "VK_KHR_maintenance2",
2825         "VK_KHR_variable_pointers",
2826         "VK_EXT_external_memory_dma_buf",
2827         "VK_EXT_queue_family_foreign",
2828         "VK_KHR_dedicated_allocation",
2829         "VK_ANDROID_external_memory_android_hardware_buffer",
2830         "VK_EXT_sampler_filter_minmax",
2831         "VK_KHR_storage_buffer_storage_class",
2832         "VK_AMD_gpu_shader_int16",
2833         "VK_AMD_mixed_attachment_samples",
2834         "VK_AMD_shader_fragment_mask",
2835         "VK_EXT_inline_uniform_block",
2836         "VK_EXT_shader_stencil_export",
2837         "VK_EXT_sample_locations",
2838         "VK_KHR_relaxed_block_layout",
2839         "VK_KHR_get_memory_requirements2",
2840         "VK_KHR_image_format_list",
2841         "VK_EXT_blend_operation_advanced",
2842         "VK_NV_fragment_coverage_to_color",
2843         "VK_KHR_acceleration_structure",
2844         "VK_KHR_ray_tracing_pipeline",
2845         "VK_KHR_ray_query",
2846         "VK_NV_framebuffer_mixed_samples",
2847         "VK_NV_fill_rectangle",
2848         "VK_NV_shader_sm_builtins",
2849         "VK_EXT_post_depth_coverage",
2850         "VK_KHR_sampler_ycbcr_conversion",
2851         "VK_KHR_bind_memory2",
2852         "VK_EXT_image_drm_format_modifier",
2853         "VK_EXT_validation_cache",
2854         "VK_EXT_descriptor_indexing",
2855         "VK_EXT_shader_viewport_index_layer",
2856         "VK_KHR_portability_subset",
2857         "VK_NV_shading_rate_image",
2858         "VK_NV_ray_tracing",
2859         "VK_NV_representative_fragment_test",
2860         "VK_KHR_maintenance3",
2861         "VK_KHR_draw_indirect_count",
2862         "VK_EXT_filter_cubic",
2863         "VK_QCOM_render_pass_shader_resolve",
2864         "VK_EXT_global_priority",
2865         "VK_KHR_shader_subgroup_extended_types",
2866         "VK_KHR_8bit_storage",
2867         "VK_EXT_external_memory_host",
2868         "VK_AMD_buffer_marker",
2869         "VK_KHR_shader_atomic_int64",
2870         "VK_KHR_shader_clock",
2871         "VK_AMD_pipeline_compiler_control",
2872         "VK_EXT_calibrated_timestamps",
2873         "VK_AMD_shader_core_properties",
2874         "VK_EXT_video_decode_h265",
2875         "VK_KHR_global_priority",
2876         "VK_AMD_memory_overallocation_behavior",
2877         "VK_EXT_vertex_attribute_divisor",
2878         "VK_GGP_frame_token",
2879         "VK_EXT_pipeline_creation_feedback",
2880         "VK_KHR_driver_properties",
2881         "VK_KHR_shader_float_controls",
2882         "VK_NV_shader_subgroup_partitioned",
2883         "VK_KHR_depth_stencil_resolve",
2884         "VK_KHR_swapchain_mutable_format",
2885         "VK_NV_compute_shader_derivatives",
2886         "VK_NV_mesh_shader",
2887         "VK_NV_fragment_shader_barycentric",
2888         "VK_NV_shader_image_footprint",
2889         "VK_NV_scissor_exclusive",
2890         "VK_NV_device_diagnostic_checkpoints",
2891         "VK_KHR_timeline_semaphore",
2892         "VK_INTEL_shader_integer_functions2",
2893         "VK_INTEL_performance_query",
2894         "VK_KHR_vulkan_memory_model",
2895         "VK_EXT_pci_bus_info",
2896         "VK_AMD_display_native_hdr",
2897         "VK_KHR_shader_terminate_invocation",
2898         "VK_EXT_fragment_density_map",
2899         "VK_EXT_scalar_block_layout",
2900         "VK_GOOGLE_hlsl_functionality1",
2901         "VK_GOOGLE_decorate_string",
2902         "VK_EXT_subgroup_size_control",
2903         "VK_KHR_fragment_shading_rate",
2904         "VK_AMD_shader_core_properties2",
2905         "VK_AMD_device_coherent_memory",
2906         "VK_EXT_shader_image_atomic_int64",
2907         "VK_KHR_spirv_1_4",
2908         "VK_EXT_memory_budget",
2909         "VK_EXT_memory_priority",
2910         "VK_NV_dedicated_allocation_image_aliasing",
2911         "VK_KHR_separate_depth_stencil_layouts",
2912         "VK_EXT_buffer_device_address",
2913         "VK_EXT_tooling_info",
2914         "VK_EXT_separate_stencil_usage",
2915         "VK_KHR_present_wait",
2916         "VK_NV_cooperative_matrix",
2917         "VK_NV_coverage_reduction_mode",
2918         "VK_EXT_fragment_shader_interlock",
2919         "VK_EXT_ycbcr_image_arrays",
2920         "VK_KHR_uniform_buffer_standard_layout",
2921         "VK_EXT_provoking_vertex",
2922         "VK_EXT_full_screen_exclusive",
2923         "VK_KHR_buffer_device_address",
2924         "VK_EXT_line_rasterization",
2925         "VK_EXT_shader_atomic_float",
2926         "VK_EXT_host_query_reset",
2927         "VK_EXT_index_type_uint8",
2928         "VK_EXT_extended_dynamic_state",
2929         "VK_KHR_deferred_host_operations",
2930         "VK_KHR_pipeline_executable_properties",
2931         "VK_EXT_shader_atomic_float2",
2932         "VK_EXT_shader_demote_to_helper_invocation",
2933         "VK_NV_device_generated_commands",
2934         "VK_NV_inherited_viewport_scissor",
2935         "VK_KHR_shader_integer_dot_product",
2936         "VK_EXT_texel_buffer_alignment",
2937         "VK_QCOM_render_pass_transform",
2938         "VK_EXT_device_memory_report",
2939         "VK_EXT_robustness2",
2940         "VK_EXT_custom_border_color",
2941         "VK_GOOGLE_user_type",
2942         "VK_KHR_pipeline_library",
2943         "VK_KHR_shader_non_semantic_info",
2944         "VK_KHR_present_id",
2945         "VK_EXT_private_data",
2946         "VK_EXT_pipeline_creation_cache_control",
2947         "VK_KHR_video_encode_queue",
2948         "VK_NV_device_diagnostics_config",
2949         "VK_QCOM_render_pass_store_ops",
2950         "VK_EXT_metal_objects",
2951         "VK_KHR_synchronization2",
2952         "VK_EXT_graphics_pipeline_library",
2953         "VK_AMD_shader_early_and_late_fragment_tests",
2954         "VK_KHR_fragment_shader_barycentric",
2955         "VK_KHR_shader_subgroup_uniform_control_flow",
2956         "VK_KHR_zero_initialize_workgroup_memory",
2957         "VK_NV_fragment_shading_rate_enums",
2958         "VK_NV_ray_tracing_motion_blur",
2959         "VK_EXT_mesh_shader",
2960         "VK_EXT_ycbcr_2plane_444_formats",
2961         "VK_EXT_fragment_density_map2",
2962         "VK_QCOM_rotated_copy_commands",
2963         "VK_EXT_image_robustness",
2964         "VK_KHR_workgroup_memory_explicit_layout",
2965         "VK_KHR_copy_commands2",
2966         "VK_EXT_image_compression_control",
2967         "VK_EXT_attachment_feedback_loop_layout",
2968         "VK_EXT_4444_formats",
2969         "VK_ARM_rasterization_order_attachment_access",
2970         "VK_EXT_rgba10x6_formats",
2971         "VK_NV_acquire_winrt_display",
2972         "VK_VALVE_mutable_descriptor_type",
2973         "VK_EXT_vertex_input_dynamic_state",
2974         "VK_EXT_physical_device_drm",
2975         "VK_EXT_depth_clip_control",
2976         "VK_EXT_primitive_topology_list_restart",
2977         "VK_KHR_format_feature_flags2",
2978         "VK_FUCHSIA_external_memory",
2979         "VK_FUCHSIA_external_semaphore",
2980         "VK_FUCHSIA_buffer_collection",
2981         "VK_HUAWEI_subpass_shading",
2982         "VK_HUAWEI_invocation_mask",
2983         "VK_NV_external_memory_rdma",
2984         "VK_EXT_pipeline_properties",
2985         "VK_EXT_multisampled_render_to_single_sampled",
2986         "VK_EXT_extended_dynamic_state2",
2987         "VK_EXT_color_write_enable",
2988         "VK_EXT_primitives_generated_query",
2989         "VK_KHR_ray_tracing_maintenance1",
2990         "VK_EXT_global_priority_query",
2991         "VK_EXT_image_view_min_lod",
2992         "VK_EXT_multi_draw",
2993         "VK_EXT_image_2d_view_of_3d",
2994         "VK_EXT_load_store_op_none",
2995         "VK_EXT_border_color_swizzle",
2996         "VK_EXT_pageable_device_local_memory",
2997         "VK_KHR_maintenance4",
2998         "VK_VALVE_descriptor_set_host_mapping",
2999         "VK_EXT_depth_clamp_zero_one",
3000         "VK_EXT_non_seamless_cube_map",
3001         "VK_QCOM_fragment_density_map_offset",
3002         "VK_NV_linear_color_attachment",
3003         "VK_EXT_image_compression_control_swapchain",
3004         "VK_QCOM_image_processing",
3005         "VK_EXT_subpass_merge_feedback",
3006         "VK_EXT_shader_module_identifier",
3007         "VK_EXT_rasterization_order_attachment_access",
3008         "VK_EXT_legacy_dithering",
3009         "VK_QCOM_tile_properties",
3010         "VK_SEC_amigo_profiling",
3011 };