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