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