icd/generated/mock_icd.h

   1 #ifndef __mock_icd_h_
   2 #define __mock_icd_h_ 1
   3
   4 /*
   5 ** Copyright (c) 2015-2018 The Khronos Group Inc.
   6 **
   7 ** Licensed under the Apache License, Version 2.0 (the "License");
   8 ** you may not use this file except in compliance with the License.
   9 ** You may obtain a copy of the License at
  10 **
  11 **     http://www.apache.org/licenses/LICENSE-2.0
  12 **
  13 ** Unless required by applicable law or agreed to in writing, software
  14 ** distributed under the License is distributed on an "AS IS" BASIS,
  15 ** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
  16 ** See the License for the specific language governing permissions and
  17 ** limitations under the License.
  18 */
  19
  20 /*
  21 ** This header is generated from the Khronos Vulkan XML API Registry.
  22 **
  23 */
  24
  25 #include <unordered_map>
  26 #include <mutex>
  27 #include <string>
  28 #include <cstring>
  29 #include "vulkan/vk_icd.h"
  30 namespace vkmock {
  31
  32
  33 using mutex_t = std::mutex;
  34 using lock_guard_t = std::lock_guard<mutex_t>;
  35 using unique_lock_t = std::unique_lock<mutex_t>;
  36
  37 static mutex_t global_lock;
  38 static uint64_t global_unique_handle = 1;
  39 static const uint32_t SUPPORTED_LOADER_ICD_INTERFACE_VERSION = 5;
  40 static uint32_t loader_interface_version = 0;
  41 static bool negotiate_loader_icd_interface_called = false;
  42 static void* CreateDispObjHandle() {
  43     auto handle = new VK_LOADER_DATA;
  44     set_loader_magic_value(handle);
  45     return handle;
  46 }
  47 static void DestroyDispObjHandle(void* handle) {
  48     delete reinterpret_cast<VK_LOADER_DATA*>(handle);
  49 }
  50
  51 // Map of instance extension name to version
  52 static const std::unordered_map<std::string, uint32_t> instance_extension_map = {
  53     {"VK_KHR_surface", 25},
  54     {"VK_KHR_display", 23},
  55     {"VK_KHR_xlib_surface", 6},
  56     {"VK_KHR_xcb_surface", 6},
  57     {"VK_KHR_wayland_surface", 6},
  58     {"VK_KHR_android_surface", 6},
  59     {"VK_KHR_win32_surface", 6},
  60     {"VK_EXT_debug_report", 9},
  61     {"VK_GGP_stream_descriptor_surface", 1},
  62     {"VK_NV_external_memory_capabilities", 1},
  63     {"VK_KHR_get_physical_device_properties2", 2},
  64     {"VK_EXT_validation_flags", 2},
  65     {"VK_NN_vi_surface", 1},
  66     {"VK_KHR_device_group_creation", 1},
  67     {"VK_KHR_external_memory_capabilities", 1},
  68     {"VK_KHR_external_semaphore_capabilities", 1},
  69     {"VK_EXT_direct_mode_display", 1},
  70     {"VK_EXT_acquire_xlib_display", 1},
  71     {"VK_EXT_display_surface_counter", 1},
  72     {"VK_EXT_swapchain_colorspace", 4},
  73     {"VK_KHR_external_fence_capabilities", 1},
  74     {"VK_KHR_get_surface_capabilities2", 1},
  75     {"VK_KHR_get_display_properties2", 1},
  76     {"VK_MVK_ios_surface", 3},
  77     {"VK_MVK_macos_surface", 3},
  78     {"VK_EXT_debug_utils", 2},
  79     {"VK_FUCHSIA_imagepipe_surface", 1},
  80     {"VK_EXT_metal_surface", 1},
  81     {"VK_KHR_surface_protected_capabilities", 1},
  82     {"VK_EXT_validation_features", 4},
  83     {"VK_EXT_headless_surface", 1},
  84     {"VK_EXT_directfb_surface", 1},
  85 };
  86 // Map of device extension name to version
  87 static const std::unordered_map<std::string, uint32_t> device_extension_map = {
  88     {"VK_KHR_swapchain", 70},
  89     {"VK_KHR_display_swapchain", 10},
  90     {"VK_NV_glsl_shader", 1},
  91     {"VK_EXT_depth_range_unrestricted", 1},
  92     {"VK_KHR_sampler_mirror_clamp_to_edge", 3},
  93     {"VK_IMG_filter_cubic", 1},
  94     {"VK_AMD_rasterization_order", 1},
  95     {"VK_AMD_shader_trinary_minmax", 1},
  96     {"VK_AMD_shader_explicit_vertex_parameter", 1},
  97     {"VK_EXT_debug_marker", 4},
  98     {"VK_AMD_gcn_shader", 1},
  99     {"VK_NV_dedicated_allocation", 1},
 100     {"VK_EXT_transform_feedback", 1},
 101     {"VK_NVX_image_view_handle", 2},
 102     {"VK_AMD_draw_indirect_count", 2},
 103     {"VK_AMD_negative_viewport_height", 1},
 104     {"VK_AMD_gpu_shader_half_float", 2},
 105     {"VK_AMD_shader_ballot", 1},
 106     {"VK_AMD_texture_gather_bias_lod", 1},
 107     {"VK_AMD_shader_info", 1},
 108     {"VK_AMD_shader_image_load_store_lod", 1},
 109     {"VK_NV_corner_sampled_image", 2},
 110     {"VK_KHR_multiview", 1},
 111     {"VK_IMG_format_pvrtc", 1},
 112     {"VK_NV_external_memory", 1},
 113     {"VK_NV_external_memory_win32", 1},
 114     {"VK_NV_win32_keyed_mutex", 2},
 115     {"VK_KHR_device_group", 4},
 116     {"VK_KHR_shader_draw_parameters", 1},
 117     {"VK_EXT_shader_subgroup_ballot", 1},
 118     {"VK_EXT_shader_subgroup_vote", 1},
 119     {"VK_EXT_texture_compression_astc_hdr", 1},
 120     {"VK_EXT_astc_decode_mode", 1},
 121     {"VK_KHR_maintenance1", 2},
 122     {"VK_KHR_external_memory", 1},
 123     {"VK_KHR_external_memory_win32", 1},
 124     {"VK_KHR_external_memory_fd", 1},
 125     {"VK_KHR_win32_keyed_mutex", 1},
 126     {"VK_KHR_external_semaphore", 1},
 127     {"VK_KHR_external_semaphore_win32", 1},
 128     {"VK_KHR_external_semaphore_fd", 1},
 129     {"VK_KHR_push_descriptor", 2},
 130     {"VK_EXT_conditional_rendering", 2},
 131     {"VK_KHR_shader_float16_int8", 1},
 132     {"VK_KHR_16bit_storage", 1},
 133     {"VK_KHR_incremental_present", 1},
 134     {"VK_KHR_descriptor_update_template", 1},
 135     {"VK_NV_clip_space_w_scaling", 1},
 136     {"VK_EXT_display_control", 1},
 137     {"VK_GOOGLE_display_timing", 1},
 138     {"VK_NV_sample_mask_override_coverage", 1},
 139     {"VK_NV_geometry_shader_passthrough", 1},
 140     {"VK_NV_viewport_array2", 1},
 141     {"VK_NVX_multiview_per_view_attributes", 1},
 142     {"VK_NV_viewport_swizzle", 1},
 143     {"VK_EXT_discard_rectangles", 1},
 144     {"VK_EXT_conservative_rasterization", 1},
 145     {"VK_EXT_depth_clip_enable", 1},
 146     {"VK_EXT_hdr_metadata", 2},
 147     {"VK_KHR_imageless_framebuffer", 1},
 148     {"VK_KHR_create_renderpass2", 1},
 149     {"VK_KHR_shared_presentable_image", 1},
 150     {"VK_KHR_external_fence", 1},
 151     {"VK_KHR_external_fence_win32", 1},
 152     {"VK_KHR_external_fence_fd", 1},
 153     {"VK_KHR_performance_query", 1},
 154     {"VK_KHR_maintenance2", 1},
 155     {"VK_KHR_variable_pointers", 1},
 156     {"VK_EXT_external_memory_dma_buf", 1},
 157     {"VK_EXT_queue_family_foreign", 1},
 158     {"VK_KHR_dedicated_allocation", 3},
 159     {"VK_ANDROID_external_memory_android_hardware_buffer", 3},
 160     {"VK_EXT_sampler_filter_minmax", 2},
 161     {"VK_KHR_storage_buffer_storage_class", 1},
 162     {"VK_AMD_gpu_shader_int16", 2},
 163     {"VK_AMD_mixed_attachment_samples", 1},
 164     {"VK_AMD_shader_fragment_mask", 1},
 165     {"VK_EXT_inline_uniform_block", 1},
 166     {"VK_EXT_shader_stencil_export", 1},
 167     {"VK_EXT_sample_locations", 1},
 168     {"VK_KHR_relaxed_block_layout", 1},
 169     {"VK_KHR_get_memory_requirements2", 1},
 170     {"VK_KHR_image_format_list", 1},
 171     {"VK_EXT_blend_operation_advanced", 2},
 172     {"VK_NV_fragment_coverage_to_color", 1},
 173     {"VK_KHR_ray_tracing", 8},
 174     {"VK_NV_framebuffer_mixed_samples", 1},
 175     {"VK_NV_fill_rectangle", 1},
 176     {"VK_NV_shader_sm_builtins", 1},
 177     {"VK_EXT_post_depth_coverage", 1},
 178     {"VK_KHR_sampler_ycbcr_conversion", 14},
 179     {"VK_KHR_bind_memory2", 1},
 180     {"VK_EXT_image_drm_format_modifier", 1},
 181     {"VK_EXT_descriptor_indexing", 2},
 182     {"VK_EXT_shader_viewport_index_layer", 1},
 183     {"VK_KHR_portability_subset", 1},
 184     {"VK_NV_shading_rate_image", 3},
 185     {"VK_NV_ray_tracing", 3},
 186     {"VK_NV_representative_fragment_test", 2},
 187     {"VK_KHR_maintenance3", 1},
 188     {"VK_KHR_draw_indirect_count", 1},
 189     {"VK_EXT_filter_cubic", 3},
 190     {"VK_QCOM_render_pass_shader_resolve", 4},
 191     {"VK_EXT_global_priority", 2},
 192     {"VK_KHR_shader_subgroup_extended_types", 1},
 193     {"VK_KHR_8bit_storage", 1},
 194     {"VK_EXT_external_memory_host", 1},
 195     {"VK_AMD_buffer_marker", 1},
 196     {"VK_KHR_shader_atomic_int64", 1},
 197     {"VK_KHR_shader_clock", 1},
 198     {"VK_AMD_pipeline_compiler_control", 1},
 199     {"VK_EXT_calibrated_timestamps", 1},
 200     {"VK_AMD_shader_core_properties", 2},
 201     {"VK_AMD_memory_overallocation_behavior", 1},
 202     {"VK_EXT_vertex_attribute_divisor", 3},
 203     {"VK_GGP_frame_token", 1},
 204     {"VK_EXT_pipeline_creation_feedback", 1},
 205     {"VK_KHR_driver_properties", 1},
 206     {"VK_KHR_shader_float_controls", 4},
 207     {"VK_NV_shader_subgroup_partitioned", 1},
 208     {"VK_KHR_depth_stencil_resolve", 1},
 209     {"VK_KHR_swapchain_mutable_format", 1},
 210     {"VK_NV_compute_shader_derivatives", 1},
 211     {"VK_NV_mesh_shader", 1},
 212     {"VK_NV_fragment_shader_barycentric", 1},
 213     {"VK_NV_shader_image_footprint", 2},
 214     {"VK_NV_scissor_exclusive", 1},
 215     {"VK_NV_device_diagnostic_checkpoints", 2},
 216     {"VK_KHR_timeline_semaphore", 2},
 217     {"VK_INTEL_shader_integer_functions2", 1},
 218     {"VK_INTEL_performance_query", 2},
 219     {"VK_KHR_vulkan_memory_model", 3},
 220     {"VK_EXT_pci_bus_info", 2},
 221     {"VK_AMD_display_native_hdr", 1},
 222     {"VK_KHR_shader_terminate_invocation", 1},
 223     {"VK_EXT_fragment_density_map", 1},
 224     {"VK_EXT_scalar_block_layout", 1},
 225     {"VK_GOOGLE_hlsl_functionality1", 1},
 226     {"VK_GOOGLE_decorate_string", 1},
 227     {"VK_EXT_subgroup_size_control", 2},
 228     {"VK_KHR_fragment_shading_rate", 1},
 229     {"VK_AMD_shader_core_properties2", 1},
 230     {"VK_AMD_device_coherent_memory", 1},
 231     {"VK_EXT_shader_image_atomic_int64", 1},
 232     {"VK_KHR_spirv_1_4", 1},
 233     {"VK_EXT_memory_budget", 1},
 234     {"VK_EXT_memory_priority", 1},
 235     {"VK_NV_dedicated_allocation_image_aliasing", 1},
 236     {"VK_KHR_separate_depth_stencil_layouts", 1},
 237     {"VK_EXT_buffer_device_address", 2},
 238     {"VK_EXT_tooling_info", 1},
 239     {"VK_EXT_separate_stencil_usage", 1},
 240     {"VK_NV_cooperative_matrix", 1},
 241     {"VK_NV_coverage_reduction_mode", 1},
 242     {"VK_EXT_fragment_shader_interlock", 1},
 243     {"VK_EXT_ycbcr_image_arrays", 1},
 244     {"VK_KHR_uniform_buffer_standard_layout", 1},
 245     {"VK_EXT_full_screen_exclusive", 4},
 246     {"VK_KHR_buffer_device_address", 1},
 247     {"VK_EXT_line_rasterization", 1},
 248     {"VK_EXT_shader_atomic_float", 1},
 249     {"VK_EXT_host_query_reset", 1},
 250     {"VK_EXT_index_type_uint8", 1},
 251     {"VK_EXT_extended_dynamic_state", 1},
 252     {"VK_KHR_deferred_host_operations", 3},
 253     {"VK_KHR_pipeline_executable_properties", 1},
 254     {"VK_EXT_shader_demote_to_helper_invocation", 1},
 255     {"VK_NV_device_generated_commands", 3},
 256     {"VK_EXT_texel_buffer_alignment", 1},
 257     {"VK_QCOM_render_pass_transform", 1},
 258     {"VK_EXT_device_memory_report", 1},
 259     {"VK_EXT_robustness2", 1},
 260     {"VK_EXT_custom_border_color", 12},
 261     {"VK_GOOGLE_user_type", 1},
 262     {"VK_KHR_pipeline_library", 1},
 263     {"VK_KHR_shader_non_semantic_info", 1},
 264     {"VK_EXT_private_data", 1},
 265     {"VK_EXT_pipeline_creation_cache_control", 3},
 266     {"VK_NV_device_diagnostics_config", 1},
 267     {"VK_QCOM_render_pass_store_ops", 2},
 268     {"VK_EXT_fragment_density_map2", 1},
 269     {"VK_EXT_image_robustness", 1},
 270     {"VK_KHR_copy_commands2", 1},
 271     {"VK_EXT_4444_formats", 1},
 272 };
 273
 274
 275 static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance(
 276     const VkInstanceCreateInfo*                 pCreateInfo,
 277     const VkAllocationCallbacks*                pAllocator,
 278     VkInstance*                                 pInstance);
 279
 280 static VKAPI_ATTR void VKAPI_CALL DestroyInstance(
 281     VkInstance                                  instance,
 282     const VkAllocationCallbacks*                pAllocator);
 283
 284 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices(
 285     VkInstance                                  instance,
 286     uint32_t*                                   pPhysicalDeviceCount,
 287     VkPhysicalDevice*                           pPhysicalDevices);
 288
 289 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures(
 290     VkPhysicalDevice                            physicalDevice,
 291     VkPhysicalDeviceFeatures*                   pFeatures);
 292
 293 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties(
 294     VkPhysicalDevice                            physicalDevice,
 295     VkFormat                                    format,
 296     VkFormatProperties*                         pFormatProperties);
 297
 298 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties(
 299     VkPhysicalDevice                            physicalDevice,
 300     VkFormat                                    format,
 301     VkImageType                                 type,
 302     VkImageTiling                               tiling,
 303     VkImageUsageFlags                           usage,
 304     VkImageCreateFlags                          flags,
 305     VkImageFormatProperties*                    pImageFormatProperties);
 306
 307 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties(
 308     VkPhysicalDevice                            physicalDevice,
 309     VkPhysicalDeviceProperties*                 pProperties);
 310
 311 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties(
 312     VkPhysicalDevice                            physicalDevice,
 313     uint32_t*                                   pQueueFamilyPropertyCount,
 314     VkQueueFamilyProperties*                    pQueueFamilyProperties);
 315
 316 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties(
 317     VkPhysicalDevice                            physicalDevice,
 318     VkPhysicalDeviceMemoryProperties*           pMemoryProperties);
 319
 320 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr(
 321     VkInstance                                  instance,
 322     const char*                                 pName);
 323
 324 static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr(
 325     VkDevice                                    device,
 326     const char*                                 pName);
 327
 328 static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice(
 329     VkPhysicalDevice                            physicalDevice,
 330     const VkDeviceCreateInfo*                   pCreateInfo,
 331     const VkAllocationCallbacks*                pAllocator,
 332     VkDevice*                                   pDevice);
 333
 334 static VKAPI_ATTR void VKAPI_CALL DestroyDevice(
 335     VkDevice                                    device,
 336     const VkAllocationCallbacks*                pAllocator);
 337
 338 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties(
 339     const char*                                 pLayerName,
 340     uint32_t*                                   pPropertyCount,
 341     VkExtensionProperties*                      pProperties);
 342
 343 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties(
 344     VkPhysicalDevice                            physicalDevice,
 345     const char*                                 pLayerName,
 346     uint32_t*                                   pPropertyCount,
 347     VkExtensionProperties*                      pProperties);
 348
 349 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties(
 350     uint32_t*                                   pPropertyCount,
 351     VkLayerProperties*                          pProperties);
 352
 353 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties(
 354     VkPhysicalDevice                            physicalDevice,
 355     uint32_t*                                   pPropertyCount,
 356     VkLayerProperties*                          pProperties);
 357
 358 static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue(
 359     VkDevice                                    device,
 360     uint32_t                                    queueFamilyIndex,
 361     uint32_t                                    queueIndex,
 362     VkQueue*                                    pQueue);
 363
 364 static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit(
 365     VkQueue                                     queue,
 366     uint32_t                                    submitCount,
 367     const VkSubmitInfo*                         pSubmits,
 368     VkFence                                     fence);
 369
 370 static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle(
 371     VkQueue                                     queue);
 372
 373 static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle(
 374     VkDevice                                    device);
 375
 376 static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory(
 377     VkDevice                                    device,
 378     const VkMemoryAllocateInfo*                 pAllocateInfo,
 379     const VkAllocationCallbacks*                pAllocator,
 380     VkDeviceMemory*                             pMemory);
 381
 382 static VKAPI_ATTR void VKAPI_CALL FreeMemory(
 383     VkDevice                                    device,
 384     VkDeviceMemory                              memory,
 385     const VkAllocationCallbacks*                pAllocator);
 386
 387 static VKAPI_ATTR VkResult VKAPI_CALL MapMemory(
 388     VkDevice                                    device,
 389     VkDeviceMemory                              memory,
 390     VkDeviceSize                                offset,
 391     VkDeviceSize                                size,
 392     VkMemoryMapFlags                            flags,
 393     void**                                      ppData);
 394
 395 static VKAPI_ATTR void VKAPI_CALL UnmapMemory(
 396     VkDevice                                    device,
 397     VkDeviceMemory                              memory);
 398
 399 static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges(
 400     VkDevice                                    device,
 401     uint32_t                                    memoryRangeCount,
 402     const VkMappedMemoryRange*                  pMemoryRanges);
 403
 404 static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges(
 405     VkDevice                                    device,
 406     uint32_t                                    memoryRangeCount,
 407     const VkMappedMemoryRange*                  pMemoryRanges);
 408
 409 static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment(
 410     VkDevice                                    device,
 411     VkDeviceMemory                              memory,
 412     VkDeviceSize*                               pCommittedMemoryInBytes);
 413
 414 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory(
 415     VkDevice                                    device,
 416     VkBuffer                                    buffer,
 417     VkDeviceMemory                              memory,
 418     VkDeviceSize                                memoryOffset);
 419
 420 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory(
 421     VkDevice                                    device,
 422     VkImage                                     image,
 423     VkDeviceMemory                              memory,
 424     VkDeviceSize                                memoryOffset);
 425
 426 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements(
 427     VkDevice                                    device,
 428     VkBuffer                                    buffer,
 429     VkMemoryRequirements*                       pMemoryRequirements);
 430
 431 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements(
 432     VkDevice                                    device,
 433     VkImage                                     image,
 434     VkMemoryRequirements*                       pMemoryRequirements);
 435
 436 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements(
 437     VkDevice                                    device,
 438     VkImage                                     image,
 439     uint32_t*                                   pSparseMemoryRequirementCount,
 440     VkSparseImageMemoryRequirements*            pSparseMemoryRequirements);
 441
 442 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties(
 443     VkPhysicalDevice                            physicalDevice,
 444     VkFormat                                    format,
 445     VkImageType                                 type,
 446     VkSampleCountFlagBits                       samples,
 447     VkImageUsageFlags                           usage,
 448     VkImageTiling                               tiling,
 449     uint32_t*                                   pPropertyCount,
 450     VkSparseImageFormatProperties*              pProperties);
 451
 452 static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse(
 453     VkQueue                                     queue,
 454     uint32_t                                    bindInfoCount,
 455     const VkBindSparseInfo*                     pBindInfo,
 456     VkFence                                     fence);
 457
 458 static VKAPI_ATTR VkResult VKAPI_CALL CreateFence(
 459     VkDevice                                    device,
 460     const VkFenceCreateInfo*                    pCreateInfo,
 461     const VkAllocationCallbacks*                pAllocator,
 462     VkFence*                                    pFence);
 463
 464 static VKAPI_ATTR void VKAPI_CALL DestroyFence(
 465     VkDevice                                    device,
 466     VkFence                                     fence,
 467     const VkAllocationCallbacks*                pAllocator);
 468
 469 static VKAPI_ATTR VkResult VKAPI_CALL ResetFences(
 470     VkDevice                                    device,
 471     uint32_t                                    fenceCount,
 472     const VkFence*                              pFences);
 473
 474 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus(
 475     VkDevice                                    device,
 476     VkFence                                     fence);
 477
 478 static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences(
 479     VkDevice                                    device,
 480     uint32_t                                    fenceCount,
 481     const VkFence*                              pFences,
 482     VkBool32                                    waitAll,
 483     uint64_t                                    timeout);
 484
 485 static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore(
 486     VkDevice                                    device,
 487     const VkSemaphoreCreateInfo*                pCreateInfo,
 488     const VkAllocationCallbacks*                pAllocator,
 489     VkSemaphore*                                pSemaphore);
 490
 491 static VKAPI_ATTR void VKAPI_CALL DestroySemaphore(
 492     VkDevice                                    device,
 493     VkSemaphore                                 semaphore,
 494     const VkAllocationCallbacks*                pAllocator);
 495
 496 static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent(
 497     VkDevice                                    device,
 498     const VkEventCreateInfo*                    pCreateInfo,
 499     const VkAllocationCallbacks*                pAllocator,
 500     VkEvent*                                    pEvent);
 501
 502 static VKAPI_ATTR void VKAPI_CALL DestroyEvent(
 503     VkDevice                                    device,
 504     VkEvent                                     event,
 505     const VkAllocationCallbacks*                pAllocator);
 506
 507 static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus(
 508     VkDevice                                    device,
 509     VkEvent                                     event);
 510
 511 static VKAPI_ATTR VkResult VKAPI_CALL SetEvent(
 512     VkDevice                                    device,
 513     VkEvent                                     event);
 514
 515 static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent(
 516     VkDevice                                    device,
 517     VkEvent                                     event);
 518
 519 static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool(
 520     VkDevice                                    device,
 521     const VkQueryPoolCreateInfo*                pCreateInfo,
 522     const VkAllocationCallbacks*                pAllocator,
 523     VkQueryPool*                                pQueryPool);
 524
 525 static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool(
 526     VkDevice                                    device,
 527     VkQueryPool                                 queryPool,
 528     const VkAllocationCallbacks*                pAllocator);
 529
 530 static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults(
 531     VkDevice                                    device,
 532     VkQueryPool                                 queryPool,
 533     uint32_t                                    firstQuery,
 534     uint32_t                                    queryCount,
 535     size_t                                      dataSize,
 536     void*                                       pData,
 537     VkDeviceSize                                stride,
 538     VkQueryResultFlags                          flags);
 539
 540 static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer(
 541     VkDevice                                    device,
 542     const VkBufferCreateInfo*                   pCreateInfo,
 543     const VkAllocationCallbacks*                pAllocator,
 544     VkBuffer*                                   pBuffer);
 545
 546 static VKAPI_ATTR void VKAPI_CALL DestroyBuffer(
 547     VkDevice                                    device,
 548     VkBuffer                                    buffer,
 549     const VkAllocationCallbacks*                pAllocator);
 550
 551 static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView(
 552     VkDevice                                    device,
 553     const VkBufferViewCreateInfo*               pCreateInfo,
 554     const VkAllocationCallbacks*                pAllocator,
 555     VkBufferView*                               pView);
 556
 557 static VKAPI_ATTR void VKAPI_CALL DestroyBufferView(
 558     VkDevice                                    device,
 559     VkBufferView                                bufferView,
 560     const VkAllocationCallbacks*                pAllocator);
 561
 562 static VKAPI_ATTR VkResult VKAPI_CALL CreateImage(
 563     VkDevice                                    device,
 564     const VkImageCreateInfo*                    pCreateInfo,
 565     const VkAllocationCallbacks*                pAllocator,
 566     VkImage*                                    pImage);
 567
 568 static VKAPI_ATTR void VKAPI_CALL DestroyImage(
 569     VkDevice                                    device,
 570     VkImage                                     image,
 571     const VkAllocationCallbacks*                pAllocator);
 572
 573 static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout(
 574     VkDevice                                    device,
 575     VkImage                                     image,
 576     const VkImageSubresource*                   pSubresource,
 577     VkSubresourceLayout*                        pLayout);
 578
 579 static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView(
 580     VkDevice                                    device,
 581     const VkImageViewCreateInfo*                pCreateInfo,
 582     const VkAllocationCallbacks*                pAllocator,
 583     VkImageView*                                pView);
 584
 585 static VKAPI_ATTR void VKAPI_CALL DestroyImageView(
 586     VkDevice                                    device,
 587     VkImageView                                 imageView,
 588     const VkAllocationCallbacks*                pAllocator);
 589
 590 static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule(
 591     VkDevice                                    device,
 592     const VkShaderModuleCreateInfo*             pCreateInfo,
 593     const VkAllocationCallbacks*                pAllocator,
 594     VkShaderModule*                             pShaderModule);
 595
 596 static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule(
 597     VkDevice                                    device,
 598     VkShaderModule                              shaderModule,
 599     const VkAllocationCallbacks*                pAllocator);
 600
 601 static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache(
 602     VkDevice                                    device,
 603     const VkPipelineCacheCreateInfo*            pCreateInfo,
 604     const VkAllocationCallbacks*                pAllocator,
 605     VkPipelineCache*                            pPipelineCache);
 606
 607 static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache(
 608     VkDevice                                    device,
 609     VkPipelineCache                             pipelineCache,
 610     const VkAllocationCallbacks*                pAllocator);
 611
 612 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData(
 613     VkDevice                                    device,
 614     VkPipelineCache                             pipelineCache,
 615     size_t*                                     pDataSize,
 616     void*                                       pData);
 617
 618 static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches(
 619     VkDevice                                    device,
 620     VkPipelineCache                             dstCache,
 621     uint32_t                                    srcCacheCount,
 622     const VkPipelineCache*                      pSrcCaches);
 623
 624 static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines(
 625     VkDevice                                    device,
 626     VkPipelineCache                             pipelineCache,
 627     uint32_t                                    createInfoCount,
 628     const VkGraphicsPipelineCreateInfo*         pCreateInfos,
 629     const VkAllocationCallbacks*                pAllocator,
 630     VkPipeline*                                 pPipelines);
 631
 632 static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines(
 633     VkDevice                                    device,
 634     VkPipelineCache                             pipelineCache,
 635     uint32_t                                    createInfoCount,
 636     const VkComputePipelineCreateInfo*          pCreateInfos,
 637     const VkAllocationCallbacks*                pAllocator,
 638     VkPipeline*                                 pPipelines);
 639
 640 static VKAPI_ATTR void VKAPI_CALL DestroyPipeline(
 641     VkDevice                                    device,
 642     VkPipeline                                  pipeline,
 643     const VkAllocationCallbacks*                pAllocator);
 644
 645 static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout(
 646     VkDevice                                    device,
 647     const VkPipelineLayoutCreateInfo*           pCreateInfo,
 648     const VkAllocationCallbacks*                pAllocator,
 649     VkPipelineLayout*                           pPipelineLayout);
 650
 651 static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout(
 652     VkDevice                                    device,
 653     VkPipelineLayout                            pipelineLayout,
 654     const VkAllocationCallbacks*                pAllocator);
 655
 656 static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler(
 657     VkDevice                                    device,
 658     const VkSamplerCreateInfo*                  pCreateInfo,
 659     const VkAllocationCallbacks*                pAllocator,
 660     VkSampler*                                  pSampler);
 661
 662 static VKAPI_ATTR void VKAPI_CALL DestroySampler(
 663     VkDevice                                    device,
 664     VkSampler                                   sampler,
 665     const VkAllocationCallbacks*                pAllocator);
 666
 667 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout(
 668     VkDevice                                    device,
 669     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
 670     const VkAllocationCallbacks*                pAllocator,
 671     VkDescriptorSetLayout*                      pSetLayout);
 672
 673 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout(
 674     VkDevice                                    device,
 675     VkDescriptorSetLayout                       descriptorSetLayout,
 676     const VkAllocationCallbacks*                pAllocator);
 677
 678 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool(
 679     VkDevice                                    device,
 680     const VkDescriptorPoolCreateInfo*           pCreateInfo,
 681     const VkAllocationCallbacks*                pAllocator,
 682     VkDescriptorPool*                           pDescriptorPool);
 683
 684 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool(
 685     VkDevice                                    device,
 686     VkDescriptorPool                            descriptorPool,
 687     const VkAllocationCallbacks*                pAllocator);
 688
 689 static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool(
 690     VkDevice                                    device,
 691     VkDescriptorPool                            descriptorPool,
 692     VkDescriptorPoolResetFlags                  flags);
 693
 694 static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets(
 695     VkDevice                                    device,
 696     const VkDescriptorSetAllocateInfo*          pAllocateInfo,
 697     VkDescriptorSet*                            pDescriptorSets);
 698
 699 static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets(
 700     VkDevice                                    device,
 701     VkDescriptorPool                            descriptorPool,
 702     uint32_t                                    descriptorSetCount,
 703     const VkDescriptorSet*                      pDescriptorSets);
 704
 705 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets(
 706     VkDevice                                    device,
 707     uint32_t                                    descriptorWriteCount,
 708     const VkWriteDescriptorSet*                 pDescriptorWrites,
 709     uint32_t                                    descriptorCopyCount,
 710     const VkCopyDescriptorSet*                  pDescriptorCopies);
 711
 712 static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer(
 713     VkDevice                                    device,
 714     const VkFramebufferCreateInfo*              pCreateInfo,
 715     const VkAllocationCallbacks*                pAllocator,
 716     VkFramebuffer*                              pFramebuffer);
 717
 718 static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer(
 719     VkDevice                                    device,
 720     VkFramebuffer                               framebuffer,
 721     const VkAllocationCallbacks*                pAllocator);
 722
 723 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass(
 724     VkDevice                                    device,
 725     const VkRenderPassCreateInfo*               pCreateInfo,
 726     const VkAllocationCallbacks*                pAllocator,
 727     VkRenderPass*                               pRenderPass);
 728
 729 static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass(
 730     VkDevice                                    device,
 731     VkRenderPass                                renderPass,
 732     const VkAllocationCallbacks*                pAllocator);
 733
 734 static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity(
 735     VkDevice                                    device,
 736     VkRenderPass                                renderPass,
 737     VkExtent2D*                                 pGranularity);
 738
 739 static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool(
 740     VkDevice                                    device,
 741     const VkCommandPoolCreateInfo*              pCreateInfo,
 742     const VkAllocationCallbacks*                pAllocator,
 743     VkCommandPool*                              pCommandPool);
 744
 745 static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool(
 746     VkDevice                                    device,
 747     VkCommandPool                               commandPool,
 748     const VkAllocationCallbacks*                pAllocator);
 749
 750 static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool(
 751     VkDevice                                    device,
 752     VkCommandPool                               commandPool,
 753     VkCommandPoolResetFlags                     flags);
 754
 755 static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers(
 756     VkDevice                                    device,
 757     const VkCommandBufferAllocateInfo*          pAllocateInfo,
 758     VkCommandBuffer*                            pCommandBuffers);
 759
 760 static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers(
 761     VkDevice                                    device,
 762     VkCommandPool                               commandPool,
 763     uint32_t                                    commandBufferCount,
 764     const VkCommandBuffer*                      pCommandBuffers);
 765
 766 static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer(
 767     VkCommandBuffer                             commandBuffer,
 768     const VkCommandBufferBeginInfo*             pBeginInfo);
 769
 770 static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer(
 771     VkCommandBuffer                             commandBuffer);
 772
 773 static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer(
 774     VkCommandBuffer                             commandBuffer,
 775     VkCommandBufferResetFlags                   flags);
 776
 777 static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline(
 778     VkCommandBuffer                             commandBuffer,
 779     VkPipelineBindPoint                         pipelineBindPoint,
 780     VkPipeline                                  pipeline);
 781
 782 static VKAPI_ATTR void VKAPI_CALL CmdSetViewport(
 783     VkCommandBuffer                             commandBuffer,
 784     uint32_t                                    firstViewport,
 785     uint32_t                                    viewportCount,
 786     const VkViewport*                           pViewports);
 787
 788 static VKAPI_ATTR void VKAPI_CALL CmdSetScissor(
 789     VkCommandBuffer                             commandBuffer,
 790     uint32_t                                    firstScissor,
 791     uint32_t                                    scissorCount,
 792     const VkRect2D*                             pScissors);
 793
 794 static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth(
 795     VkCommandBuffer                             commandBuffer,
 796     float                                       lineWidth);
 797
 798 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias(
 799     VkCommandBuffer                             commandBuffer,
 800     float                                       depthBiasConstantFactor,
 801     float                                       depthBiasClamp,
 802     float                                       depthBiasSlopeFactor);
 803
 804 static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants(
 805     VkCommandBuffer                             commandBuffer,
 806     const float                                 blendConstants[4]);
 807
 808 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds(
 809     VkCommandBuffer                             commandBuffer,
 810     float                                       minDepthBounds,
 811     float                                       maxDepthBounds);
 812
 813 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask(
 814     VkCommandBuffer                             commandBuffer,
 815     VkStencilFaceFlags                          faceMask,
 816     uint32_t                                    compareMask);
 817
 818 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask(
 819     VkCommandBuffer                             commandBuffer,
 820     VkStencilFaceFlags                          faceMask,
 821     uint32_t                                    writeMask);
 822
 823 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference(
 824     VkCommandBuffer                             commandBuffer,
 825     VkStencilFaceFlags                          faceMask,
 826     uint32_t                                    reference);
 827
 828 static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets(
 829     VkCommandBuffer                             commandBuffer,
 830     VkPipelineBindPoint                         pipelineBindPoint,
 831     VkPipelineLayout                            layout,
 832     uint32_t                                    firstSet,
 833     uint32_t                                    descriptorSetCount,
 834     const VkDescriptorSet*                      pDescriptorSets,
 835     uint32_t                                    dynamicOffsetCount,
 836     const uint32_t*                             pDynamicOffsets);
 837
 838 static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer(
 839     VkCommandBuffer                             commandBuffer,
 840     VkBuffer                                    buffer,
 841     VkDeviceSize                                offset,
 842     VkIndexType                                 indexType);
 843
 844 static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers(
 845     VkCommandBuffer                             commandBuffer,
 846     uint32_t                                    firstBinding,
 847     uint32_t                                    bindingCount,
 848     const VkBuffer*                             pBuffers,
 849     const VkDeviceSize*                         pOffsets);
 850
 851 static VKAPI_ATTR void VKAPI_CALL CmdDraw(
 852     VkCommandBuffer                             commandBuffer,
 853     uint32_t                                    vertexCount,
 854     uint32_t                                    instanceCount,
 855     uint32_t                                    firstVertex,
 856     uint32_t                                    firstInstance);
 857
 858 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed(
 859     VkCommandBuffer                             commandBuffer,
 860     uint32_t                                    indexCount,
 861     uint32_t                                    instanceCount,
 862     uint32_t                                    firstIndex,
 863     int32_t                                     vertexOffset,
 864     uint32_t                                    firstInstance);
 865
 866 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect(
 867     VkCommandBuffer                             commandBuffer,
 868     VkBuffer                                    buffer,
 869     VkDeviceSize                                offset,
 870     uint32_t                                    drawCount,
 871     uint32_t                                    stride);
 872
 873 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect(
 874     VkCommandBuffer                             commandBuffer,
 875     VkBuffer                                    buffer,
 876     VkDeviceSize                                offset,
 877     uint32_t                                    drawCount,
 878     uint32_t                                    stride);
 879
 880 static VKAPI_ATTR void VKAPI_CALL CmdDispatch(
 881     VkCommandBuffer                             commandBuffer,
 882     uint32_t                                    groupCountX,
 883     uint32_t                                    groupCountY,
 884     uint32_t                                    groupCountZ);
 885
 886 static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect(
 887     VkCommandBuffer                             commandBuffer,
 888     VkBuffer                                    buffer,
 889     VkDeviceSize                                offset);
 890
 891 static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer(
 892     VkCommandBuffer                             commandBuffer,
 893     VkBuffer                                    srcBuffer,
 894     VkBuffer                                    dstBuffer,
 895     uint32_t                                    regionCount,
 896     const VkBufferCopy*                         pRegions);
 897
 898 static VKAPI_ATTR void VKAPI_CALL CmdCopyImage(
 899     VkCommandBuffer                             commandBuffer,
 900     VkImage                                     srcImage,
 901     VkImageLayout                               srcImageLayout,
 902     VkImage                                     dstImage,
 903     VkImageLayout                               dstImageLayout,
 904     uint32_t                                    regionCount,
 905     const VkImageCopy*                          pRegions);
 906
 907 static VKAPI_ATTR void VKAPI_CALL CmdBlitImage(
 908     VkCommandBuffer                             commandBuffer,
 909     VkImage                                     srcImage,
 910     VkImageLayout                               srcImageLayout,
 911     VkImage                                     dstImage,
 912     VkImageLayout                               dstImageLayout,
 913     uint32_t                                    regionCount,
 914     const VkImageBlit*                          pRegions,
 915     VkFilter                                    filter);
 916
 917 static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage(
 918     VkCommandBuffer                             commandBuffer,
 919     VkBuffer                                    srcBuffer,
 920     VkImage                                     dstImage,
 921     VkImageLayout                               dstImageLayout,
 922     uint32_t                                    regionCount,
 923     const VkBufferImageCopy*                    pRegions);
 924
 925 static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer(
 926     VkCommandBuffer                             commandBuffer,
 927     VkImage                                     srcImage,
 928     VkImageLayout                               srcImageLayout,
 929     VkBuffer                                    dstBuffer,
 930     uint32_t                                    regionCount,
 931     const VkBufferImageCopy*                    pRegions);
 932
 933 static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer(
 934     VkCommandBuffer                             commandBuffer,
 935     VkBuffer                                    dstBuffer,
 936     VkDeviceSize                                dstOffset,
 937     VkDeviceSize                                dataSize,
 938     const void*                                 pData);
 939
 940 static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer(
 941     VkCommandBuffer                             commandBuffer,
 942     VkBuffer                                    dstBuffer,
 943     VkDeviceSize                                dstOffset,
 944     VkDeviceSize                                size,
 945     uint32_t                                    data);
 946
 947 static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage(
 948     VkCommandBuffer                             commandBuffer,
 949     VkImage                                     image,
 950     VkImageLayout                               imageLayout,
 951     const VkClearColorValue*                    pColor,
 952     uint32_t                                    rangeCount,
 953     const VkImageSubresourceRange*              pRanges);
 954
 955 static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage(
 956     VkCommandBuffer                             commandBuffer,
 957     VkImage                                     image,
 958     VkImageLayout                               imageLayout,
 959     const VkClearDepthStencilValue*             pDepthStencil,
 960     uint32_t                                    rangeCount,
 961     const VkImageSubresourceRange*              pRanges);
 962
 963 static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments(
 964     VkCommandBuffer                             commandBuffer,
 965     uint32_t                                    attachmentCount,
 966     const VkClearAttachment*                    pAttachments,
 967     uint32_t                                    rectCount,
 968     const VkClearRect*                          pRects);
 969
 970 static VKAPI_ATTR void VKAPI_CALL CmdResolveImage(
 971     VkCommandBuffer                             commandBuffer,
 972     VkImage                                     srcImage,
 973     VkImageLayout                               srcImageLayout,
 974     VkImage                                     dstImage,
 975     VkImageLayout                               dstImageLayout,
 976     uint32_t                                    regionCount,
 977     const VkImageResolve*                       pRegions);
 978
 979 static VKAPI_ATTR void VKAPI_CALL CmdSetEvent(
 980     VkCommandBuffer                             commandBuffer,
 981     VkEvent                                     event,
 982     VkPipelineStageFlags                        stageMask);
 983
 984 static VKAPI_ATTR void VKAPI_CALL CmdResetEvent(
 985     VkCommandBuffer                             commandBuffer,
 986     VkEvent                                     event,
 987     VkPipelineStageFlags                        stageMask);
 988
 989 static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents(
 990     VkCommandBuffer                             commandBuffer,
 991     uint32_t                                    eventCount,
 992     const VkEvent*                              pEvents,
 993     VkPipelineStageFlags                        srcStageMask,
 994     VkPipelineStageFlags                        dstStageMask,
 995     uint32_t                                    memoryBarrierCount,
 996     const VkMemoryBarrier*                      pMemoryBarriers,
 997     uint32_t                                    bufferMemoryBarrierCount,
 998     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
 999     uint32_t                                    imageMemoryBarrierCount,
1000     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
1001
1002 static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier(
1003     VkCommandBuffer                             commandBuffer,
1004     VkPipelineStageFlags                        srcStageMask,
1005     VkPipelineStageFlags                        dstStageMask,
1006     VkDependencyFlags                           dependencyFlags,
1007     uint32_t                                    memoryBarrierCount,
1008     const VkMemoryBarrier*                      pMemoryBarriers,
1009     uint32_t                                    bufferMemoryBarrierCount,
1010     const VkBufferMemoryBarrier*                pBufferMemoryBarriers,
1011     uint32_t                                    imageMemoryBarrierCount,
1012     const VkImageMemoryBarrier*                 pImageMemoryBarriers);
1013
1014 static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery(
1015     VkCommandBuffer                             commandBuffer,
1016     VkQueryPool                                 queryPool,
1017     uint32_t                                    query,
1018     VkQueryControlFlags                         flags);
1019
1020 static VKAPI_ATTR void VKAPI_CALL CmdEndQuery(
1021     VkCommandBuffer                             commandBuffer,
1022     VkQueryPool                                 queryPool,
1023     uint32_t                                    query);
1024
1025 static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool(
1026     VkCommandBuffer                             commandBuffer,
1027     VkQueryPool                                 queryPool,
1028     uint32_t                                    firstQuery,
1029     uint32_t                                    queryCount);
1030
1031 static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp(
1032     VkCommandBuffer                             commandBuffer,
1033     VkPipelineStageFlagBits                     pipelineStage,
1034     VkQueryPool                                 queryPool,
1035     uint32_t                                    query);
1036
1037 static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults(
1038     VkCommandBuffer                             commandBuffer,
1039     VkQueryPool                                 queryPool,
1040     uint32_t                                    firstQuery,
1041     uint32_t                                    queryCount,
1042     VkBuffer                                    dstBuffer,
1043     VkDeviceSize                                dstOffset,
1044     VkDeviceSize                                stride,
1045     VkQueryResultFlags                          flags);
1046
1047 static VKAPI_ATTR void VKAPI_CALL CmdPushConstants(
1048     VkCommandBuffer                             commandBuffer,
1049     VkPipelineLayout                            layout,
1050     VkShaderStageFlags                          stageFlags,
1051     uint32_t                                    offset,
1052     uint32_t                                    size,
1053     const void*                                 pValues);
1054
1055 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass(
1056     VkCommandBuffer                             commandBuffer,
1057     const VkRenderPassBeginInfo*                pRenderPassBegin,
1058     VkSubpassContents                           contents);
1059
1060 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass(
1061     VkCommandBuffer                             commandBuffer,
1062     VkSubpassContents                           contents);
1063
1064 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass(
1065     VkCommandBuffer                             commandBuffer);
1066
1067 static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands(
1068     VkCommandBuffer                             commandBuffer,
1069     uint32_t                                    commandBufferCount,
1070     const VkCommandBuffer*                      pCommandBuffers);
1071
1072
1073 static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion(
1074     uint32_t*                                   pApiVersion);
1075
1076 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2(
1077     VkDevice                                    device,
1078     uint32_t                                    bindInfoCount,
1079     const VkBindBufferMemoryInfo*               pBindInfos);
1080
1081 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2(
1082     VkDevice                                    device,
1083     uint32_t                                    bindInfoCount,
1084     const VkBindImageMemoryInfo*                pBindInfos);
1085
1086 static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures(
1087     VkDevice                                    device,
1088     uint32_t                                    heapIndex,
1089     uint32_t                                    localDeviceIndex,
1090     uint32_t                                    remoteDeviceIndex,
1091     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
1092
1093 static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask(
1094     VkCommandBuffer                             commandBuffer,
1095     uint32_t                                    deviceMask);
1096
1097 static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase(
1098     VkCommandBuffer                             commandBuffer,
1099     uint32_t                                    baseGroupX,
1100     uint32_t                                    baseGroupY,
1101     uint32_t                                    baseGroupZ,
1102     uint32_t                                    groupCountX,
1103     uint32_t                                    groupCountY,
1104     uint32_t                                    groupCountZ);
1105
1106 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups(
1107     VkInstance                                  instance,
1108     uint32_t*                                   pPhysicalDeviceGroupCount,
1109     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
1110
1111 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2(
1112     VkDevice                                    device,
1113     const VkImageMemoryRequirementsInfo2*       pInfo,
1114     VkMemoryRequirements2*                      pMemoryRequirements);
1115
1116 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2(
1117     VkDevice                                    device,
1118     const VkBufferMemoryRequirementsInfo2*      pInfo,
1119     VkMemoryRequirements2*                      pMemoryRequirements);
1120
1121 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2(
1122     VkDevice                                    device,
1123     const VkImageSparseMemoryRequirementsInfo2* pInfo,
1124     uint32_t*                                   pSparseMemoryRequirementCount,
1125     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
1126
1127 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2(
1128     VkPhysicalDevice                            physicalDevice,
1129     VkPhysicalDeviceFeatures2*                  pFeatures);
1130
1131 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2(
1132     VkPhysicalDevice                            physicalDevice,
1133     VkPhysicalDeviceProperties2*                pProperties);
1134
1135 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2(
1136     VkPhysicalDevice                            physicalDevice,
1137     VkFormat                                    format,
1138     VkFormatProperties2*                        pFormatProperties);
1139
1140 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2(
1141     VkPhysicalDevice                            physicalDevice,
1142     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
1143     VkImageFormatProperties2*                   pImageFormatProperties);
1144
1145 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2(
1146     VkPhysicalDevice                            physicalDevice,
1147     uint32_t*                                   pQueueFamilyPropertyCount,
1148     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
1149
1150 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2(
1151     VkPhysicalDevice                            physicalDevice,
1152     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
1153
1154 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2(
1155     VkPhysicalDevice                            physicalDevice,
1156     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
1157     uint32_t*                                   pPropertyCount,
1158     VkSparseImageFormatProperties2*             pProperties);
1159
1160 static VKAPI_ATTR void VKAPI_CALL TrimCommandPool(
1161     VkDevice                                    device,
1162     VkCommandPool                               commandPool,
1163     VkCommandPoolTrimFlags                      flags);
1164
1165 static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2(
1166     VkDevice                                    device,
1167     const VkDeviceQueueInfo2*                   pQueueInfo,
1168     VkQueue*                                    pQueue);
1169
1170 static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion(
1171     VkDevice                                    device,
1172     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
1173     const VkAllocationCallbacks*                pAllocator,
1174     VkSamplerYcbcrConversion*                   pYcbcrConversion);
1175
1176 static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion(
1177     VkDevice                                    device,
1178     VkSamplerYcbcrConversion                    ycbcrConversion,
1179     const VkAllocationCallbacks*                pAllocator);
1180
1181 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate(
1182     VkDevice                                    device,
1183     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1184     const VkAllocationCallbacks*                pAllocator,
1185     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
1186
1187 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate(
1188     VkDevice                                    device,
1189     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1190     const VkAllocationCallbacks*                pAllocator);
1191
1192 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate(
1193     VkDevice                                    device,
1194     VkDescriptorSet                             descriptorSet,
1195     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1196     const void*                                 pData);
1197
1198 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties(
1199     VkPhysicalDevice                            physicalDevice,
1200     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
1201     VkExternalBufferProperties*                 pExternalBufferProperties);
1202
1203 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties(
1204     VkPhysicalDevice                            physicalDevice,
1205     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
1206     VkExternalFenceProperties*                  pExternalFenceProperties);
1207
1208 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties(
1209     VkPhysicalDevice                            physicalDevice,
1210     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1211     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
1212
1213 static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport(
1214     VkDevice                                    device,
1215     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
1216     VkDescriptorSetLayoutSupport*               pSupport);
1217
1218
1219 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount(
1220     VkCommandBuffer                             commandBuffer,
1221     VkBuffer                                    buffer,
1222     VkDeviceSize                                offset,
1223     VkBuffer                                    countBuffer,
1224     VkDeviceSize                                countBufferOffset,
1225     uint32_t                                    maxDrawCount,
1226     uint32_t                                    stride);
1227
1228 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount(
1229     VkCommandBuffer                             commandBuffer,
1230     VkBuffer                                    buffer,
1231     VkDeviceSize                                offset,
1232     VkBuffer                                    countBuffer,
1233     VkDeviceSize                                countBufferOffset,
1234     uint32_t                                    maxDrawCount,
1235     uint32_t                                    stride);
1236
1237 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2(
1238     VkDevice                                    device,
1239     const VkRenderPassCreateInfo2*              pCreateInfo,
1240     const VkAllocationCallbacks*                pAllocator,
1241     VkRenderPass*                               pRenderPass);
1242
1243 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2(
1244     VkCommandBuffer                             commandBuffer,
1245     const VkRenderPassBeginInfo*                pRenderPassBegin,
1246     const VkSubpassBeginInfo*                   pSubpassBeginInfo);
1247
1248 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2(
1249     VkCommandBuffer                             commandBuffer,
1250     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
1251     const VkSubpassEndInfo*                     pSubpassEndInfo);
1252
1253 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2(
1254     VkCommandBuffer                             commandBuffer,
1255     const VkSubpassEndInfo*                     pSubpassEndInfo);
1256
1257 static VKAPI_ATTR void VKAPI_CALL ResetQueryPool(
1258     VkDevice                                    device,
1259     VkQueryPool                                 queryPool,
1260     uint32_t                                    firstQuery,
1261     uint32_t                                    queryCount);
1262
1263 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue(
1264     VkDevice                                    device,
1265     VkSemaphore                                 semaphore,
1266     uint64_t*                                   pValue);
1267
1268 static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores(
1269     VkDevice                                    device,
1270     const VkSemaphoreWaitInfo*                  pWaitInfo,
1271     uint64_t                                    timeout);
1272
1273 static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore(
1274     VkDevice                                    device,
1275     const VkSemaphoreSignalInfo*                pSignalInfo);
1276
1277 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress(
1278     VkDevice                                    device,
1279     const VkBufferDeviceAddressInfo*            pInfo);
1280
1281 static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress(
1282     VkDevice                                    device,
1283     const VkBufferDeviceAddressInfo*            pInfo);
1284
1285 static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress(
1286     VkDevice                                    device,
1287     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
1288
1289
1290 static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR(
1291     VkInstance                                  instance,
1292     VkSurfaceKHR                                surface,
1293     const VkAllocationCallbacks*                pAllocator);
1294
1295 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR(
1296     VkPhysicalDevice                            physicalDevice,
1297     uint32_t                                    queueFamilyIndex,
1298     VkSurfaceKHR                                surface,
1299     VkBool32*                                   pSupported);
1300
1301 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR(
1302     VkPhysicalDevice                            physicalDevice,
1303     VkSurfaceKHR                                surface,
1304     VkSurfaceCapabilitiesKHR*                   pSurfaceCapabilities);
1305
1306 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR(
1307     VkPhysicalDevice                            physicalDevice,
1308     VkSurfaceKHR                                surface,
1309     uint32_t*                                   pSurfaceFormatCount,
1310     VkSurfaceFormatKHR*                         pSurfaceFormats);
1311
1312 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR(
1313     VkPhysicalDevice                            physicalDevice,
1314     VkSurfaceKHR                                surface,
1315     uint32_t*                                   pPresentModeCount,
1316     VkPresentModeKHR*                           pPresentModes);
1317
1318
1319 static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR(
1320     VkDevice                                    device,
1321     const VkSwapchainCreateInfoKHR*             pCreateInfo,
1322     const VkAllocationCallbacks*                pAllocator,
1323     VkSwapchainKHR*                             pSwapchain);
1324
1325 static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR(
1326     VkDevice                                    device,
1327     VkSwapchainKHR                              swapchain,
1328     const VkAllocationCallbacks*                pAllocator);
1329
1330 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR(
1331     VkDevice                                    device,
1332     VkSwapchainKHR                              swapchain,
1333     uint32_t*                                   pSwapchainImageCount,
1334     VkImage*                                    pSwapchainImages);
1335
1336 static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR(
1337     VkDevice                                    device,
1338     VkSwapchainKHR                              swapchain,
1339     uint64_t                                    timeout,
1340     VkSemaphore                                 semaphore,
1341     VkFence                                     fence,
1342     uint32_t*                                   pImageIndex);
1343
1344 static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR(
1345     VkQueue                                     queue,
1346     const VkPresentInfoKHR*                     pPresentInfo);
1347
1348 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR(
1349     VkDevice                                    device,
1350     VkDeviceGroupPresentCapabilitiesKHR*        pDeviceGroupPresentCapabilities);
1351
1352 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR(
1353     VkDevice                                    device,
1354     VkSurfaceKHR                                surface,
1355     VkDeviceGroupPresentModeFlagsKHR*           pModes);
1356
1357 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR(
1358     VkPhysicalDevice                            physicalDevice,
1359     VkSurfaceKHR                                surface,
1360     uint32_t*                                   pRectCount,
1361     VkRect2D*                                   pRects);
1362
1363 static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR(
1364     VkDevice                                    device,
1365     const VkAcquireNextImageInfoKHR*            pAcquireInfo,
1366     uint32_t*                                   pImageIndex);
1367
1368
1369 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR(
1370     VkPhysicalDevice                            physicalDevice,
1371     uint32_t*                                   pPropertyCount,
1372     VkDisplayPropertiesKHR*                     pProperties);
1373
1374 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR(
1375     VkPhysicalDevice                            physicalDevice,
1376     uint32_t*                                   pPropertyCount,
1377     VkDisplayPlanePropertiesKHR*                pProperties);
1378
1379 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR(
1380     VkPhysicalDevice                            physicalDevice,
1381     uint32_t                                    planeIndex,
1382     uint32_t*                                   pDisplayCount,
1383     VkDisplayKHR*                               pDisplays);
1384
1385 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR(
1386     VkPhysicalDevice                            physicalDevice,
1387     VkDisplayKHR                                display,
1388     uint32_t*                                   pPropertyCount,
1389     VkDisplayModePropertiesKHR*                 pProperties);
1390
1391 static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR(
1392     VkPhysicalDevice                            physicalDevice,
1393     VkDisplayKHR                                display,
1394     const VkDisplayModeCreateInfoKHR*           pCreateInfo,
1395     const VkAllocationCallbacks*                pAllocator,
1396     VkDisplayModeKHR*                           pMode);
1397
1398 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR(
1399     VkPhysicalDevice                            physicalDevice,
1400     VkDisplayModeKHR                            mode,
1401     uint32_t                                    planeIndex,
1402     VkDisplayPlaneCapabilitiesKHR*              pCapabilities);
1403
1404 static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR(
1405     VkInstance                                  instance,
1406     const VkDisplaySurfaceCreateInfoKHR*        pCreateInfo,
1407     const VkAllocationCallbacks*                pAllocator,
1408     VkSurfaceKHR*                               pSurface);
1409
1410
1411 static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR(
1412     VkDevice                                    device,
1413     uint32_t                                    swapchainCount,
1414     const VkSwapchainCreateInfoKHR*             pCreateInfos,
1415     const VkAllocationCallbacks*                pAllocator,
1416     VkSwapchainKHR*                             pSwapchains);
1417
1418 #ifdef VK_USE_PLATFORM_XLIB_KHR
1419
1420 static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR(
1421     VkInstance                                  instance,
1422     const VkXlibSurfaceCreateInfoKHR*           pCreateInfo,
1423     const VkAllocationCallbacks*                pAllocator,
1424     VkSurfaceKHR*                               pSurface);
1425
1426 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR(
1427     VkPhysicalDevice                            physicalDevice,
1428     uint32_t                                    queueFamilyIndex,
1429     Display*                                    dpy,
1430     VisualID                                    visualID);
1431 #endif /* VK_USE_PLATFORM_XLIB_KHR */
1432
1433 #ifdef VK_USE_PLATFORM_XCB_KHR
1434
1435 static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR(
1436     VkInstance                                  instance,
1437     const VkXcbSurfaceCreateInfoKHR*            pCreateInfo,
1438     const VkAllocationCallbacks*                pAllocator,
1439     VkSurfaceKHR*                               pSurface);
1440
1441 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR(
1442     VkPhysicalDevice                            physicalDevice,
1443     uint32_t                                    queueFamilyIndex,
1444     xcb_connection_t*                           connection,
1445     xcb_visualid_t                              visual_id);
1446 #endif /* VK_USE_PLATFORM_XCB_KHR */
1447
1448 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
1449
1450 static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR(
1451     VkInstance                                  instance,
1452     const VkWaylandSurfaceCreateInfoKHR*        pCreateInfo,
1453     const VkAllocationCallbacks*                pAllocator,
1454     VkSurfaceKHR*                               pSurface);
1455
1456 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR(
1457     VkPhysicalDevice                            physicalDevice,
1458     uint32_t                                    queueFamilyIndex,
1459     struct wl_display*                          display);
1460 #endif /* VK_USE_PLATFORM_WAYLAND_KHR */
1461
1462 #ifdef VK_USE_PLATFORM_ANDROID_KHR
1463
1464 static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR(
1465     VkInstance                                  instance,
1466     const VkAndroidSurfaceCreateInfoKHR*        pCreateInfo,
1467     const VkAllocationCallbacks*                pAllocator,
1468     VkSurfaceKHR*                               pSurface);
1469 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
1470
1471 #ifdef VK_USE_PLATFORM_WIN32_KHR
1472
1473 static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR(
1474     VkInstance                                  instance,
1475     const VkWin32SurfaceCreateInfoKHR*          pCreateInfo,
1476     const VkAllocationCallbacks*                pAllocator,
1477     VkSurfaceKHR*                               pSurface);
1478
1479 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR(
1480     VkPhysicalDevice                            physicalDevice,
1481     uint32_t                                    queueFamilyIndex);
1482 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1483
1484
1485
1486
1487 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR(
1488     VkPhysicalDevice                            physicalDevice,
1489     VkPhysicalDeviceFeatures2*                  pFeatures);
1490
1491 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR(
1492     VkPhysicalDevice                            physicalDevice,
1493     VkPhysicalDeviceProperties2*                pProperties);
1494
1495 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR(
1496     VkPhysicalDevice                            physicalDevice,
1497     VkFormat                                    format,
1498     VkFormatProperties2*                        pFormatProperties);
1499
1500 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR(
1501     VkPhysicalDevice                            physicalDevice,
1502     const VkPhysicalDeviceImageFormatInfo2*     pImageFormatInfo,
1503     VkImageFormatProperties2*                   pImageFormatProperties);
1504
1505 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR(
1506     VkPhysicalDevice                            physicalDevice,
1507     uint32_t*                                   pQueueFamilyPropertyCount,
1508     VkQueueFamilyProperties2*                   pQueueFamilyProperties);
1509
1510 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR(
1511     VkPhysicalDevice                            physicalDevice,
1512     VkPhysicalDeviceMemoryProperties2*          pMemoryProperties);
1513
1514 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR(
1515     VkPhysicalDevice                            physicalDevice,
1516     const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo,
1517     uint32_t*                                   pPropertyCount,
1518     VkSparseImageFormatProperties2*             pProperties);
1519
1520
1521 static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR(
1522     VkDevice                                    device,
1523     uint32_t                                    heapIndex,
1524     uint32_t                                    localDeviceIndex,
1525     uint32_t                                    remoteDeviceIndex,
1526     VkPeerMemoryFeatureFlags*                   pPeerMemoryFeatures);
1527
1528 static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR(
1529     VkCommandBuffer                             commandBuffer,
1530     uint32_t                                    deviceMask);
1531
1532 static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR(
1533     VkCommandBuffer                             commandBuffer,
1534     uint32_t                                    baseGroupX,
1535     uint32_t                                    baseGroupY,
1536     uint32_t                                    baseGroupZ,
1537     uint32_t                                    groupCountX,
1538     uint32_t                                    groupCountY,
1539     uint32_t                                    groupCountZ);
1540
1541
1542
1543 static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR(
1544     VkDevice                                    device,
1545     VkCommandPool                               commandPool,
1546     VkCommandPoolTrimFlags                      flags);
1547
1548
1549 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR(
1550     VkInstance                                  instance,
1551     uint32_t*                                   pPhysicalDeviceGroupCount,
1552     VkPhysicalDeviceGroupProperties*            pPhysicalDeviceGroupProperties);
1553
1554
1555 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR(
1556     VkPhysicalDevice                            physicalDevice,
1557     const VkPhysicalDeviceExternalBufferInfo*   pExternalBufferInfo,
1558     VkExternalBufferProperties*                 pExternalBufferProperties);
1559
1560
1561 #ifdef VK_USE_PLATFORM_WIN32_KHR
1562
1563 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR(
1564     VkDevice                                    device,
1565     const VkMemoryGetWin32HandleInfoKHR*        pGetWin32HandleInfo,
1566     HANDLE*                                     pHandle);
1567
1568 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR(
1569     VkDevice                                    device,
1570     VkExternalMemoryHandleTypeFlagBits          handleType,
1571     HANDLE                                      handle,
1572     VkMemoryWin32HandlePropertiesKHR*           pMemoryWin32HandleProperties);
1573 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1574
1575
1576 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR(
1577     VkDevice                                    device,
1578     const VkMemoryGetFdInfoKHR*                 pGetFdInfo,
1579     int*                                        pFd);
1580
1581 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR(
1582     VkDevice                                    device,
1583     VkExternalMemoryHandleTypeFlagBits          handleType,
1584     int                                         fd,
1585     VkMemoryFdPropertiesKHR*                    pMemoryFdProperties);
1586
1587 #ifdef VK_USE_PLATFORM_WIN32_KHR
1588 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1589
1590
1591 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR(
1592     VkPhysicalDevice                            physicalDevice,
1593     const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo,
1594     VkExternalSemaphoreProperties*              pExternalSemaphoreProperties);
1595
1596
1597 #ifdef VK_USE_PLATFORM_WIN32_KHR
1598
1599 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR(
1600     VkDevice                                    device,
1601     const VkImportSemaphoreWin32HandleInfoKHR*  pImportSemaphoreWin32HandleInfo);
1602
1603 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR(
1604     VkDevice                                    device,
1605     const VkSemaphoreGetWin32HandleInfoKHR*     pGetWin32HandleInfo,
1606     HANDLE*                                     pHandle);
1607 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1608
1609
1610 static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR(
1611     VkDevice                                    device,
1612     const VkImportSemaphoreFdInfoKHR*           pImportSemaphoreFdInfo);
1613
1614 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR(
1615     VkDevice                                    device,
1616     const VkSemaphoreGetFdInfoKHR*              pGetFdInfo,
1617     int*                                        pFd);
1618
1619
1620 static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR(
1621     VkCommandBuffer                             commandBuffer,
1622     VkPipelineBindPoint                         pipelineBindPoint,
1623     VkPipelineLayout                            layout,
1624     uint32_t                                    set,
1625     uint32_t                                    descriptorWriteCount,
1626     const VkWriteDescriptorSet*                 pDescriptorWrites);
1627
1628 static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR(
1629     VkCommandBuffer                             commandBuffer,
1630     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1631     VkPipelineLayout                            layout,
1632     uint32_t                                    set,
1633     const void*                                 pData);
1634
1635
1636
1637
1638
1639 static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR(
1640     VkDevice                                    device,
1641     const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo,
1642     const VkAllocationCallbacks*                pAllocator,
1643     VkDescriptorUpdateTemplate*                 pDescriptorUpdateTemplate);
1644
1645 static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR(
1646     VkDevice                                    device,
1647     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1648     const VkAllocationCallbacks*                pAllocator);
1649
1650 static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR(
1651     VkDevice                                    device,
1652     VkDescriptorSet                             descriptorSet,
1653     VkDescriptorUpdateTemplate                  descriptorUpdateTemplate,
1654     const void*                                 pData);
1655
1656
1657
1658 static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR(
1659     VkDevice                                    device,
1660     const VkRenderPassCreateInfo2*              pCreateInfo,
1661     const VkAllocationCallbacks*                pAllocator,
1662     VkRenderPass*                               pRenderPass);
1663
1664 static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(
1665     VkCommandBuffer                             commandBuffer,
1666     const VkRenderPassBeginInfo*                pRenderPassBegin,
1667     const VkSubpassBeginInfo*                   pSubpassBeginInfo);
1668
1669 static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(
1670     VkCommandBuffer                             commandBuffer,
1671     const VkSubpassBeginInfo*                   pSubpassBeginInfo,
1672     const VkSubpassEndInfo*                     pSubpassEndInfo);
1673
1674 static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(
1675     VkCommandBuffer                             commandBuffer,
1676     const VkSubpassEndInfo*                     pSubpassEndInfo);
1677
1678
1679 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR(
1680     VkDevice                                    device,
1681     VkSwapchainKHR                              swapchain);
1682
1683
1684 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR(
1685     VkPhysicalDevice                            physicalDevice,
1686     const VkPhysicalDeviceExternalFenceInfo*    pExternalFenceInfo,
1687     VkExternalFenceProperties*                  pExternalFenceProperties);
1688
1689
1690 #ifdef VK_USE_PLATFORM_WIN32_KHR
1691
1692 static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR(
1693     VkDevice                                    device,
1694     const VkImportFenceWin32HandleInfoKHR*      pImportFenceWin32HandleInfo);
1695
1696 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR(
1697     VkDevice                                    device,
1698     const VkFenceGetWin32HandleInfoKHR*         pGetWin32HandleInfo,
1699     HANDLE*                                     pHandle);
1700 #endif /* VK_USE_PLATFORM_WIN32_KHR */
1701
1702
1703 static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR(
1704     VkDevice                                    device,
1705     const VkImportFenceFdInfoKHR*               pImportFenceFdInfo);
1706
1707 static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR(
1708     VkDevice                                    device,
1709     const VkFenceGetFdInfoKHR*                  pGetFdInfo,
1710     int*                                        pFd);
1711
1712
1713 static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR(
1714     VkPhysicalDevice                            physicalDevice,
1715     uint32_t                                    queueFamilyIndex,
1716     uint32_t*                                   pCounterCount,
1717     VkPerformanceCounterKHR*                    pCounters,
1718     VkPerformanceCounterDescriptionKHR*         pCounterDescriptions);
1719
1720 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR(
1721     VkPhysicalDevice                            physicalDevice,
1722     const VkQueryPoolPerformanceCreateInfoKHR*  pPerformanceQueryCreateInfo,
1723     uint32_t*                                   pNumPasses);
1724
1725 static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR(
1726     VkDevice                                    device,
1727     const VkAcquireProfilingLockInfoKHR*        pInfo);
1728
1729 static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR(
1730     VkDevice                                    device);
1731
1732
1733
1734 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR(
1735     VkPhysicalDevice                            physicalDevice,
1736     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
1737     VkSurfaceCapabilities2KHR*                  pSurfaceCapabilities);
1738
1739 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR(
1740     VkPhysicalDevice                            physicalDevice,
1741     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
1742     uint32_t*                                   pSurfaceFormatCount,
1743     VkSurfaceFormat2KHR*                        pSurfaceFormats);
1744
1745
1746
1747 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR(
1748     VkPhysicalDevice                            physicalDevice,
1749     uint32_t*                                   pPropertyCount,
1750     VkDisplayProperties2KHR*                    pProperties);
1751
1752 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR(
1753     VkPhysicalDevice                            physicalDevice,
1754     uint32_t*                                   pPropertyCount,
1755     VkDisplayPlaneProperties2KHR*               pProperties);
1756
1757 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR(
1758     VkPhysicalDevice                            physicalDevice,
1759     VkDisplayKHR                                display,
1760     uint32_t*                                   pPropertyCount,
1761     VkDisplayModeProperties2KHR*                pProperties);
1762
1763 static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR(
1764     VkPhysicalDevice                            physicalDevice,
1765     const VkDisplayPlaneInfo2KHR*               pDisplayPlaneInfo,
1766     VkDisplayPlaneCapabilities2KHR*             pCapabilities);
1767
1768
1769
1770
1771
1772 static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR(
1773     VkDevice                                    device,
1774     const VkImageMemoryRequirementsInfo2*       pInfo,
1775     VkMemoryRequirements2*                      pMemoryRequirements);
1776
1777 static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR(
1778     VkDevice                                    device,
1779     const VkBufferMemoryRequirementsInfo2*      pInfo,
1780     VkMemoryRequirements2*                      pMemoryRequirements);
1781
1782 static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR(
1783     VkDevice                                    device,
1784     const VkImageSparseMemoryRequirementsInfo2* pInfo,
1785     uint32_t*                                   pSparseMemoryRequirementCount,
1786     VkSparseImageMemoryRequirements2*           pSparseMemoryRequirements);
1787
1788
1789
1790 static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR(
1791     VkDevice                                    device,
1792     const VkSamplerYcbcrConversionCreateInfo*   pCreateInfo,
1793     const VkAllocationCallbacks*                pAllocator,
1794     VkSamplerYcbcrConversion*                   pYcbcrConversion);
1795
1796 static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR(
1797     VkDevice                                    device,
1798     VkSamplerYcbcrConversion                    ycbcrConversion,
1799     const VkAllocationCallbacks*                pAllocator);
1800
1801
1802 static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR(
1803     VkDevice                                    device,
1804     uint32_t                                    bindInfoCount,
1805     const VkBindBufferMemoryInfo*               pBindInfos);
1806
1807 static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR(
1808     VkDevice                                    device,
1809     uint32_t                                    bindInfoCount,
1810     const VkBindImageMemoryInfo*                pBindInfos);
1811
1812 #ifdef VK_ENABLE_BETA_EXTENSIONS
1813 #endif /* VK_ENABLE_BETA_EXTENSIONS */
1814
1815
1816 static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR(
1817     VkDevice                                    device,
1818     const VkDescriptorSetLayoutCreateInfo*      pCreateInfo,
1819     VkDescriptorSetLayoutSupport*               pSupport);
1820
1821
1822 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR(
1823     VkCommandBuffer                             commandBuffer,
1824     VkBuffer                                    buffer,
1825     VkDeviceSize                                offset,
1826     VkBuffer                                    countBuffer,
1827     VkDeviceSize                                countBufferOffset,
1828     uint32_t                                    maxDrawCount,
1829     uint32_t                                    stride);
1830
1831 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR(
1832     VkCommandBuffer                             commandBuffer,
1833     VkBuffer                                    buffer,
1834     VkDeviceSize                                offset,
1835     VkBuffer                                    countBuffer,
1836     VkDeviceSize                                countBufferOffset,
1837     uint32_t                                    maxDrawCount,
1838     uint32_t                                    stride);
1839
1840
1841
1842
1843
1844
1845
1846
1847
1848
1849 static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR(
1850     VkDevice                                    device,
1851     VkSemaphore                                 semaphore,
1852     uint64_t*                                   pValue);
1853
1854 static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR(
1855     VkDevice                                    device,
1856     const VkSemaphoreWaitInfo*                  pWaitInfo,
1857     uint64_t                                    timeout);
1858
1859 static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(
1860     VkDevice                                    device,
1861     const VkSemaphoreSignalInfo*                pSignalInfo);
1862
1863
1864
1865
1866 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR(
1867     VkPhysicalDevice                            physicalDevice,
1868     uint32_t*                                   pFragmentShadingRateCount,
1869     VkPhysicalDeviceFragmentShadingRateKHR*     pFragmentShadingRates);
1870
1871 static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR(
1872     VkCommandBuffer                             commandBuffer,
1873     const VkExtent2D*                           pFragmentSize,
1874     const VkFragmentShadingRateCombinerOpKHR    combinerOps[2]);
1875
1876
1877
1878
1879
1880
1881 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(
1882     VkDevice                                    device,
1883     const VkBufferDeviceAddressInfo*            pInfo);
1884
1885 static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(
1886     VkDevice                                    device,
1887     const VkBufferDeviceAddressInfo*            pInfo);
1888
1889 static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(
1890     VkDevice                                    device,
1891     const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo);
1892
1893 #ifdef VK_ENABLE_BETA_EXTENSIONS
1894
1895 static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR(
1896     VkDevice                                    device,
1897     const VkAllocationCallbacks*                pAllocator,
1898     VkDeferredOperationKHR*                     pDeferredOperation);
1899
1900 static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR(
1901     VkDevice                                    device,
1902     VkDeferredOperationKHR                      operation,
1903     const VkAllocationCallbacks*                pAllocator);
1904
1905 static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR(
1906     VkDevice                                    device,
1907     VkDeferredOperationKHR                      operation);
1908
1909 static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR(
1910     VkDevice                                    device,
1911     VkDeferredOperationKHR                      operation);
1912
1913 static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR(
1914     VkDevice                                    device,
1915     VkDeferredOperationKHR                      operation);
1916 #endif /* VK_ENABLE_BETA_EXTENSIONS */
1917
1918
1919 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR(
1920     VkDevice                                    device,
1921     const VkPipelineInfoKHR*                    pPipelineInfo,
1922     uint32_t*                                   pExecutableCount,
1923     VkPipelineExecutablePropertiesKHR*          pProperties);
1924
1925 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR(
1926     VkDevice                                    device,
1927     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
1928     uint32_t*                                   pStatisticCount,
1929     VkPipelineExecutableStatisticKHR*           pStatistics);
1930
1931 static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR(
1932     VkDevice                                    device,
1933     const VkPipelineExecutableInfoKHR*          pExecutableInfo,
1934     uint32_t*                                   pInternalRepresentationCount,
1935     VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations);
1936
1937 #ifdef VK_ENABLE_BETA_EXTENSIONS
1938 #endif /* VK_ENABLE_BETA_EXTENSIONS */
1939
1940
1941
1942 static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR(
1943     VkCommandBuffer                             commandBuffer,
1944     const VkCopyBufferInfo2KHR*                 pCopyBufferInfo);
1945
1946 static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR(
1947     VkCommandBuffer                             commandBuffer,
1948     const VkCopyImageInfo2KHR*                  pCopyImageInfo);
1949
1950 static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR(
1951     VkCommandBuffer                             commandBuffer,
1952     const VkCopyBufferToImageInfo2KHR*          pCopyBufferToImageInfo);
1953
1954 static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR(
1955     VkCommandBuffer                             commandBuffer,
1956     const VkCopyImageToBufferInfo2KHR*          pCopyImageToBufferInfo);
1957
1958 static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR(
1959     VkCommandBuffer                             commandBuffer,
1960     const VkBlitImageInfo2KHR*                  pBlitImageInfo);
1961
1962 static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR(
1963     VkCommandBuffer                             commandBuffer,
1964     const VkResolveImageInfo2KHR*               pResolveImageInfo);
1965
1966
1967 static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT(
1968     VkInstance                                  instance,
1969     const VkDebugReportCallbackCreateInfoEXT*   pCreateInfo,
1970     const VkAllocationCallbacks*                pAllocator,
1971     VkDebugReportCallbackEXT*                   pCallback);
1972
1973 static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT(
1974     VkInstance                                  instance,
1975     VkDebugReportCallbackEXT                    callback,
1976     const VkAllocationCallbacks*                pAllocator);
1977
1978 static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT(
1979     VkInstance                                  instance,
1980     VkDebugReportFlagsEXT                       flags,
1981     VkDebugReportObjectTypeEXT                  objectType,
1982     uint64_t                                    object,
1983     size_t                                      location,
1984     int32_t                                     messageCode,
1985     const char*                                 pLayerPrefix,
1986     const char*                                 pMessage);
1987
1988
1989
1990
1991
1992
1993
1994
1995 static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT(
1996     VkDevice                                    device,
1997     const VkDebugMarkerObjectTagInfoEXT*        pTagInfo);
1998
1999 static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT(
2000     VkDevice                                    device,
2001     const VkDebugMarkerObjectNameInfoEXT*       pNameInfo);
2002
2003 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT(
2004     VkCommandBuffer                             commandBuffer,
2005     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
2006
2007 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT(
2008     VkCommandBuffer                             commandBuffer);
2009
2010 static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT(
2011     VkCommandBuffer                             commandBuffer,
2012     const VkDebugMarkerMarkerInfoEXT*           pMarkerInfo);
2013
2014
2015
2016
2017 static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT(
2018     VkCommandBuffer                             commandBuffer,
2019     uint32_t                                    firstBinding,
2020     uint32_t                                    bindingCount,
2021     const VkBuffer*                             pBuffers,
2022     const VkDeviceSize*                         pOffsets,
2023     const VkDeviceSize*                         pSizes);
2024
2025 static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT(
2026     VkCommandBuffer                             commandBuffer,
2027     uint32_t                                    firstCounterBuffer,
2028     uint32_t                                    counterBufferCount,
2029     const VkBuffer*                             pCounterBuffers,
2030     const VkDeviceSize*                         pCounterBufferOffsets);
2031
2032 static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT(
2033     VkCommandBuffer                             commandBuffer,
2034     uint32_t                                    firstCounterBuffer,
2035     uint32_t                                    counterBufferCount,
2036     const VkBuffer*                             pCounterBuffers,
2037     const VkDeviceSize*                         pCounterBufferOffsets);
2038
2039 static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT(
2040     VkCommandBuffer                             commandBuffer,
2041     VkQueryPool                                 queryPool,
2042     uint32_t                                    query,
2043     VkQueryControlFlags                         flags,
2044     uint32_t                                    index);
2045
2046 static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT(
2047     VkCommandBuffer                             commandBuffer,
2048     VkQueryPool                                 queryPool,
2049     uint32_t                                    query,
2050     uint32_t                                    index);
2051
2052 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT(
2053     VkCommandBuffer                             commandBuffer,
2054     uint32_t                                    instanceCount,
2055     uint32_t                                    firstInstance,
2056     VkBuffer                                    counterBuffer,
2057     VkDeviceSize                                counterBufferOffset,
2058     uint32_t                                    counterOffset,
2059     uint32_t                                    vertexStride);
2060
2061
2062 static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX(
2063     VkDevice                                    device,
2064     const VkImageViewHandleInfoNVX*             pInfo);
2065
2066 static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX(
2067     VkDevice                                    device,
2068     VkImageView                                 imageView,
2069     VkImageViewAddressPropertiesNVX*            pProperties);
2070
2071
2072 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD(
2073     VkCommandBuffer                             commandBuffer,
2074     VkBuffer                                    buffer,
2075     VkDeviceSize                                offset,
2076     VkBuffer                                    countBuffer,
2077     VkDeviceSize                                countBufferOffset,
2078     uint32_t                                    maxDrawCount,
2079     uint32_t                                    stride);
2080
2081 static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD(
2082     VkCommandBuffer                             commandBuffer,
2083     VkBuffer                                    buffer,
2084     VkDeviceSize                                offset,
2085     VkBuffer                                    countBuffer,
2086     VkDeviceSize                                countBufferOffset,
2087     uint32_t                                    maxDrawCount,
2088     uint32_t                                    stride);
2089
2090
2091
2092
2093
2094
2095 static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD(
2096     VkDevice                                    device,
2097     VkPipeline                                  pipeline,
2098     VkShaderStageFlagBits                       shaderStage,
2099     VkShaderInfoTypeAMD                         infoType,
2100     size_t*                                     pInfoSize,
2101     void*                                       pInfo);
2102
2103
2104 #ifdef VK_USE_PLATFORM_GGP
2105
2106 static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP(
2107     VkInstance                                  instance,
2108     const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo,
2109     const VkAllocationCallbacks*                pAllocator,
2110     VkSurfaceKHR*                               pSurface);
2111 #endif /* VK_USE_PLATFORM_GGP */
2112
2113
2114
2115
2116 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV(
2117     VkPhysicalDevice                            physicalDevice,
2118     VkFormat                                    format,
2119     VkImageType                                 type,
2120     VkImageTiling                               tiling,
2121     VkImageUsageFlags                           usage,
2122     VkImageCreateFlags                          flags,
2123     VkExternalMemoryHandleTypeFlagsNV           externalHandleType,
2124     VkExternalImageFormatPropertiesNV*          pExternalImageFormatProperties);
2125
2126
2127 #ifdef VK_USE_PLATFORM_WIN32_KHR
2128
2129 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV(
2130     VkDevice                                    device,
2131     VkDeviceMemory                              memory,
2132     VkExternalMemoryHandleTypeFlagsNV           handleType,
2133     HANDLE*                                     pHandle);
2134 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2135
2136 #ifdef VK_USE_PLATFORM_WIN32_KHR
2137 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2138
2139
2140 #ifdef VK_USE_PLATFORM_VI_NN
2141
2142 static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN(
2143     VkInstance                                  instance,
2144     const VkViSurfaceCreateInfoNN*              pCreateInfo,
2145     const VkAllocationCallbacks*                pAllocator,
2146     VkSurfaceKHR*                               pSurface);
2147 #endif /* VK_USE_PLATFORM_VI_NN */
2148
2149
2150
2151
2152
2153
2154 static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT(
2155     VkCommandBuffer                             commandBuffer,
2156     const VkConditionalRenderingBeginInfoEXT*   pConditionalRenderingBegin);
2157
2158 static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT(
2159     VkCommandBuffer                             commandBuffer);
2160
2161
2162 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV(
2163     VkCommandBuffer                             commandBuffer,
2164     uint32_t                                    firstViewport,
2165     uint32_t                                    viewportCount,
2166     const VkViewportWScalingNV*                 pViewportWScalings);
2167
2168
2169 static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT(
2170     VkPhysicalDevice                            physicalDevice,
2171     VkDisplayKHR                                display);
2172
2173 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
2174
2175 static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT(
2176     VkPhysicalDevice                            physicalDevice,
2177     Display*                                    dpy,
2178     VkDisplayKHR                                display);
2179
2180 static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT(
2181     VkPhysicalDevice                            physicalDevice,
2182     Display*                                    dpy,
2183     RROutput                                    rrOutput,
2184     VkDisplayKHR*                               pDisplay);
2185 #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */
2186
2187
2188 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT(
2189     VkPhysicalDevice                            physicalDevice,
2190     VkSurfaceKHR                                surface,
2191     VkSurfaceCapabilities2EXT*                  pSurfaceCapabilities);
2192
2193
2194 static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT(
2195     VkDevice                                    device,
2196     VkDisplayKHR                                display,
2197     const VkDisplayPowerInfoEXT*                pDisplayPowerInfo);
2198
2199 static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT(
2200     VkDevice                                    device,
2201     const VkDeviceEventInfoEXT*                 pDeviceEventInfo,
2202     const VkAllocationCallbacks*                pAllocator,
2203     VkFence*                                    pFence);
2204
2205 static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT(
2206     VkDevice                                    device,
2207     VkDisplayKHR                                display,
2208     const VkDisplayEventInfoEXT*                pDisplayEventInfo,
2209     const VkAllocationCallbacks*                pAllocator,
2210     VkFence*                                    pFence);
2211
2212 static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT(
2213     VkDevice                                    device,
2214     VkSwapchainKHR                              swapchain,
2215     VkSurfaceCounterFlagBitsEXT                 counter,
2216     uint64_t*                                   pCounterValue);
2217
2218
2219 static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE(
2220     VkDevice                                    device,
2221     VkSwapchainKHR                              swapchain,
2222     VkRefreshCycleDurationGOOGLE*               pDisplayTimingProperties);
2223
2224 static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE(
2225     VkDevice                                    device,
2226     VkSwapchainKHR                              swapchain,
2227     uint32_t*                                   pPresentationTimingCount,
2228     VkPastPresentationTimingGOOGLE*             pPresentationTimings);
2229
2230
2231
2232
2233
2234
2235
2236 static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT(
2237     VkCommandBuffer                             commandBuffer,
2238     uint32_t                                    firstDiscardRectangle,
2239     uint32_t                                    discardRectangleCount,
2240     const VkRect2D*                             pDiscardRectangles);
2241
2242
2243
2244
2245
2246 static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT(
2247     VkDevice                                    device,
2248     uint32_t                                    swapchainCount,
2249     const VkSwapchainKHR*                       pSwapchains,
2250     const VkHdrMetadataEXT*                     pMetadata);
2251
2252 #ifdef VK_USE_PLATFORM_IOS_MVK
2253
2254 static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK(
2255     VkInstance                                  instance,
2256     const VkIOSSurfaceCreateInfoMVK*            pCreateInfo,
2257     const VkAllocationCallbacks*                pAllocator,
2258     VkSurfaceKHR*                               pSurface);
2259 #endif /* VK_USE_PLATFORM_IOS_MVK */
2260
2261 #ifdef VK_USE_PLATFORM_MACOS_MVK
2262
2263 static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK(
2264     VkInstance                                  instance,
2265     const VkMacOSSurfaceCreateInfoMVK*          pCreateInfo,
2266     const VkAllocationCallbacks*                pAllocator,
2267     VkSurfaceKHR*                               pSurface);
2268 #endif /* VK_USE_PLATFORM_MACOS_MVK */
2269
2270
2271
2272
2273 static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT(
2274     VkDevice                                    device,
2275     const VkDebugUtilsObjectNameInfoEXT*        pNameInfo);
2276
2277 static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT(
2278     VkDevice                                    device,
2279     const VkDebugUtilsObjectTagInfoEXT*         pTagInfo);
2280
2281 static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT(
2282     VkQueue                                     queue,
2283     const VkDebugUtilsLabelEXT*                 pLabelInfo);
2284
2285 static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT(
2286     VkQueue                                     queue);
2287
2288 static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT(
2289     VkQueue                                     queue,
2290     const VkDebugUtilsLabelEXT*                 pLabelInfo);
2291
2292 static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT(
2293     VkCommandBuffer                             commandBuffer,
2294     const VkDebugUtilsLabelEXT*                 pLabelInfo);
2295
2296 static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT(
2297     VkCommandBuffer                             commandBuffer);
2298
2299 static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT(
2300     VkCommandBuffer                             commandBuffer,
2301     const VkDebugUtilsLabelEXT*                 pLabelInfo);
2302
2303 static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT(
2304     VkInstance                                  instance,
2305     const VkDebugUtilsMessengerCreateInfoEXT*   pCreateInfo,
2306     const VkAllocationCallbacks*                pAllocator,
2307     VkDebugUtilsMessengerEXT*                   pMessenger);
2308
2309 static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT(
2310     VkInstance                                  instance,
2311     VkDebugUtilsMessengerEXT                    messenger,
2312     const VkAllocationCallbacks*                pAllocator);
2313
2314 static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT(
2315     VkInstance                                  instance,
2316     VkDebugUtilsMessageSeverityFlagBitsEXT      messageSeverity,
2317     VkDebugUtilsMessageTypeFlagsEXT             messageTypes,
2318     const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData);
2319
2320 #ifdef VK_USE_PLATFORM_ANDROID_KHR
2321
2322 static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID(
2323     VkDevice                                    device,
2324     const struct AHardwareBuffer*               buffer,
2325     VkAndroidHardwareBufferPropertiesANDROID*   pProperties);
2326
2327 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID(
2328     VkDevice                                    device,
2329     const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo,
2330     struct AHardwareBuffer**                    pBuffer);
2331 #endif /* VK_USE_PLATFORM_ANDROID_KHR */
2332
2333
2334
2335
2336
2337
2338
2339
2340 static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT(
2341     VkCommandBuffer                             commandBuffer,
2342     const VkSampleLocationsInfoEXT*             pSampleLocationsInfo);
2343
2344 static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT(
2345     VkPhysicalDevice                            physicalDevice,
2346     VkSampleCountFlagBits                       samples,
2347     VkMultisamplePropertiesEXT*                 pMultisampleProperties);
2348
2349
2350
2351
2352
2353
2354
2355
2356 static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT(
2357     VkDevice                                    device,
2358     VkImage                                     image,
2359     VkImageDrmFormatModifierPropertiesEXT*      pProperties);
2360
2361
2362 static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT(
2363     VkDevice                                    device,
2364     const VkValidationCacheCreateInfoEXT*       pCreateInfo,
2365     const VkAllocationCallbacks*                pAllocator,
2366     VkValidationCacheEXT*                       pValidationCache);
2367
2368 static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT(
2369     VkDevice                                    device,
2370     VkValidationCacheEXT                        validationCache,
2371     const VkAllocationCallbacks*                pAllocator);
2372
2373 static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT(
2374     VkDevice                                    device,
2375     VkValidationCacheEXT                        dstCache,
2376     uint32_t                                    srcCacheCount,
2377     const VkValidationCacheEXT*                 pSrcCaches);
2378
2379 static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT(
2380     VkDevice                                    device,
2381     VkValidationCacheEXT                        validationCache,
2382     size_t*                                     pDataSize,
2383     void*                                       pData);
2384
2385
2386
2387
2388 static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV(
2389     VkCommandBuffer                             commandBuffer,
2390     VkImageView                                 imageView,
2391     VkImageLayout                               imageLayout);
2392
2393 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV(
2394     VkCommandBuffer                             commandBuffer,
2395     uint32_t                                    firstViewport,
2396     uint32_t                                    viewportCount,
2397     const VkShadingRatePaletteNV*               pShadingRatePalettes);
2398
2399 static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV(
2400     VkCommandBuffer                             commandBuffer,
2401     VkCoarseSampleOrderTypeNV                   sampleOrderType,
2402     uint32_t                                    customSampleOrderCount,
2403     const VkCoarseSampleOrderCustomNV*          pCustomSampleOrders);
2404
2405
2406 static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV(
2407     VkDevice                                    device,
2408     const VkAccelerationStructureCreateInfoNV*  pCreateInfo,
2409     const VkAllocationCallbacks*                pAllocator,
2410     VkAccelerationStructureNV*                  pAccelerationStructure);
2411
2412 static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR(
2413     VkDevice                                    device,
2414     VkAccelerationStructureKHR                  accelerationStructure,
2415     const VkAllocationCallbacks*                pAllocator);
2416
2417 static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV(
2418     VkDevice                                    device,
2419     VkAccelerationStructureKHR                  accelerationStructure,
2420     const VkAllocationCallbacks*                pAllocator);
2421
2422 static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV(
2423     VkDevice                                    device,
2424     const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo,
2425     VkMemoryRequirements2KHR*                   pMemoryRequirements);
2426
2427 static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryKHR(
2428     VkDevice                                    device,
2429     uint32_t                                    bindInfoCount,
2430     const VkBindAccelerationStructureMemoryInfoKHR* pBindInfos);
2431
2432 static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV(
2433     VkDevice                                    device,
2434     uint32_t                                    bindInfoCount,
2435     const VkBindAccelerationStructureMemoryInfoKHR* pBindInfos);
2436
2437 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV(
2438     VkCommandBuffer                             commandBuffer,
2439     const VkAccelerationStructureInfoNV*        pInfo,
2440     VkBuffer                                    instanceData,
2441     VkDeviceSize                                instanceOffset,
2442     VkBool32                                    update,
2443     VkAccelerationStructureKHR                  dst,
2444     VkAccelerationStructureKHR                  src,
2445     VkBuffer                                    scratch,
2446     VkDeviceSize                                scratchOffset);
2447
2448 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV(
2449     VkCommandBuffer                             commandBuffer,
2450     VkAccelerationStructureKHR                  dst,
2451     VkAccelerationStructureKHR                  src,
2452     VkCopyAccelerationStructureModeKHR          mode);
2453
2454 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV(
2455     VkCommandBuffer                             commandBuffer,
2456     VkBuffer                                    raygenShaderBindingTableBuffer,
2457     VkDeviceSize                                raygenShaderBindingOffset,
2458     VkBuffer                                    missShaderBindingTableBuffer,
2459     VkDeviceSize                                missShaderBindingOffset,
2460     VkDeviceSize                                missShaderBindingStride,
2461     VkBuffer                                    hitShaderBindingTableBuffer,
2462     VkDeviceSize                                hitShaderBindingOffset,
2463     VkDeviceSize                                hitShaderBindingStride,
2464     VkBuffer                                    callableShaderBindingTableBuffer,
2465     VkDeviceSize                                callableShaderBindingOffset,
2466     VkDeviceSize                                callableShaderBindingStride,
2467     uint32_t                                    width,
2468     uint32_t                                    height,
2469     uint32_t                                    depth);
2470
2471 static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV(
2472     VkDevice                                    device,
2473     VkPipelineCache                             pipelineCache,
2474     uint32_t                                    createInfoCount,
2475     const VkRayTracingPipelineCreateInfoNV*     pCreateInfos,
2476     const VkAllocationCallbacks*                pAllocator,
2477     VkPipeline*                                 pPipelines);
2478
2479 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR(
2480     VkDevice                                    device,
2481     VkPipeline                                  pipeline,
2482     uint32_t                                    firstGroup,
2483     uint32_t                                    groupCount,
2484     size_t                                      dataSize,
2485     void*                                       pData);
2486
2487 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV(
2488     VkDevice                                    device,
2489     VkPipeline                                  pipeline,
2490     uint32_t                                    firstGroup,
2491     uint32_t                                    groupCount,
2492     size_t                                      dataSize,
2493     void*                                       pData);
2494
2495 static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV(
2496     VkDevice                                    device,
2497     VkAccelerationStructureKHR                  accelerationStructure,
2498     size_t                                      dataSize,
2499     void*                                       pData);
2500
2501 static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR(
2502     VkCommandBuffer                             commandBuffer,
2503     uint32_t                                    accelerationStructureCount,
2504     const VkAccelerationStructureKHR*           pAccelerationStructures,
2505     VkQueryType                                 queryType,
2506     VkQueryPool                                 queryPool,
2507     uint32_t                                    firstQuery);
2508
2509 static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV(
2510     VkCommandBuffer                             commandBuffer,
2511     uint32_t                                    accelerationStructureCount,
2512     const VkAccelerationStructureKHR*           pAccelerationStructures,
2513     VkQueryType                                 queryType,
2514     VkQueryPool                                 queryPool,
2515     uint32_t                                    firstQuery);
2516
2517 static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV(
2518     VkDevice                                    device,
2519     VkPipeline                                  pipeline,
2520     uint32_t                                    shader);
2521
2522
2523
2524
2525
2526
2527 static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT(
2528     VkDevice                                    device,
2529     VkExternalMemoryHandleTypeFlagBits          handleType,
2530     const void*                                 pHostPointer,
2531     VkMemoryHostPointerPropertiesEXT*           pMemoryHostPointerProperties);
2532
2533
2534 static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD(
2535     VkCommandBuffer                             commandBuffer,
2536     VkPipelineStageFlagBits                     pipelineStage,
2537     VkBuffer                                    dstBuffer,
2538     VkDeviceSize                                dstOffset,
2539     uint32_t                                    marker);
2540
2541
2542
2543 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT(
2544     VkPhysicalDevice                            physicalDevice,
2545     uint32_t*                                   pTimeDomainCount,
2546     VkTimeDomainEXT*                            pTimeDomains);
2547
2548 static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT(
2549     VkDevice                                    device,
2550     uint32_t                                    timestampCount,
2551     const VkCalibratedTimestampInfoEXT*         pTimestampInfos,
2552     uint64_t*                                   pTimestamps,
2553     uint64_t*                                   pMaxDeviation);
2554
2555
2556
2557
2558 #ifdef VK_USE_PLATFORM_GGP
2559 #endif /* VK_USE_PLATFORM_GGP */
2560
2561
2562
2563
2564
2565 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV(
2566     VkCommandBuffer                             commandBuffer,
2567     uint32_t                                    taskCount,
2568     uint32_t                                    firstTask);
2569
2570 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV(
2571     VkCommandBuffer                             commandBuffer,
2572     VkBuffer                                    buffer,
2573     VkDeviceSize                                offset,
2574     uint32_t                                    drawCount,
2575     uint32_t                                    stride);
2576
2577 static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV(
2578     VkCommandBuffer                             commandBuffer,
2579     VkBuffer                                    buffer,
2580     VkDeviceSize                                offset,
2581     VkBuffer                                    countBuffer,
2582     VkDeviceSize                                countBufferOffset,
2583     uint32_t                                    maxDrawCount,
2584     uint32_t                                    stride);
2585
2586
2587
2588
2589 static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV(
2590     VkCommandBuffer                             commandBuffer,
2591     uint32_t                                    firstExclusiveScissor,
2592     uint32_t                                    exclusiveScissorCount,
2593     const VkRect2D*                             pExclusiveScissors);
2594
2595
2596 static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV(
2597     VkCommandBuffer                             commandBuffer,
2598     const void*                                 pCheckpointMarker);
2599
2600 static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV(
2601     VkQueue                                     queue,
2602     uint32_t*                                   pCheckpointDataCount,
2603     VkCheckpointDataNV*                         pCheckpointData);
2604
2605
2606
2607 static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL(
2608     VkDevice                                    device,
2609     const VkInitializePerformanceApiInfoINTEL*  pInitializeInfo);
2610
2611 static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL(
2612     VkDevice                                    device);
2613
2614 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL(
2615     VkCommandBuffer                             commandBuffer,
2616     const VkPerformanceMarkerInfoINTEL*         pMarkerInfo);
2617
2618 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL(
2619     VkCommandBuffer                             commandBuffer,
2620     const VkPerformanceStreamMarkerInfoINTEL*   pMarkerInfo);
2621
2622 static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL(
2623     VkCommandBuffer                             commandBuffer,
2624     const VkPerformanceOverrideInfoINTEL*       pOverrideInfo);
2625
2626 static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL(
2627     VkDevice                                    device,
2628     const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo,
2629     VkPerformanceConfigurationINTEL*            pConfiguration);
2630
2631 static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL(
2632     VkDevice                                    device,
2633     VkPerformanceConfigurationINTEL             configuration);
2634
2635 static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL(
2636     VkQueue                                     queue,
2637     VkPerformanceConfigurationINTEL             configuration);
2638
2639 static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL(
2640     VkDevice                                    device,
2641     VkPerformanceParameterTypeINTEL             parameter,
2642     VkPerformanceValueINTEL*                    pValue);
2643
2644
2645
2646 static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD(
2647     VkDevice                                    device,
2648     VkSwapchainKHR                              swapChain,
2649     VkBool32                                    localDimmingEnable);
2650
2651 #ifdef VK_USE_PLATFORM_FUCHSIA
2652
2653 static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA(
2654     VkInstance                                  instance,
2655     const VkImagePipeSurfaceCreateInfoFUCHSIA*  pCreateInfo,
2656     const VkAllocationCallbacks*                pAllocator,
2657     VkSurfaceKHR*                               pSurface);
2658 #endif /* VK_USE_PLATFORM_FUCHSIA */
2659
2660 #ifdef VK_USE_PLATFORM_METAL_EXT
2661
2662 static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT(
2663     VkInstance                                  instance,
2664     const VkMetalSurfaceCreateInfoEXT*          pCreateInfo,
2665     const VkAllocationCallbacks*                pAllocator,
2666     VkSurfaceKHR*                               pSurface);
2667 #endif /* VK_USE_PLATFORM_METAL_EXT */
2668
2669
2670
2671
2672
2673
2674
2675
2676
2677
2678
2679
2680
2681 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT(
2682     VkDevice                                    device,
2683     const VkBufferDeviceAddressInfo*            pInfo);
2684
2685
2686 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(
2687     VkPhysicalDevice                            physicalDevice,
2688     uint32_t*                                   pToolCount,
2689     VkPhysicalDeviceToolPropertiesEXT*          pToolProperties);
2690
2691
2692
2693
2694 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV(
2695     VkPhysicalDevice                            physicalDevice,
2696     uint32_t*                                   pPropertyCount,
2697     VkCooperativeMatrixPropertiesNV*            pProperties);
2698
2699
2700 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV(
2701     VkPhysicalDevice                            physicalDevice,
2702     uint32_t*                                   pCombinationCount,
2703     VkFramebufferMixedSamplesCombinationNV*     pCombinations);
2704
2705
2706
2707 #ifdef VK_USE_PLATFORM_WIN32_KHR
2708
2709 static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT(
2710     VkPhysicalDevice                            physicalDevice,
2711     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
2712     uint32_t*                                   pPresentModeCount,
2713     VkPresentModeKHR*                           pPresentModes);
2714
2715 static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT(
2716     VkDevice                                    device,
2717     VkSwapchainKHR                              swapchain);
2718
2719 static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT(
2720     VkDevice                                    device,
2721     VkSwapchainKHR                              swapchain);
2722
2723 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT(
2724     VkDevice                                    device,
2725     const VkPhysicalDeviceSurfaceInfo2KHR*      pSurfaceInfo,
2726     VkDeviceGroupPresentModeFlagsKHR*           pModes);
2727 #endif /* VK_USE_PLATFORM_WIN32_KHR */
2728
2729
2730 static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT(
2731     VkInstance                                  instance,
2732     const VkHeadlessSurfaceCreateInfoEXT*       pCreateInfo,
2733     const VkAllocationCallbacks*                pAllocator,
2734     VkSurfaceKHR*                               pSurface);
2735
2736
2737 static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT(
2738     VkCommandBuffer                             commandBuffer,
2739     uint32_t                                    lineStippleFactor,
2740     uint16_t                                    lineStipplePattern);
2741
2742
2743
2744 static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT(
2745     VkDevice                                    device,
2746     VkQueryPool                                 queryPool,
2747     uint32_t                                    firstQuery,
2748     uint32_t                                    queryCount);
2749
2750
2751
2752 static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT(
2753     VkCommandBuffer                             commandBuffer,
2754     VkCullModeFlags                             cullMode);
2755
2756 static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT(
2757     VkCommandBuffer                             commandBuffer,
2758     VkFrontFace                                 frontFace);
2759
2760 static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT(
2761     VkCommandBuffer                             commandBuffer,
2762     VkPrimitiveTopology                         primitiveTopology);
2763
2764 static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT(
2765     VkCommandBuffer                             commandBuffer,
2766     uint32_t                                    viewportCount,
2767     const VkViewport*                           pViewports);
2768
2769 static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT(
2770     VkCommandBuffer                             commandBuffer,
2771     uint32_t                                    scissorCount,
2772     const VkRect2D*                             pScissors);
2773
2774 static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT(
2775     VkCommandBuffer                             commandBuffer,
2776     uint32_t                                    firstBinding,
2777     uint32_t                                    bindingCount,
2778     const VkBuffer*                             pBuffers,
2779     const VkDeviceSize*                         pOffsets,
2780     const VkDeviceSize*                         pSizes,
2781     const VkDeviceSize*                         pStrides);
2782
2783 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT(
2784     VkCommandBuffer                             commandBuffer,
2785     VkBool32                                    depthTestEnable);
2786
2787 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT(
2788     VkCommandBuffer                             commandBuffer,
2789     VkBool32                                    depthWriteEnable);
2790
2791 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT(
2792     VkCommandBuffer                             commandBuffer,
2793     VkCompareOp                                 depthCompareOp);
2794
2795 static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT(
2796     VkCommandBuffer                             commandBuffer,
2797     VkBool32                                    depthBoundsTestEnable);
2798
2799 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT(
2800     VkCommandBuffer                             commandBuffer,
2801     VkBool32                                    stencilTestEnable);
2802
2803 static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT(
2804     VkCommandBuffer                             commandBuffer,
2805     VkStencilFaceFlags                          faceMask,
2806     VkStencilOp                                 failOp,
2807     VkStencilOp                                 passOp,
2808     VkStencilOp                                 depthFailOp,
2809     VkCompareOp                                 compareOp);
2810
2811
2812
2813 static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV(
2814     VkDevice                                    device,
2815     const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo,
2816     VkMemoryRequirements2*                      pMemoryRequirements);
2817
2818 static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV(
2819     VkCommandBuffer                             commandBuffer,
2820     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
2821
2822 static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV(
2823     VkCommandBuffer                             commandBuffer,
2824     VkBool32                                    isPreprocessed,
2825     const VkGeneratedCommandsInfoNV*            pGeneratedCommandsInfo);
2826
2827 static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV(
2828     VkCommandBuffer                             commandBuffer,
2829     VkPipelineBindPoint                         pipelineBindPoint,
2830     VkPipeline                                  pipeline,
2831     uint32_t                                    groupIndex);
2832
2833 static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV(
2834     VkDevice                                    device,
2835     const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo,
2836     const VkAllocationCallbacks*                pAllocator,
2837     VkIndirectCommandsLayoutNV*                 pIndirectCommandsLayout);
2838
2839 static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV(
2840     VkDevice                                    device,
2841     VkIndirectCommandsLayoutNV                  indirectCommandsLayout,
2842     const VkAllocationCallbacks*                pAllocator);
2843
2844
2845
2846
2847
2848
2849
2850
2851 static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT(
2852     VkDevice                                    device,
2853     const VkPrivateDataSlotCreateInfoEXT*       pCreateInfo,
2854     const VkAllocationCallbacks*                pAllocator,
2855     VkPrivateDataSlotEXT*                       pPrivateDataSlot);
2856
2857 static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT(
2858     VkDevice                                    device,
2859     VkPrivateDataSlotEXT                        privateDataSlot,
2860     const VkAllocationCallbacks*                pAllocator);
2861
2862 static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT(
2863     VkDevice                                    device,
2864     VkObjectType                                objectType,
2865     uint64_t                                    objectHandle,
2866     VkPrivateDataSlotEXT                        privateDataSlot,
2867     uint64_t                                    data);
2868
2869 static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT(
2870     VkDevice                                    device,
2871     VkObjectType                                objectType,
2872     uint64_t                                    objectHandle,
2873     VkPrivateDataSlotEXT                        privateDataSlot,
2874     uint64_t*                                   pData);
2875
2876
2877
2878
2879
2880
2881
2882 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
2883
2884 static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT(
2885     VkInstance                                  instance,
2886     const VkDirectFBSurfaceCreateInfoEXT*       pCreateInfo,
2887     const VkAllocationCallbacks*                pAllocator,
2888     VkSurfaceKHR*                               pSurface);
2889
2890 static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT(
2891     VkPhysicalDevice                            physicalDevice,
2892     uint32_t                                    queueFamilyIndex,
2893     IDirectFB*                                  dfb);
2894 #endif /* VK_USE_PLATFORM_DIRECTFB_EXT */
2895
2896 #ifdef VK_ENABLE_BETA_EXTENSIONS
2897
2898 static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR(
2899     VkDevice                                    device,
2900     const VkAccelerationStructureCreateInfoKHR* pCreateInfo,
2901     const VkAllocationCallbacks*                pAllocator,
2902     VkAccelerationStructureKHR*                 pAccelerationStructure);
2903
2904 static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsKHR(
2905     VkDevice                                    device,
2906     const VkAccelerationStructureMemoryRequirementsInfoKHR* pInfo,
2907     VkMemoryRequirements2*                      pMemoryRequirements);
2908
2909 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureKHR(
2910     VkCommandBuffer                             commandBuffer,
2911     uint32_t                                    infoCount,
2912     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
2913     const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos);
2914
2915 static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureIndirectKHR(
2916     VkCommandBuffer                             commandBuffer,
2917     const VkAccelerationStructureBuildGeometryInfoKHR* pInfo,
2918     VkBuffer                                    indirectBuffer,
2919     VkDeviceSize                                indirectOffset,
2920     uint32_t                                    indirectStride);
2921
2922 static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructureKHR(
2923     VkDevice                                    device,
2924     uint32_t                                    infoCount,
2925     const VkAccelerationStructureBuildGeometryInfoKHR* pInfos,
2926     const VkAccelerationStructureBuildOffsetInfoKHR* const* ppOffsetInfos);
2927
2928 static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR(
2929     VkDevice                                    device,
2930     const VkCopyAccelerationStructureInfoKHR*   pInfo);
2931
2932 static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR(
2933     VkDevice                                    device,
2934     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
2935
2936 static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR(
2937     VkDevice                                    device,
2938     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
2939
2940 static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR(
2941     VkDevice                                    device,
2942     uint32_t                                    accelerationStructureCount,
2943     const VkAccelerationStructureKHR*           pAccelerationStructures,
2944     VkQueryType                                 queryType,
2945     size_t                                      dataSize,
2946     void*                                       pData,
2947     size_t                                      stride);
2948
2949 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR(
2950     VkCommandBuffer                             commandBuffer,
2951     const VkCopyAccelerationStructureInfoKHR*   pInfo);
2952
2953 static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR(
2954     VkCommandBuffer                             commandBuffer,
2955     const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo);
2956
2957 static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR(
2958     VkCommandBuffer                             commandBuffer,
2959     const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo);
2960
2961 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR(
2962     VkCommandBuffer                             commandBuffer,
2963     const VkStridedBufferRegionKHR*             pRaygenShaderBindingTable,
2964     const VkStridedBufferRegionKHR*             pMissShaderBindingTable,
2965     const VkStridedBufferRegionKHR*             pHitShaderBindingTable,
2966     const VkStridedBufferRegionKHR*             pCallableShaderBindingTable,
2967     uint32_t                                    width,
2968     uint32_t                                    height,
2969     uint32_t                                    depth);
2970
2971 static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR(
2972     VkDevice                                    device,
2973     VkPipelineCache                             pipelineCache,
2974     uint32_t                                    createInfoCount,
2975     const VkRayTracingPipelineCreateInfoKHR*    pCreateInfos,
2976     const VkAllocationCallbacks*                pAllocator,
2977     VkPipeline*                                 pPipelines);
2978
2979 static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR(
2980     VkDevice                                    device,
2981     const VkAccelerationStructureDeviceAddressInfoKHR* pInfo);
2982
2983 static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR(
2984     VkDevice                                    device,
2985     VkPipeline                                  pipeline,
2986     uint32_t                                    firstGroup,
2987     uint32_t                                    groupCount,
2988     size_t                                      dataSize,
2989     void*                                       pData);
2990
2991 static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR(
2992     VkCommandBuffer                             commandBuffer,
2993     const VkStridedBufferRegionKHR*             pRaygenShaderBindingTable,
2994     const VkStridedBufferRegionKHR*             pMissShaderBindingTable,
2995     const VkStridedBufferRegionKHR*             pHitShaderBindingTable,
2996     const VkStridedBufferRegionKHR*             pCallableShaderBindingTable,
2997     VkBuffer                                    buffer,
2998     VkDeviceSize                                offset);
2999
3000 static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR(
3001     VkDevice                                    device,
3002     const VkAccelerationStructureVersionKHR*    version);
3003 #endif /* VK_ENABLE_BETA_EXTENSIONS */
3004
3005 // Map of all APIs to be intercepted by this layer
3006 static const std::unordered_map<std::string, void*> name_to_funcptr_map = {
3007     {"vkCreateInstance", (void*)CreateInstance},
3008     {"vkDestroyInstance", (void*)DestroyInstance},
3009     {"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices},
3010     {"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures},
3011     {"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties},
3012     {"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties},
3013     {"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties},
3014     {"vkGetPhysicalDeviceQueueFamilyProperties", (void*)GetPhysicalDeviceQueueFamilyProperties},
3015     {"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties},
3016     {"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr},
3017     {"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr},
3018     {"vkCreateDevice", (void*)CreateDevice},
3019     {"vkDestroyDevice", (void*)DestroyDevice},
3020     {"vkEnumerateInstanceExtensionProperties", (void*)EnumerateInstanceExtensionProperties},
3021     {"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties},
3022     {"vkEnumerateInstanceLayerProperties", (void*)EnumerateInstanceLayerProperties},
3023     {"vkEnumerateDeviceLayerProperties", (void*)EnumerateDeviceLayerProperties},
3024     {"vkGetDeviceQueue", (void*)GetDeviceQueue},
3025     {"vkQueueSubmit", (void*)QueueSubmit},
3026     {"vkQueueWaitIdle", (void*)QueueWaitIdle},
3027     {"vkDeviceWaitIdle", (void*)DeviceWaitIdle},
3028     {"vkAllocateMemory", (void*)AllocateMemory},
3029     {"vkFreeMemory", (void*)FreeMemory},
3030     {"vkMapMemory", (void*)MapMemory},
3031     {"vkUnmapMemory", (void*)UnmapMemory},
3032     {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges},
3033     {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges},
3034     {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment},
3035     {"vkBindBufferMemory", (void*)BindBufferMemory},
3036     {"vkBindImageMemory", (void*)BindImageMemory},
3037     {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements},
3038     {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements},
3039     {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements},
3040     {"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties},
3041     {"vkQueueBindSparse", (void*)QueueBindSparse},
3042     {"vkCreateFence", (void*)CreateFence},
3043     {"vkDestroyFence", (void*)DestroyFence},
3044     {"vkResetFences", (void*)ResetFences},
3045     {"vkGetFenceStatus", (void*)GetFenceStatus},
3046     {"vkWaitForFences", (void*)WaitForFences},
3047     {"vkCreateSemaphore", (void*)CreateSemaphore},
3048     {"vkDestroySemaphore", (void*)DestroySemaphore},
3049     {"vkCreateEvent", (void*)CreateEvent},
3050     {"vkDestroyEvent", (void*)DestroyEvent},
3051     {"vkGetEventStatus", (void*)GetEventStatus},
3052     {"vkSetEvent", (void*)SetEvent},
3053     {"vkResetEvent", (void*)ResetEvent},
3054     {"vkCreateQueryPool", (void*)CreateQueryPool},
3055     {"vkDestroyQueryPool", (void*)DestroyQueryPool},
3056     {"vkGetQueryPoolResults", (void*)GetQueryPoolResults},
3057     {"vkCreateBuffer", (void*)CreateBuffer},
3058     {"vkDestroyBuffer", (void*)DestroyBuffer},
3059     {"vkCreateBufferView", (void*)CreateBufferView},
3060     {"vkDestroyBufferView", (void*)DestroyBufferView},
3061     {"vkCreateImage", (void*)CreateImage},
3062     {"vkDestroyImage", (void*)DestroyImage},
3063     {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout},
3064     {"vkCreateImageView", (void*)CreateImageView},
3065     {"vkDestroyImageView", (void*)DestroyImageView},
3066     {"vkCreateShaderModule", (void*)CreateShaderModule},
3067     {"vkDestroyShaderModule", (void*)DestroyShaderModule},
3068     {"vkCreatePipelineCache", (void*)CreatePipelineCache},
3069     {"vkDestroyPipelineCache", (void*)DestroyPipelineCache},
3070     {"vkGetPipelineCacheData", (void*)GetPipelineCacheData},
3071     {"vkMergePipelineCaches", (void*)MergePipelineCaches},
3072     {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines},
3073     {"vkCreateComputePipelines", (void*)CreateComputePipelines},
3074     {"vkDestroyPipeline", (void*)DestroyPipeline},
3075     {"vkCreatePipelineLayout", (void*)CreatePipelineLayout},
3076     {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout},
3077     {"vkCreateSampler", (void*)CreateSampler},
3078     {"vkDestroySampler", (void*)DestroySampler},
3079     {"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout},
3080     {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout},
3081     {"vkCreateDescriptorPool", (void*)CreateDescriptorPool},
3082     {"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool},
3083     {"vkResetDescriptorPool", (void*)ResetDescriptorPool},
3084     {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets},
3085     {"vkFreeDescriptorSets", (void*)FreeDescriptorSets},
3086     {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets},
3087     {"vkCreateFramebuffer", (void*)CreateFramebuffer},
3088     {"vkDestroyFramebuffer", (void*)DestroyFramebuffer},
3089     {"vkCreateRenderPass", (void*)CreateRenderPass},
3090     {"vkDestroyRenderPass", (void*)DestroyRenderPass},
3091     {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity},
3092     {"vkCreateCommandPool", (void*)CreateCommandPool},
3093     {"vkDestroyCommandPool", (void*)DestroyCommandPool},
3094     {"vkResetCommandPool", (void*)ResetCommandPool},
3095     {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers},
3096     {"vkFreeCommandBuffers", (void*)FreeCommandBuffers},
3097     {"vkBeginCommandBuffer", (void*)BeginCommandBuffer},
3098     {"vkEndCommandBuffer", (void*)EndCommandBuffer},
3099     {"vkResetCommandBuffer", (void*)ResetCommandBuffer},
3100     {"vkCmdBindPipeline", (void*)CmdBindPipeline},
3101     {"vkCmdSetViewport", (void*)CmdSetViewport},
3102     {"vkCmdSetScissor", (void*)CmdSetScissor},
3103     {"vkCmdSetLineWidth", (void*)CmdSetLineWidth},
3104     {"vkCmdSetDepthBias", (void*)CmdSetDepthBias},
3105     {"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants},
3106     {"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds},
3107     {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask},
3108     {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask},
3109     {"vkCmdSetStencilReference", (void*)CmdSetStencilReference},
3110     {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets},
3111     {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer},
3112     {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers},
3113     {"vkCmdDraw", (void*)CmdDraw},
3114     {"vkCmdDrawIndexed", (void*)CmdDrawIndexed},
3115     {"vkCmdDrawIndirect", (void*)CmdDrawIndirect},
3116     {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect},
3117     {"vkCmdDispatch", (void*)CmdDispatch},
3118     {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect},
3119     {"vkCmdCopyBuffer", (void*)CmdCopyBuffer},
3120     {"vkCmdCopyImage", (void*)CmdCopyImage},
3121     {"vkCmdBlitImage", (void*)CmdBlitImage},
3122     {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage},
3123     {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer},
3124     {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer},
3125     {"vkCmdFillBuffer", (void*)CmdFillBuffer},
3126     {"vkCmdClearColorImage", (void*)CmdClearColorImage},
3127     {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage},
3128     {"vkCmdClearAttachments", (void*)CmdClearAttachments},
3129     {"vkCmdResolveImage", (void*)CmdResolveImage},
3130     {"vkCmdSetEvent", (void*)CmdSetEvent},
3131     {"vkCmdResetEvent", (void*)CmdResetEvent},
3132     {"vkCmdWaitEvents", (void*)CmdWaitEvents},
3133     {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier},
3134     {"vkCmdBeginQuery", (void*)CmdBeginQuery},
3135     {"vkCmdEndQuery", (void*)CmdEndQuery},
3136     {"vkCmdResetQueryPool", (void*)CmdResetQueryPool},
3137     {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp},
3138     {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults},
3139     {"vkCmdPushConstants", (void*)CmdPushConstants},
3140     {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass},
3141     {"vkCmdNextSubpass", (void*)CmdNextSubpass},
3142     {"vkCmdEndRenderPass", (void*)CmdEndRenderPass},
3143     {"vkCmdExecuteCommands", (void*)CmdExecuteCommands},
3144     {"vkEnumerateInstanceVersion", (void*)EnumerateInstanceVersion},
3145     {"vkBindBufferMemory2", (void*)BindBufferMemory2},
3146     {"vkBindImageMemory2", (void*)BindImageMemory2},
3147     {"vkGetDeviceGroupPeerMemoryFeatures", (void*)GetDeviceGroupPeerMemoryFeatures},
3148     {"vkCmdSetDeviceMask", (void*)CmdSetDeviceMask},
3149     {"vkCmdDispatchBase", (void*)CmdDispatchBase},
3150     {"vkEnumeratePhysicalDeviceGroups", (void*)EnumeratePhysicalDeviceGroups},
3151     {"vkGetImageMemoryRequirements2", (void*)GetImageMemoryRequirements2},
3152     {"vkGetBufferMemoryRequirements2", (void*)GetBufferMemoryRequirements2},
3153     {"vkGetImageSparseMemoryRequirements2", (void*)GetImageSparseMemoryRequirements2},
3154     {"vkGetPhysicalDeviceFeatures2", (void*)GetPhysicalDeviceFeatures2},
3155     {"vkGetPhysicalDeviceProperties2", (void*)GetPhysicalDeviceProperties2},
3156     {"vkGetPhysicalDeviceFormatProperties2", (void*)GetPhysicalDeviceFormatProperties2},
3157     {"vkGetPhysicalDeviceImageFormatProperties2", (void*)GetPhysicalDeviceImageFormatProperties2},
3158     {"vkGetPhysicalDeviceQueueFamilyProperties2", (void*)GetPhysicalDeviceQueueFamilyProperties2},
3159     {"vkGetPhysicalDeviceMemoryProperties2", (void*)GetPhysicalDeviceMemoryProperties2},
3160     {"vkGetPhysicalDeviceSparseImageFormatProperties2", (void*)GetPhysicalDeviceSparseImageFormatProperties2},
3161     {"vkTrimCommandPool", (void*)TrimCommandPool},
3162     {"vkGetDeviceQueue2", (void*)GetDeviceQueue2},
3163     {"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion},
3164     {"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion},
3165     {"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate},
3166     {"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate},
3167     {"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate},
3168     {"vkGetPhysicalDeviceExternalBufferProperties", (void*)GetPhysicalDeviceExternalBufferProperties},
3169     {"vkGetPhysicalDeviceExternalFenceProperties", (void*)GetPhysicalDeviceExternalFenceProperties},
3170     {"vkGetPhysicalDeviceExternalSemaphoreProperties", (void*)GetPhysicalDeviceExternalSemaphoreProperties},
3171     {"vkGetDescriptorSetLayoutSupport", (void*)GetDescriptorSetLayoutSupport},
3172     {"vkCmdDrawIndirectCount", (void*)CmdDrawIndirectCount},
3173     {"vkCmdDrawIndexedIndirectCount", (void*)CmdDrawIndexedIndirectCount},
3174     {"vkCreateRenderPass2", (void*)CreateRenderPass2},
3175     {"vkCmdBeginRenderPass2", (void*)CmdBeginRenderPass2},
3176     {"vkCmdNextSubpass2", (void*)CmdNextSubpass2},
3177     {"vkCmdEndRenderPass2", (void*)CmdEndRenderPass2},
3178     {"vkResetQueryPool", (void*)ResetQueryPool},
3179     {"vkGetSemaphoreCounterValue", (void*)GetSemaphoreCounterValue},
3180     {"vkWaitSemaphores", (void*)WaitSemaphores},
3181     {"vkSignalSemaphore", (void*)SignalSemaphore},
3182     {"vkGetBufferDeviceAddress", (void*)GetBufferDeviceAddress},
3183     {"vkGetBufferOpaqueCaptureAddress", (void*)GetBufferOpaqueCaptureAddress},
3184     {"vkGetDeviceMemoryOpaqueCaptureAddress", (void*)GetDeviceMemoryOpaqueCaptureAddress},
3185     {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR},
3186     {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR},
3187     {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR},
3188     {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR},
3189     {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR},
3190     {"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR},
3191     {"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR},
3192     {"vkGetSwapchainImagesKHR", (void*)GetSwapchainImagesKHR},
3193     {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR},
3194     {"vkQueuePresentKHR", (void*)QueuePresentKHR},
3195     {"vkGetDeviceGroupPresentCapabilitiesKHR", (void*)GetDeviceGroupPresentCapabilitiesKHR},
3196     {"vkGetDeviceGroupSurfacePresentModesKHR", (void*)GetDeviceGroupSurfacePresentModesKHR},
3197     {"vkGetPhysicalDevicePresentRectanglesKHR", (void*)GetPhysicalDevicePresentRectanglesKHR},
3198     {"vkAcquireNextImage2KHR", (void*)AcquireNextImage2KHR},
3199     {"vkGetPhysicalDeviceDisplayPropertiesKHR", (void*)GetPhysicalDeviceDisplayPropertiesKHR},
3200     {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR},
3201     {"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR},
3202     {"vkGetDisplayModePropertiesKHR", (void*)GetDisplayModePropertiesKHR},
3203     {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR},
3204     {"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR},
3205     {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR},
3206     {"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR},
3207 #ifdef VK_USE_PLATFORM_XLIB_KHR
3208     {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR},
3209 #endif
3210 #ifdef VK_USE_PLATFORM_XLIB_KHR
3211     {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void*)GetPhysicalDeviceXlibPresentationSupportKHR},
3212 #endif
3213 #ifdef VK_USE_PLATFORM_XCB_KHR
3214     {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR},
3215 #endif
3216 #ifdef VK_USE_PLATFORM_XCB_KHR
3217     {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void*)GetPhysicalDeviceXcbPresentationSupportKHR},
3218 #endif
3219 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
3220     {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR},
3221 #endif
3222 #ifdef VK_USE_PLATFORM_WAYLAND_KHR
3223     {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void*)GetPhysicalDeviceWaylandPresentationSupportKHR},
3224 #endif
3225 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3226     {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR},
3227 #endif
3228 #ifdef VK_USE_PLATFORM_WIN32_KHR
3229     {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR},
3230 #endif
3231 #ifdef VK_USE_PLATFORM_WIN32_KHR
3232     {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR},
3233 #endif
3234     {"vkGetPhysicalDeviceFeatures2KHR", (void*)GetPhysicalDeviceFeatures2KHR},
3235     {"vkGetPhysicalDeviceProperties2KHR", (void*)GetPhysicalDeviceProperties2KHR},
3236     {"vkGetPhysicalDeviceFormatProperties2KHR", (void*)GetPhysicalDeviceFormatProperties2KHR},
3237     {"vkGetPhysicalDeviceImageFormatProperties2KHR", (void*)GetPhysicalDeviceImageFormatProperties2KHR},
3238     {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void*)GetPhysicalDeviceQueueFamilyProperties2KHR},
3239     {"vkGetPhysicalDeviceMemoryProperties2KHR", (void*)GetPhysicalDeviceMemoryProperties2KHR},
3240     {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR},
3241     {"vkGetDeviceGroupPeerMemoryFeaturesKHR", (void*)GetDeviceGroupPeerMemoryFeaturesKHR},
3242     {"vkCmdSetDeviceMaskKHR", (void*)CmdSetDeviceMaskKHR},
3243     {"vkCmdDispatchBaseKHR", (void*)CmdDispatchBaseKHR},
3244     {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR},
3245     {"vkEnumeratePhysicalDeviceGroupsKHR", (void*)EnumeratePhysicalDeviceGroupsKHR},
3246     {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR},
3247 #ifdef VK_USE_PLATFORM_WIN32_KHR
3248     {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR},
3249 #endif
3250 #ifdef VK_USE_PLATFORM_WIN32_KHR
3251     {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR},
3252 #endif
3253     {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR},
3254     {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR},
3255     {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR},
3256 #ifdef VK_USE_PLATFORM_WIN32_KHR
3257     {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR},
3258 #endif
3259 #ifdef VK_USE_PLATFORM_WIN32_KHR
3260     {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR},
3261 #endif
3262     {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR},
3263     {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR},
3264     {"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR},
3265     {"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR},
3266     {"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR},
3267     {"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR},
3268     {"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR},
3269     {"vkCreateRenderPass2KHR", (void*)CreateRenderPass2KHR},
3270     {"vkCmdBeginRenderPass2KHR", (void*)CmdBeginRenderPass2KHR},
3271     {"vkCmdNextSubpass2KHR", (void*)CmdNextSubpass2KHR},
3272     {"vkCmdEndRenderPass2KHR", (void*)CmdEndRenderPass2KHR},
3273     {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR},
3274     {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR},
3275 #ifdef VK_USE_PLATFORM_WIN32_KHR
3276     {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR},
3277 #endif
3278 #ifdef VK_USE_PLATFORM_WIN32_KHR
3279     {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR},
3280 #endif
3281     {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR},
3282     {"vkGetFenceFdKHR", (void*)GetFenceFdKHR},
3283     {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR},
3284     {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", (void*)GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR},
3285     {"vkAcquireProfilingLockKHR", (void*)AcquireProfilingLockKHR},
3286     {"vkReleaseProfilingLockKHR", (void*)ReleaseProfilingLockKHR},
3287     {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR},
3288     {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR},
3289     {"vkGetPhysicalDeviceDisplayProperties2KHR", (void*)GetPhysicalDeviceDisplayProperties2KHR},
3290     {"vkGetPhysicalDeviceDisplayPlaneProperties2KHR", (void*)GetPhysicalDeviceDisplayPlaneProperties2KHR},
3291     {"vkGetDisplayModeProperties2KHR", (void*)GetDisplayModeProperties2KHR},
3292     {"vkGetDisplayPlaneCapabilities2KHR", (void*)GetDisplayPlaneCapabilities2KHR},
3293     {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR},
3294     {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR},
3295     {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR},
3296     {"vkCreateSamplerYcbcrConversionKHR", (void*)CreateSamplerYcbcrConversionKHR},
3297     {"vkDestroySamplerYcbcrConversionKHR", (void*)DestroySamplerYcbcrConversionKHR},
3298     {"vkBindBufferMemory2KHR", (void*)BindBufferMemory2KHR},
3299     {"vkBindImageMemory2KHR", (void*)BindImageMemory2KHR},
3300     {"vkGetDescriptorSetLayoutSupportKHR", (void*)GetDescriptorSetLayoutSupportKHR},
3301     {"vkCmdDrawIndirectCountKHR", (void*)CmdDrawIndirectCountKHR},
3302     {"vkCmdDrawIndexedIndirectCountKHR", (void*)CmdDrawIndexedIndirectCountKHR},
3303     {"vkGetSemaphoreCounterValueKHR", (void*)GetSemaphoreCounterValueKHR},
3304     {"vkWaitSemaphoresKHR", (void*)WaitSemaphoresKHR},
3305     {"vkSignalSemaphoreKHR", (void*)SignalSemaphoreKHR},
3306     {"vkGetPhysicalDeviceFragmentShadingRatesKHR", (void*)GetPhysicalDeviceFragmentShadingRatesKHR},
3307     {"vkCmdSetFragmentShadingRateKHR", (void*)CmdSetFragmentShadingRateKHR},
3308     {"vkGetBufferDeviceAddressKHR", (void*)GetBufferDeviceAddressKHR},
3309     {"vkGetBufferOpaqueCaptureAddressKHR", (void*)GetBufferOpaqueCaptureAddressKHR},
3310     {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (void*)GetDeviceMemoryOpaqueCaptureAddressKHR},
3311 #ifdef VK_ENABLE_BETA_EXTENSIONS
3312     {"vkCreateDeferredOperationKHR", (void*)CreateDeferredOperationKHR},
3313 #endif
3314 #ifdef VK_ENABLE_BETA_EXTENSIONS
3315     {"vkDestroyDeferredOperationKHR", (void*)DestroyDeferredOperationKHR},
3316 #endif
3317 #ifdef VK_ENABLE_BETA_EXTENSIONS
3318     {"vkGetDeferredOperationMaxConcurrencyKHR", (void*)GetDeferredOperationMaxConcurrencyKHR},
3319 #endif
3320 #ifdef VK_ENABLE_BETA_EXTENSIONS
3321     {"vkGetDeferredOperationResultKHR", (void*)GetDeferredOperationResultKHR},
3322 #endif
3323 #ifdef VK_ENABLE_BETA_EXTENSIONS
3324     {"vkDeferredOperationJoinKHR", (void*)DeferredOperationJoinKHR},
3325 #endif
3326     {"vkGetPipelineExecutablePropertiesKHR", (void*)GetPipelineExecutablePropertiesKHR},
3327     {"vkGetPipelineExecutableStatisticsKHR", (void*)GetPipelineExecutableStatisticsKHR},
3328     {"vkGetPipelineExecutableInternalRepresentationsKHR", (void*)GetPipelineExecutableInternalRepresentationsKHR},
3329     {"vkCmdCopyBuffer2KHR", (void*)CmdCopyBuffer2KHR},
3330     {"vkCmdCopyImage2KHR", (void*)CmdCopyImage2KHR},
3331     {"vkCmdCopyBufferToImage2KHR", (void*)CmdCopyBufferToImage2KHR},
3332     {"vkCmdCopyImageToBuffer2KHR", (void*)CmdCopyImageToBuffer2KHR},
3333     {"vkCmdBlitImage2KHR", (void*)CmdBlitImage2KHR},
3334     {"vkCmdResolveImage2KHR", (void*)CmdResolveImage2KHR},
3335     {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT},
3336     {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT},
3337     {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT},
3338     {"vkDebugMarkerSetObjectTagEXT", (void*)DebugMarkerSetObjectTagEXT},
3339     {"vkDebugMarkerSetObjectNameEXT", (void*)DebugMarkerSetObjectNameEXT},
3340     {"vkCmdDebugMarkerBeginEXT", (void*)CmdDebugMarkerBeginEXT},
3341     {"vkCmdDebugMarkerEndEXT", (void*)CmdDebugMarkerEndEXT},
3342     {"vkCmdDebugMarkerInsertEXT", (void*)CmdDebugMarkerInsertEXT},
3343     {"vkCmdBindTransformFeedbackBuffersEXT", (void*)CmdBindTransformFeedbackBuffersEXT},
3344     {"vkCmdBeginTransformFeedbackEXT", (void*)CmdBeginTransformFeedbackEXT},
3345     {"vkCmdEndTransformFeedbackEXT", (void*)CmdEndTransformFeedbackEXT},
3346     {"vkCmdBeginQueryIndexedEXT", (void*)CmdBeginQueryIndexedEXT},
3347     {"vkCmdEndQueryIndexedEXT", (void*)CmdEndQueryIndexedEXT},
3348     {"vkCmdDrawIndirectByteCountEXT", (void*)CmdDrawIndirectByteCountEXT},
3349     {"vkGetImageViewHandleNVX", (void*)GetImageViewHandleNVX},
3350     {"vkGetImageViewAddressNVX", (void*)GetImageViewAddressNVX},
3351     {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD},
3352     {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD},
3353     {"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD},
3354 #ifdef VK_USE_PLATFORM_GGP
3355     {"vkCreateStreamDescriptorSurfaceGGP", (void*)CreateStreamDescriptorSurfaceGGP},
3356 #endif
3357     {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV},
3358 #ifdef VK_USE_PLATFORM_WIN32_KHR
3359     {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV},
3360 #endif
3361 #ifdef VK_USE_PLATFORM_VI_NN
3362     {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN},
3363 #endif
3364     {"vkCmdBeginConditionalRenderingEXT", (void*)CmdBeginConditionalRenderingEXT},
3365     {"vkCmdEndConditionalRenderingEXT", (void*)CmdEndConditionalRenderingEXT},
3366     {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV},
3367     {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT},
3368 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3369     {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT},
3370 #endif
3371 #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT
3372     {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT},
3373 #endif
3374     {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT},
3375     {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT},
3376     {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT},
3377     {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT},
3378     {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT},
3379     {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE},
3380     {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE},
3381     {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT},
3382     {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT},
3383 #ifdef VK_USE_PLATFORM_IOS_MVK
3384     {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK},
3385 #endif
3386 #ifdef VK_USE_PLATFORM_MACOS_MVK
3387     {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK},
3388 #endif
3389     {"vkSetDebugUtilsObjectNameEXT", (void*)SetDebugUtilsObjectNameEXT},
3390     {"vkSetDebugUtilsObjectTagEXT", (void*)SetDebugUtilsObjectTagEXT},
3391     {"vkQueueBeginDebugUtilsLabelEXT", (void*)QueueBeginDebugUtilsLabelEXT},
3392     {"vkQueueEndDebugUtilsLabelEXT", (void*)QueueEndDebugUtilsLabelEXT},
3393     {"vkQueueInsertDebugUtilsLabelEXT", (void*)QueueInsertDebugUtilsLabelEXT},
3394     {"vkCmdBeginDebugUtilsLabelEXT", (void*)CmdBeginDebugUtilsLabelEXT},
3395     {"vkCmdEndDebugUtilsLabelEXT", (void*)CmdEndDebugUtilsLabelEXT},
3396     {"vkCmdInsertDebugUtilsLabelEXT", (void*)CmdInsertDebugUtilsLabelEXT},
3397     {"vkCreateDebugUtilsMessengerEXT", (void*)CreateDebugUtilsMessengerEXT},
3398     {"vkDestroyDebugUtilsMessengerEXT", (void*)DestroyDebugUtilsMessengerEXT},
3399     {"vkSubmitDebugUtilsMessageEXT", (void*)SubmitDebugUtilsMessageEXT},
3400 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3401     {"vkGetAndroidHardwareBufferPropertiesANDROID", (void*)GetAndroidHardwareBufferPropertiesANDROID},
3402 #endif
3403 #ifdef VK_USE_PLATFORM_ANDROID_KHR
3404     {"vkGetMemoryAndroidHardwareBufferANDROID", (void*)GetMemoryAndroidHardwareBufferANDROID},
3405 #endif
3406     {"vkCmdSetSampleLocationsEXT", (void*)CmdSetSampleLocationsEXT},
3407     {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (void*)GetPhysicalDeviceMultisamplePropertiesEXT},
3408     {"vkGetImageDrmFormatModifierPropertiesEXT", (void*)GetImageDrmFormatModifierPropertiesEXT},
3409     {"vkCreateValidationCacheEXT", (void*)CreateValidationCacheEXT},
3410     {"vkDestroyValidationCacheEXT", (void*)DestroyValidationCacheEXT},
3411     {"vkMergeValidationCachesEXT", (void*)MergeValidationCachesEXT},
3412     {"vkGetValidationCacheDataEXT", (void*)GetValidationCacheDataEXT},
3413     {"vkCmdBindShadingRateImageNV", (void*)CmdBindShadingRateImageNV},
3414     {"vkCmdSetViewportShadingRatePaletteNV", (void*)CmdSetViewportShadingRatePaletteNV},
3415     {"vkCmdSetCoarseSampleOrderNV", (void*)CmdSetCoarseSampleOrderNV},
3416     {"vkCreateAccelerationStructureNV", (void*)CreateAccelerationStructureNV},
3417     {"vkDestroyAccelerationStructureKHR", (void*)DestroyAccelerationStructureKHR},
3418     {"vkDestroyAccelerationStructureNV", (void*)DestroyAccelerationStructureNV},
3419     {"vkGetAccelerationStructureMemoryRequirementsNV", (void*)GetAccelerationStructureMemoryRequirementsNV},
3420     {"vkBindAccelerationStructureMemoryKHR", (void*)BindAccelerationStructureMemoryKHR},
3421     {"vkBindAccelerationStructureMemoryNV", (void*)BindAccelerationStructureMemoryNV},
3422     {"vkCmdBuildAccelerationStructureNV", (void*)CmdBuildAccelerationStructureNV},
3423     {"vkCmdCopyAccelerationStructureNV", (void*)CmdCopyAccelerationStructureNV},
3424     {"vkCmdTraceRaysNV", (void*)CmdTraceRaysNV},
3425     {"vkCreateRayTracingPipelinesNV", (void*)CreateRayTracingPipelinesNV},
3426     {"vkGetRayTracingShaderGroupHandlesKHR", (void*)GetRayTracingShaderGroupHandlesKHR},
3427     {"vkGetRayTracingShaderGroupHandlesNV", (void*)GetRayTracingShaderGroupHandlesNV},
3428     {"vkGetAccelerationStructureHandleNV", (void*)GetAccelerationStructureHandleNV},
3429     {"vkCmdWriteAccelerationStructuresPropertiesKHR", (void*)CmdWriteAccelerationStructuresPropertiesKHR},
3430     {"vkCmdWriteAccelerationStructuresPropertiesNV", (void*)CmdWriteAccelerationStructuresPropertiesNV},
3431     {"vkCompileDeferredNV", (void*)CompileDeferredNV},
3432     {"vkGetMemoryHostPointerPropertiesEXT", (void*)GetMemoryHostPointerPropertiesEXT},
3433     {"vkCmdWriteBufferMarkerAMD", (void*)CmdWriteBufferMarkerAMD},
3434     {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (void*)GetPhysicalDeviceCalibrateableTimeDomainsEXT},
3435     {"vkGetCalibratedTimestampsEXT", (void*)GetCalibratedTimestampsEXT},
3436     {"vkCmdDrawMeshTasksNV", (void*)CmdDrawMeshTasksNV},
3437     {"vkCmdDrawMeshTasksIndirectNV", (void*)CmdDrawMeshTasksIndirectNV},
3438     {"vkCmdDrawMeshTasksIndirectCountNV", (void*)CmdDrawMeshTasksIndirectCountNV},
3439     {"vkCmdSetExclusiveScissorNV", (void*)CmdSetExclusiveScissorNV},
3440     {"vkCmdSetCheckpointNV", (void*)CmdSetCheckpointNV},
3441     {"vkGetQueueCheckpointDataNV", (void*)GetQueueCheckpointDataNV},
3442     {"vkInitializePerformanceApiINTEL", (void*)InitializePerformanceApiINTEL},
3443     {"vkUninitializePerformanceApiINTEL", (void*)UninitializePerformanceApiINTEL},
3444     {"vkCmdSetPerformanceMarkerINTEL", (void*)CmdSetPerformanceMarkerINTEL},
3445     {"vkCmdSetPerformanceStreamMarkerINTEL", (void*)CmdSetPerformanceStreamMarkerINTEL},
3446     {"vkCmdSetPerformanceOverrideINTEL", (void*)CmdSetPerformanceOverrideINTEL},
3447     {"vkAcquirePerformanceConfigurationINTEL", (void*)AcquirePerformanceConfigurationINTEL},
3448     {"vkReleasePerformanceConfigurationINTEL", (void*)ReleasePerformanceConfigurationINTEL},
3449     {"vkQueueSetPerformanceConfigurationINTEL", (void*)QueueSetPerformanceConfigurationINTEL},
3450     {"vkGetPerformanceParameterINTEL", (void*)GetPerformanceParameterINTEL},
3451     {"vkSetLocalDimmingAMD", (void*)SetLocalDimmingAMD},
3452 #ifdef VK_USE_PLATFORM_FUCHSIA
3453     {"vkCreateImagePipeSurfaceFUCHSIA", (void*)CreateImagePipeSurfaceFUCHSIA},
3454 #endif
3455 #ifdef VK_USE_PLATFORM_METAL_EXT
3456     {"vkCreateMetalSurfaceEXT", (void*)CreateMetalSurfaceEXT},
3457 #endif
3458     {"vkGetBufferDeviceAddressEXT", (void*)GetBufferDeviceAddressEXT},
3459     {"vkGetPhysicalDeviceToolPropertiesEXT", (void*)GetPhysicalDeviceToolPropertiesEXT},
3460     {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesNV},
3461     {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV},
3462 #ifdef VK_USE_PLATFORM_WIN32_KHR
3463     {"vkGetPhysicalDeviceSurfacePresentModes2EXT", (void*)GetPhysicalDeviceSurfacePresentModes2EXT},
3464 #endif
3465 #ifdef VK_USE_PLATFORM_WIN32_KHR
3466     {"vkAcquireFullScreenExclusiveModeEXT", (void*)AcquireFullScreenExclusiveModeEXT},
3467 #endif
3468 #ifdef VK_USE_PLATFORM_WIN32_KHR
3469     {"vkReleaseFullScreenExclusiveModeEXT", (void*)ReleaseFullScreenExclusiveModeEXT},
3470 #endif
3471 #ifdef VK_USE_PLATFORM_WIN32_KHR
3472     {"vkGetDeviceGroupSurfacePresentModes2EXT", (void*)GetDeviceGroupSurfacePresentModes2EXT},
3473 #endif
3474     {"vkCreateHeadlessSurfaceEXT", (void*)CreateHeadlessSurfaceEXT},
3475     {"vkCmdSetLineStippleEXT", (void*)CmdSetLineStippleEXT},
3476     {"vkResetQueryPoolEXT", (void*)ResetQueryPoolEXT},
3477     {"vkCmdSetCullModeEXT", (void*)CmdSetCullModeEXT},
3478     {"vkCmdSetFrontFaceEXT", (void*)CmdSetFrontFaceEXT},
3479     {"vkCmdSetPrimitiveTopologyEXT", (void*)CmdSetPrimitiveTopologyEXT},
3480     {"vkCmdSetViewportWithCountEXT", (void*)CmdSetViewportWithCountEXT},
3481     {"vkCmdSetScissorWithCountEXT", (void*)CmdSetScissorWithCountEXT},
3482     {"vkCmdBindVertexBuffers2EXT", (void*)CmdBindVertexBuffers2EXT},
3483     {"vkCmdSetDepthTestEnableEXT", (void*)CmdSetDepthTestEnableEXT},
3484     {"vkCmdSetDepthWriteEnableEXT", (void*)CmdSetDepthWriteEnableEXT},
3485     {"vkCmdSetDepthCompareOpEXT", (void*)CmdSetDepthCompareOpEXT},
3486     {"vkCmdSetDepthBoundsTestEnableEXT", (void*)CmdSetDepthBoundsTestEnableEXT},
3487     {"vkCmdSetStencilTestEnableEXT", (void*)CmdSetStencilTestEnableEXT},
3488     {"vkCmdSetStencilOpEXT", (void*)CmdSetStencilOpEXT},
3489     {"vkGetGeneratedCommandsMemoryRequirementsNV", (void*)GetGeneratedCommandsMemoryRequirementsNV},
3490     {"vkCmdPreprocessGeneratedCommandsNV", (void*)CmdPreprocessGeneratedCommandsNV},
3491     {"vkCmdExecuteGeneratedCommandsNV", (void*)CmdExecuteGeneratedCommandsNV},
3492     {"vkCmdBindPipelineShaderGroupNV", (void*)CmdBindPipelineShaderGroupNV},
3493     {"vkCreateIndirectCommandsLayoutNV", (void*)CreateIndirectCommandsLayoutNV},
3494     {"vkDestroyIndirectCommandsLayoutNV", (void*)DestroyIndirectCommandsLayoutNV},
3495     {"vkCreatePrivateDataSlotEXT", (void*)CreatePrivateDataSlotEXT},
3496     {"vkDestroyPrivateDataSlotEXT", (void*)DestroyPrivateDataSlotEXT},
3497     {"vkSetPrivateDataEXT", (void*)SetPrivateDataEXT},
3498     {"vkGetPrivateDataEXT", (void*)GetPrivateDataEXT},
3499 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
3500     {"vkCreateDirectFBSurfaceEXT", (void*)CreateDirectFBSurfaceEXT},
3501 #endif
3502 #ifdef VK_USE_PLATFORM_DIRECTFB_EXT
3503     {"vkGetPhysicalDeviceDirectFBPresentationSupportEXT", (void*)GetPhysicalDeviceDirectFBPresentationSupportEXT},
3504 #endif
3505 #ifdef VK_ENABLE_BETA_EXTENSIONS
3506     {"vkCreateAccelerationStructureKHR", (void*)CreateAccelerationStructureKHR},
3507 #endif
3508 #ifdef VK_ENABLE_BETA_EXTENSIONS
3509     {"vkGetAccelerationStructureMemoryRequirementsKHR", (void*)GetAccelerationStructureMemoryRequirementsKHR},
3510 #endif
3511 #ifdef VK_ENABLE_BETA_EXTENSIONS
3512     {"vkCmdBuildAccelerationStructureKHR", (void*)CmdBuildAccelerationStructureKHR},
3513 #endif
3514 #ifdef VK_ENABLE_BETA_EXTENSIONS
3515     {"vkCmdBuildAccelerationStructureIndirectKHR", (void*)CmdBuildAccelerationStructureIndirectKHR},
3516 #endif
3517 #ifdef VK_ENABLE_BETA_EXTENSIONS
3518     {"vkBuildAccelerationStructureKHR", (void*)BuildAccelerationStructureKHR},
3519 #endif
3520 #ifdef VK_ENABLE_BETA_EXTENSIONS
3521     {"vkCopyAccelerationStructureKHR", (void*)CopyAccelerationStructureKHR},
3522 #endif
3523 #ifdef VK_ENABLE_BETA_EXTENSIONS
3524     {"vkCopyAccelerationStructureToMemoryKHR", (void*)CopyAccelerationStructureToMemoryKHR},
3525 #endif
3526 #ifdef VK_ENABLE_BETA_EXTENSIONS
3527     {"vkCopyMemoryToAccelerationStructureKHR", (void*)CopyMemoryToAccelerationStructureKHR},
3528 #endif
3529 #ifdef VK_ENABLE_BETA_EXTENSIONS
3530     {"vkWriteAccelerationStructuresPropertiesKHR", (void*)WriteAccelerationStructuresPropertiesKHR},
3531 #endif
3532 #ifdef VK_ENABLE_BETA_EXTENSIONS
3533     {"vkCmdCopyAccelerationStructureKHR", (void*)CmdCopyAccelerationStructureKHR},
3534 #endif
3535 #ifdef VK_ENABLE_BETA_EXTENSIONS
3536     {"vkCmdCopyAccelerationStructureToMemoryKHR", (void*)CmdCopyAccelerationStructureToMemoryKHR},
3537 #endif
3538 #ifdef VK_ENABLE_BETA_EXTENSIONS
3539     {"vkCmdCopyMemoryToAccelerationStructureKHR", (void*)CmdCopyMemoryToAccelerationStructureKHR},
3540 #endif
3541 #ifdef VK_ENABLE_BETA_EXTENSIONS
3542     {"vkCmdTraceRaysKHR", (void*)CmdTraceRaysKHR},
3543 #endif
3544 #ifdef VK_ENABLE_BETA_EXTENSIONS
3545     {"vkCreateRayTracingPipelinesKHR", (void*)CreateRayTracingPipelinesKHR},
3546 #endif
3547 #ifdef VK_ENABLE_BETA_EXTENSIONS
3548     {"vkGetAccelerationStructureDeviceAddressKHR", (void*)GetAccelerationStructureDeviceAddressKHR},
3549 #endif
3550 #ifdef VK_ENABLE_BETA_EXTENSIONS
3551     {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", (void*)GetRayTracingCaptureReplayShaderGroupHandlesKHR},
3552 #endif
3553 #ifdef VK_ENABLE_BETA_EXTENSIONS
3554     {"vkCmdTraceRaysIndirectKHR", (void*)CmdTraceRaysIndirectKHR},
3555 #endif
3556 #ifdef VK_ENABLE_BETA_EXTENSIONS
3557     {"vkGetDeviceAccelerationStructureCompatibilityKHR", (void*)GetDeviceAccelerationStructureCompatibilityKHR},
3558 #endif
3559 };
3560
3561
3562 } // namespace vkmock
3563
3564 #endif