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