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