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