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