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