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

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