diff options
| author | Charles Giessen <charles@lunarg.com> | 2023-06-15 12:22:52 -0600 |
|---|---|---|
| committer | Charles Giessen <46324611+charles-lunarg@users.noreply.github.com> | 2023-06-16 18:05:38 -0600 |
| commit | ca8bb4ee3cc9afdeca4b49c5ef758bad7cce2c72 (patch) | |
| tree | a289dd7d1fb7a38a783c5e54a044c822aef8582d /icd/generated/function_declarations.h | |
| parent | 7040985c553c1a5ecf998bc61e53e5ae76fd41c1 (diff) | |
| download | usermoji-ca8bb4ee3cc9afdeca4b49c5ef758bad7cce2c72.tar.xz | |
icd: Move handwritten code into .cpp file
Takes the hand written portions of the mock_icd_generator.py and puts them
in a .cpp file, then moves the code gen into function_declarations.h and
function_definitions.h.
This move makes it easier to maintain the C++ code that exists because it
no longer lives in a python file. This commit does not make adding custom
code easier, as it still is in the python file. The intent of this commit
is to create a baseline that would allow such code to be put inside of C++
instead of python.
Additionally, this commit removes egregious over engineering in the
mock icd CMakeLists.txt. Things removed are macros that are only called
once, foreach loops over single items, and replacing variables that had no
solid reason to be a variable.
Diffstat (limited to 'icd/generated/function_declarations.h')
| -rw-r--r-- | icd/generated/function_declarations.h | 4982 |
1 files changed, 4982 insertions, 0 deletions
diff --git a/icd/generated/function_declarations.h b/icd/generated/function_declarations.h new file mode 100644 index 00000000..bdd172e4 --- /dev/null +++ b/icd/generated/function_declarations.h @@ -0,0 +1,4982 @@ +/* +** Copyright (c) 2015-2018, 2023 The Khronos Group Inc. +** +** Licensed under the Apache License, Version 2.0 (the "License"); +** you may not use this file except in compliance with the License. +** You may obtain a copy of the License at +** +** http://www.apache.org/licenses/LICENSE-2.0 +** +** Unless required by applicable law or agreed to in writing, software +** distributed under the License is distributed on an "AS IS" BASIS, +** WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. +** See the License for the specific language governing permissions and +** limitations under the License. +*/ + +/* +** This header is generated from the Khronos Vulkan XML API Registry. +** +*/ + + +#pragma once + +#include <stdint.h> +#include <string> +#include <unordered_map> +#include <vulkan/vulkan.h> + +namespace vkmock { + +// Map of instance extension name to version +static const std::unordered_map<std::string, uint32_t> instance_extension_map = { + {"VK_KHR_surface", 25}, + {"VK_KHR_display", 23}, + {"VK_KHR_xlib_surface", 6}, + {"VK_KHR_xcb_surface", 6}, + {"VK_KHR_wayland_surface", 6}, + {"VK_KHR_android_surface", 6}, + {"VK_KHR_win32_surface", 6}, + {"VK_EXT_debug_report", 10}, + {"VK_GGP_stream_descriptor_surface", 1}, + {"VK_NV_external_memory_capabilities", 1}, + {"VK_KHR_get_physical_device_properties2", 2}, + {"VK_EXT_validation_flags", 2}, + {"VK_NN_vi_surface", 1}, + {"VK_KHR_device_group_creation", 1}, + {"VK_KHR_external_memory_capabilities", 1}, + {"VK_KHR_external_semaphore_capabilities", 1}, + {"VK_EXT_direct_mode_display", 1}, + {"VK_EXT_acquire_xlib_display", 1}, + {"VK_EXT_display_surface_counter", 1}, + {"VK_EXT_swapchain_colorspace", 4}, + {"VK_KHR_external_fence_capabilities", 1}, + {"VK_KHR_get_surface_capabilities2", 1}, + {"VK_KHR_get_display_properties2", 1}, + {"VK_MVK_ios_surface", 3}, + {"VK_MVK_macos_surface", 3}, + {"VK_EXT_debug_utils", 2}, + {"VK_FUCHSIA_imagepipe_surface", 1}, + {"VK_EXT_metal_surface", 1}, + {"VK_KHR_surface_protected_capabilities", 1}, + {"VK_EXT_validation_features", 5}, + {"VK_EXT_headless_surface", 1}, + {"VK_EXT_surface_maintenance1", 1}, + {"VK_EXT_acquire_drm_display", 1}, + {"VK_EXT_directfb_surface", 1}, + {"VK_QNX_screen_surface", 1}, + {"VK_KHR_portability_enumeration", 1}, + {"VK_GOOGLE_surfaceless_query", 2}, + {"VK_LUNARG_direct_driver_loading", 1}, +}; +// Map of device extension name to version +static const std::unordered_map<std::string, uint32_t> device_extension_map = { + {"VK_KHR_swapchain", 70}, + {"VK_KHR_display_swapchain", 10}, + {"VK_NV_glsl_shader", 1}, + {"VK_EXT_depth_range_unrestricted", 1}, + {"VK_KHR_sampler_mirror_clamp_to_edge", 3}, + {"VK_IMG_filter_cubic", 1}, + {"VK_AMD_rasterization_order", 1}, + {"VK_AMD_shader_trinary_minmax", 1}, + {"VK_AMD_shader_explicit_vertex_parameter", 1}, + {"VK_EXT_debug_marker", 4}, + {"VK_KHR_video_queue", 8}, + {"VK_KHR_video_decode_queue", 7}, + {"VK_AMD_gcn_shader", 1}, + {"VK_NV_dedicated_allocation", 1}, + {"VK_EXT_transform_feedback", 1}, + {"VK_NVX_binary_import", 1}, + {"VK_NVX_image_view_handle", 2}, + {"VK_AMD_draw_indirect_count", 2}, + {"VK_AMD_negative_viewport_height", 1}, + {"VK_AMD_gpu_shader_half_float", 2}, + {"VK_AMD_shader_ballot", 1}, + {"VK_EXT_video_encode_h264", 11}, + {"VK_EXT_video_encode_h265", 11}, + {"VK_KHR_video_decode_h264", 8}, + {"VK_AMD_texture_gather_bias_lod", 1}, + {"VK_AMD_shader_info", 1}, + {"VK_KHR_dynamic_rendering", 1}, + {"VK_AMD_shader_image_load_store_lod", 1}, + {"VK_NV_corner_sampled_image", 2}, + {"VK_KHR_multiview", 1}, + {"VK_IMG_format_pvrtc", 1}, + {"VK_NV_external_memory", 1}, + {"VK_NV_external_memory_win32", 1}, + {"VK_NV_win32_keyed_mutex", 2}, + {"VK_KHR_device_group", 4}, + {"VK_KHR_shader_draw_parameters", 1}, + {"VK_EXT_shader_subgroup_ballot", 1}, + {"VK_EXT_shader_subgroup_vote", 1}, + {"VK_EXT_texture_compression_astc_hdr", 1}, + {"VK_EXT_astc_decode_mode", 1}, + {"VK_EXT_pipeline_robustness", 1}, + {"VK_KHR_maintenance1", 2}, + {"VK_KHR_external_memory", 1}, + {"VK_KHR_external_memory_win32", 1}, + {"VK_KHR_external_memory_fd", 1}, + {"VK_KHR_win32_keyed_mutex", 1}, + {"VK_KHR_external_semaphore", 1}, + {"VK_KHR_external_semaphore_win32", 1}, + {"VK_KHR_external_semaphore_fd", 1}, + {"VK_KHR_push_descriptor", 2}, + {"VK_EXT_conditional_rendering", 2}, + {"VK_KHR_shader_float16_int8", 1}, + {"VK_KHR_16bit_storage", 1}, + {"VK_KHR_incremental_present", 2}, + {"VK_KHR_descriptor_update_template", 1}, + {"VK_NV_clip_space_w_scaling", 1}, + {"VK_EXT_display_control", 1}, + {"VK_GOOGLE_display_timing", 1}, + {"VK_NV_sample_mask_override_coverage", 1}, + {"VK_NV_geometry_shader_passthrough", 1}, + {"VK_NV_viewport_array2", 1}, + {"VK_NVX_multiview_per_view_attributes", 1}, + {"VK_NV_viewport_swizzle", 1}, + {"VK_EXT_discard_rectangles", 2}, + {"VK_EXT_conservative_rasterization", 1}, + {"VK_EXT_depth_clip_enable", 1}, + {"VK_EXT_hdr_metadata", 2}, + {"VK_KHR_imageless_framebuffer", 1}, + {"VK_KHR_create_renderpass2", 1}, + {"VK_KHR_shared_presentable_image", 1}, + {"VK_KHR_external_fence", 1}, + {"VK_KHR_external_fence_win32", 1}, + {"VK_KHR_external_fence_fd", 1}, + {"VK_KHR_performance_query", 1}, + {"VK_KHR_maintenance2", 1}, + {"VK_KHR_variable_pointers", 1}, + {"VK_EXT_external_memory_dma_buf", 1}, + {"VK_EXT_queue_family_foreign", 1}, + {"VK_KHR_dedicated_allocation", 3}, + {"VK_ANDROID_external_memory_android_hardware_buffer", 5}, + {"VK_EXT_sampler_filter_minmax", 2}, + {"VK_KHR_storage_buffer_storage_class", 1}, + {"VK_AMD_gpu_shader_int16", 2}, + {"VK_AMD_mixed_attachment_samples", 1}, + {"VK_AMD_shader_fragment_mask", 1}, + {"VK_EXT_inline_uniform_block", 1}, + {"VK_EXT_shader_stencil_export", 1}, + {"VK_EXT_sample_locations", 1}, + {"VK_KHR_relaxed_block_layout", 1}, + {"VK_KHR_get_memory_requirements2", 1}, + {"VK_KHR_image_format_list", 1}, + {"VK_EXT_blend_operation_advanced", 2}, + {"VK_NV_fragment_coverage_to_color", 1}, + {"VK_KHR_acceleration_structure", 13}, + {"VK_KHR_ray_tracing_pipeline", 1}, + {"VK_KHR_ray_query", 1}, + {"VK_NV_framebuffer_mixed_samples", 1}, + {"VK_NV_fill_rectangle", 1}, + {"VK_NV_shader_sm_builtins", 1}, + {"VK_EXT_post_depth_coverage", 1}, + {"VK_KHR_sampler_ycbcr_conversion", 14}, + {"VK_KHR_bind_memory2", 1}, + {"VK_EXT_image_drm_format_modifier", 2}, + {"VK_EXT_descriptor_indexing", 2}, + {"VK_EXT_shader_viewport_index_layer", 1}, + {"VK_NV_shading_rate_image", 3}, + {"VK_NV_ray_tracing", 3}, + {"VK_NV_representative_fragment_test", 2}, + {"VK_KHR_maintenance3", 1}, + {"VK_KHR_draw_indirect_count", 1}, + {"VK_EXT_filter_cubic", 3}, + {"VK_QCOM_render_pass_shader_resolve", 4}, + {"VK_EXT_global_priority", 2}, + {"VK_KHR_shader_subgroup_extended_types", 1}, + {"VK_KHR_8bit_storage", 1}, + {"VK_EXT_external_memory_host", 1}, + {"VK_AMD_buffer_marker", 1}, + {"VK_KHR_shader_atomic_int64", 1}, + {"VK_KHR_shader_clock", 1}, + {"VK_AMD_pipeline_compiler_control", 1}, + {"VK_EXT_calibrated_timestamps", 2}, + {"VK_AMD_shader_core_properties", 2}, + {"VK_KHR_video_decode_h265", 7}, + {"VK_KHR_global_priority", 1}, + {"VK_AMD_memory_overallocation_behavior", 1}, + {"VK_EXT_vertex_attribute_divisor", 3}, + {"VK_GGP_frame_token", 1}, + {"VK_EXT_pipeline_creation_feedback", 1}, + {"VK_KHR_driver_properties", 1}, + {"VK_KHR_shader_float_controls", 4}, + {"VK_NV_shader_subgroup_partitioned", 1}, + {"VK_KHR_depth_stencil_resolve", 1}, + {"VK_KHR_swapchain_mutable_format", 1}, + {"VK_NV_compute_shader_derivatives", 1}, + {"VK_NV_mesh_shader", 1}, + {"VK_NV_fragment_shader_barycentric", 1}, + {"VK_NV_shader_image_footprint", 2}, + {"VK_NV_scissor_exclusive", 2}, + {"VK_NV_device_diagnostic_checkpoints", 2}, + {"VK_KHR_timeline_semaphore", 2}, + {"VK_INTEL_shader_integer_functions2", 1}, + {"VK_INTEL_performance_query", 2}, + {"VK_KHR_vulkan_memory_model", 3}, + {"VK_EXT_pci_bus_info", 2}, + {"VK_AMD_display_native_hdr", 1}, + {"VK_KHR_shader_terminate_invocation", 1}, + {"VK_EXT_fragment_density_map", 2}, + {"VK_EXT_scalar_block_layout", 1}, + {"VK_GOOGLE_hlsl_functionality1", 1}, + {"VK_GOOGLE_decorate_string", 1}, + {"VK_EXT_subgroup_size_control", 2}, + {"VK_KHR_fragment_shading_rate", 2}, + {"VK_AMD_shader_core_properties2", 1}, + {"VK_AMD_device_coherent_memory", 1}, + {"VK_EXT_shader_image_atomic_int64", 1}, + {"VK_KHR_spirv_1_4", 1}, + {"VK_EXT_memory_budget", 1}, + {"VK_EXT_memory_priority", 1}, + {"VK_NV_dedicated_allocation_image_aliasing", 1}, + {"VK_KHR_separate_depth_stencil_layouts", 1}, + {"VK_EXT_buffer_device_address", 2}, + {"VK_EXT_tooling_info", 1}, + {"VK_EXT_separate_stencil_usage", 1}, + {"VK_KHR_present_wait", 1}, + {"VK_NV_cooperative_matrix", 1}, + {"VK_NV_coverage_reduction_mode", 1}, + {"VK_EXT_fragment_shader_interlock", 1}, + {"VK_EXT_ycbcr_image_arrays", 1}, + {"VK_KHR_uniform_buffer_standard_layout", 1}, + {"VK_EXT_provoking_vertex", 1}, + {"VK_EXT_full_screen_exclusive", 4}, + {"VK_KHR_buffer_device_address", 1}, + {"VK_EXT_line_rasterization", 1}, + {"VK_EXT_shader_atomic_float", 1}, + {"VK_EXT_host_query_reset", 1}, + {"VK_EXT_index_type_uint8", 1}, + {"VK_EXT_extended_dynamic_state", 1}, + {"VK_KHR_deferred_host_operations", 4}, + {"VK_KHR_pipeline_executable_properties", 1}, + {"VK_KHR_map_memory2", 1}, + {"VK_EXT_shader_atomic_float2", 1}, + {"VK_EXT_swapchain_maintenance1", 1}, + {"VK_EXT_shader_demote_to_helper_invocation", 1}, + {"VK_NV_device_generated_commands", 3}, + {"VK_NV_inherited_viewport_scissor", 1}, + {"VK_KHR_shader_integer_dot_product", 1}, + {"VK_EXT_texel_buffer_alignment", 1}, + {"VK_QCOM_render_pass_transform", 3}, + {"VK_EXT_depth_bias_control", 1}, + {"VK_EXT_device_memory_report", 2}, + {"VK_EXT_robustness2", 1}, + {"VK_EXT_custom_border_color", 12}, + {"VK_GOOGLE_user_type", 1}, + {"VK_KHR_pipeline_library", 1}, + {"VK_NV_present_barrier", 1}, + {"VK_KHR_shader_non_semantic_info", 1}, + {"VK_KHR_present_id", 1}, + {"VK_EXT_private_data", 1}, + {"VK_EXT_pipeline_creation_cache_control", 3}, + {"VK_KHR_video_encode_queue", 9}, + {"VK_NV_device_diagnostics_config", 2}, + {"VK_QCOM_render_pass_store_ops", 2}, + {"VK_NV_low_latency", 1}, + {"VK_EXT_metal_objects", 1}, + {"VK_KHR_synchronization2", 1}, + {"VK_EXT_descriptor_buffer", 1}, + {"VK_EXT_graphics_pipeline_library", 1}, + {"VK_AMD_shader_early_and_late_fragment_tests", 1}, + {"VK_KHR_fragment_shader_barycentric", 1}, + {"VK_KHR_shader_subgroup_uniform_control_flow", 1}, + {"VK_KHR_zero_initialize_workgroup_memory", 1}, + {"VK_NV_fragment_shading_rate_enums", 1}, + {"VK_NV_ray_tracing_motion_blur", 1}, + {"VK_EXT_mesh_shader", 1}, + {"VK_EXT_ycbcr_2plane_444_formats", 1}, + {"VK_EXT_fragment_density_map2", 1}, + {"VK_QCOM_rotated_copy_commands", 1}, + {"VK_EXT_image_robustness", 1}, + {"VK_KHR_workgroup_memory_explicit_layout", 1}, + {"VK_KHR_copy_commands2", 1}, + {"VK_EXT_image_compression_control", 1}, + {"VK_EXT_attachment_feedback_loop_layout", 2}, + {"VK_EXT_4444_formats", 1}, + {"VK_EXT_device_fault", 2}, + {"VK_ARM_rasterization_order_attachment_access", 1}, + {"VK_EXT_rgba10x6_formats", 1}, + {"VK_NV_acquire_winrt_display", 1}, + {"VK_VALVE_mutable_descriptor_type", 1}, + {"VK_EXT_vertex_input_dynamic_state", 2}, + {"VK_EXT_physical_device_drm", 1}, + {"VK_EXT_device_address_binding_report", 1}, + {"VK_EXT_depth_clip_control", 1}, + {"VK_EXT_primitive_topology_list_restart", 1}, + {"VK_KHR_format_feature_flags2", 2}, + {"VK_FUCHSIA_external_memory", 1}, + {"VK_FUCHSIA_external_semaphore", 1}, + {"VK_FUCHSIA_buffer_collection", 2}, + {"VK_HUAWEI_subpass_shading", 2}, + {"VK_HUAWEI_invocation_mask", 1}, + {"VK_NV_external_memory_rdma", 1}, + {"VK_EXT_pipeline_properties", 1}, + {"VK_EXT_multisampled_render_to_single_sampled", 1}, + {"VK_EXT_extended_dynamic_state2", 1}, + {"VK_EXT_color_write_enable", 1}, + {"VK_EXT_primitives_generated_query", 1}, + {"VK_KHR_ray_tracing_maintenance1", 1}, + {"VK_EXT_global_priority_query", 1}, + {"VK_EXT_image_view_min_lod", 1}, + {"VK_EXT_multi_draw", 1}, + {"VK_EXT_image_2d_view_of_3d", 1}, + {"VK_EXT_shader_tile_image", 1}, + {"VK_EXT_opacity_micromap", 2}, + {"VK_NV_displacement_micromap", 1}, + {"VK_EXT_load_store_op_none", 1}, + {"VK_HUAWEI_cluster_culling_shader", 2}, + {"VK_EXT_border_color_swizzle", 1}, + {"VK_EXT_pageable_device_local_memory", 1}, + {"VK_KHR_maintenance4", 2}, + {"VK_ARM_shader_core_properties", 1}, + {"VK_EXT_image_sliced_view_of_3d", 1}, + {"VK_VALVE_descriptor_set_host_mapping", 1}, + {"VK_EXT_depth_clamp_zero_one", 1}, + {"VK_EXT_non_seamless_cube_map", 1}, + {"VK_QCOM_fragment_density_map_offset", 1}, + {"VK_NV_copy_memory_indirect", 1}, + {"VK_NV_memory_decompression", 1}, + {"VK_NV_linear_color_attachment", 1}, + {"VK_EXT_image_compression_control_swapchain", 1}, + {"VK_QCOM_image_processing", 1}, + {"VK_EXT_external_memory_acquire_unmodified", 1}, + {"VK_EXT_extended_dynamic_state3", 2}, + {"VK_EXT_subpass_merge_feedback", 2}, + {"VK_EXT_shader_module_identifier", 1}, + {"VK_EXT_rasterization_order_attachment_access", 1}, + {"VK_NV_optical_flow", 1}, + {"VK_EXT_legacy_dithering", 1}, + {"VK_EXT_pipeline_protected_access", 1}, + {"VK_KHR_ray_tracing_position_fetch", 1}, + {"VK_EXT_shader_object", 1}, + {"VK_QCOM_tile_properties", 1}, + {"VK_SEC_amigo_profiling", 1}, + {"VK_QCOM_multiview_per_view_viewports", 1}, + {"VK_NV_ray_tracing_invocation_reorder", 1}, + {"VK_EXT_mutable_descriptor_type", 1}, + {"VK_ARM_shader_core_builtins", 2}, + {"VK_EXT_pipeline_library_group_handles", 1}, + {"VK_EXT_dynamic_rendering_unused_attachments", 1}, + {"VK_QCOM_multiview_per_view_render_areas", 1}, + {"VK_EXT_attachment_feedback_loop_dynamic_state", 1}, + {"VK_QNX_external_memory_screen_buffer", 1}, +}; + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance); + +static VKAPI_ATTR void VKAPI_CALL DestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties); + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( + VkInstance instance, + const char* pName); + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( + VkDevice device, + const char* pName); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice); + +static VKAPI_ATTR void VKAPI_CALL DestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( + VkQueue queue); + +static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( + VkDevice device); + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory); + +static VKAPI_ATTR void VKAPI_CALL FreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData); + +static VKAPI_ATTR void VKAPI_CALL UnmapMemory( + VkDevice device, + VkDeviceMemory memory); + +static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes); + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset); + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +static VKAPI_ATTR void VKAPI_CALL DestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences); + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( + VkDevice device, + VkFence fence); + +static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore); + +static VKAPI_ATTR void VKAPI_CALL DestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent); + +static VKAPI_ATTR void VKAPI_CALL DestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( + VkDevice device, + VkEvent event); + +static VKAPI_ATTR VkResult VKAPI_CALL SetEvent( + VkDevice device, + VkEvent event); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( + VkDevice device, + VkEvent event); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool); + +static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetQueryPoolResults( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + size_t dataSize, + void* pData, + VkDeviceSize stride, + VkQueryResultFlags flags); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer); + +static VKAPI_ATTR void VKAPI_CALL DestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView); + +static VKAPI_ATTR void VKAPI_CALL DestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage); + +static VKAPI_ATTR void VKAPI_CALL DestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView); + +static VKAPI_ATTR void VKAPI_CALL DestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule); + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache); + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR void VKAPI_CALL DestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout); + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler); + +static VKAPI_ATTR void VKAPI_CALL DestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout); + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool); + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags); + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets); + +static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets); + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer); + +static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool); + +static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags); + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers); + +static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + +static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags); + +static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports); + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor); + +static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference); + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorSets( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets, + uint32_t dynamicOffsetCount, + const uint32_t* pDynamicOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType); + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageBlit* pRegions, + VkFilter filter); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data); + +static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges); + +static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects); + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask); + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags srcStageMask, + VkPipelineStageFlags dstStageMask, + VkDependencyFlags dependencyFlags, + uint32_t memoryBarrierCount, + const VkMemoryBarrier* pMemoryBarriers, + uint32_t bufferMemoryBarrierCount, + const VkBufferMemoryBarrier* pBufferMemoryBarriers, + uint32_t imageMemoryBarrierCount, + const VkImageMemoryBarrier* pImageMemoryBarriers); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags); + +static VKAPI_ATTR void VKAPI_CALL CmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query); + +static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyQueryPoolResults( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize stride, + VkQueryResultFlags flags); + +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents); + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers); + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion( + uint32_t* pApiVersion); + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBase( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); + +static VKAPI_ATTR void VKAPI_CALL TrimCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); + +static VKAPI_ATTR void VKAPI_CALL ResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); + +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data); + +static VKAPI_ATTR void VKAPI_CALL GetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + + +static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain); + +static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex); + +static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains); + +#ifdef VK_USE_PLATFORM_XLIB_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID); +#endif /* VK_USE_PLATFORM_XLIB_KHR */ + +#ifdef VK_USE_PLATFORM_XCB_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateXcbSurfaceKHR( + VkInstance instance, + const VkXcbSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id); +#endif /* VK_USE_PLATFORM_XCB_KHR */ + +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateWaylandSurfaceKHR( + VkInstance instance, + const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display); +#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAndroidSurfaceKHR( + VkInstance instance, + const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateWin32SurfaceKHR( + VkInstance instance, + const VkWin32SurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR( + VkDevice device, + const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession); + +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements); + +static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR( + VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters); + +static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo); + +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo); + + +static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoDecodeInfoKHR* pDecodeInfo); + + + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR( + VkCommandBuffer commandBuffer); + + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties); + + +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( + VkCommandBuffer commandBuffer, + uint32_t deviceMask); + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchBaseKHR( + VkCommandBuffer commandBuffer, + uint32_t baseGroupX, + uint32_t baseGroupY, + uint32_t baseGroupZ, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + + + +static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags); + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties); + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties); + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd); + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties); + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphorePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties); + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd); + + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites); + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData); + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate); + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData); + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain); + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties); + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd); + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR( + VkDevice device); + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats); + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities); + + + + + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion); + +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator); + + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos); + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport); + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + + + + + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue); + +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout); + +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates); + +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR( + VkCommandBuffer commandBuffer, + const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t presentId, + uint64_t timeout); + + + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR( + VkDevice device, + const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation); + +static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR( + VkDevice device, + VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR( + VkDevice device, + VkDeferredOperationKHR operation); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR( + VkDevice device, + VkDeferredOperationKHR operation); + +static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR( + VkDevice device, + VkDeferredOperationKHR operation); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( + VkDevice device, + const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations); + + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR( + VkDevice device, + const VkMemoryMapInfoKHR* pMemoryMapInfo, + void** ppData); + +static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR( + VkDevice device, + const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo); + + + + + +#ifdef VK_ENABLE_BETA_EXTENSIONS + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetEncodedVideoSessionParametersKHR( + VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, + size_t* pDataSize, + void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoEncodeInfoKHR* pEncodeInfo); +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask); + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); + +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData); + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo); + + + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectDeviceAddress); + + + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements); + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback); + +static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL DebugReportMessageEXT( + VkInstance instance, + VkDebugReportFlagsEXT flags, + VkDebugReportObjectTypeEXT objectType, + uint64_t object, + size_t location, + int32_t messageCode, + const char* pLayerPrefix, + const char* pMessage); + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags, + uint32_t index); + +static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + uint32_t index); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectByteCountEXT( + VkCommandBuffer commandBuffer, + uint32_t instanceCount, + uint32_t firstInstance, + VkBuffer counterBuffer, + VkDeviceSize counterBufferOffset, + uint32_t counterOffset, + uint32_t vertexStride); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX( + VkDevice device, + const VkCuModuleCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuModuleNVX* pModule); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX( + VkDevice device, + const VkCuFunctionCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuFunctionNVX* pFunction); + +static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX( + VkDevice device, + VkCuModuleNVX module, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX( + VkDevice device, + VkCuFunctionNVX function, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX( + VkCommandBuffer commandBuffer, + const VkCuLaunchInfoNVX* pLaunchInfo); + + +static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( + VkDevice device, + const VkImageViewHandleInfoNVX* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( + VkDevice device, + VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties); + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + + + + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderInfoAMD( + VkDevice device, + VkPipeline pipeline, + VkShaderStageFlagBits shaderStage, + VkShaderInfoTypeAMD infoType, + size_t* pInfoSize, + void* pInfo); + + +#ifdef VK_USE_PLATFORM_GGP + +static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( + VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_GGP */ + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceExternalImageFormatPropertiesNV( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkExternalMemoryHandleTypeFlagsNV externalHandleType, + VkExternalImageFormatPropertiesNV* pExternalImageFormatProperties); + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#ifdef VK_USE_PLATFORM_WIN32_KHR +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +#ifdef VK_USE_PLATFORM_VI_NN + +static VKAPI_ATTR VkResult VKAPI_CALL CreateViSurfaceNN( + VkInstance instance, + const VkViSurfaceCreateInfoNN* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_VI_NN */ + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin); + +static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( + VkCommandBuffer commandBuffer); + + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings); + + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display); + +static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay); +#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities); + + +static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings); + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 discardRectangleEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT( + VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode); + + + + + +static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata); + +#ifdef VK_USE_PLATFORM_IOS_MVK + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_IOS_MVK */ + +#ifdef VK_USE_PLATFORM_MACOS_MVK + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMacOSSurfaceMVK( + VkInstance instance, + const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_MACOS_MVK */ + + + + +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo); + +static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( + VkQueue queue); + +static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer); + +static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger); + +static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData); + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( + VkDevice device, + const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( + VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer); +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo); + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties); + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache); + +static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches); + +static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( + VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders); + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( + VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure); + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements); + +static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( + VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructureNV( + VkCommandBuffer commandBuffer, + const VkAccelerationStructureInfoNV* pInfo, + VkBuffer instanceData, + VkDeviceSize instanceOffset, + VkBool32 update, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkBuffer scratch, + VkDeviceSize scratchOffset); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode); + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysNV( + VkCommandBuffer commandBuffer, + VkBuffer raygenShaderBindingTableBuffer, + VkDeviceSize raygenShaderBindingOffset, + VkBuffer missShaderBindingTableBuffer, + VkDeviceSize missShaderBindingOffset, + VkDeviceSize missShaderBindingStride, + VkBuffer hitShaderBindingTableBuffer, + VkDeviceSize hitShaderBindingOffset, + VkDeviceSize hitShaderBindingStride, + VkBuffer callableShaderBindingTableBuffer, + VkDeviceSize callableShaderBindingOffset, + VkDeviceSize callableShaderBindingStride, + uint32_t width, + uint32_t height, + uint32_t depth); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( + VkDevice device, + VkPipeline pipeline, + uint32_t shader); + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties); + + +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker); + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainEXT* pTimeDomains); + +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoEXT* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation); + + + + +#ifdef VK_USE_PLATFORM_GGP +#endif /* VK_USE_PLATFORM_GGP */ + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksNV( + VkCommandBuffer commandBuffer, + uint32_t taskCount, + uint32_t firstTask); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables); + +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors); + + +static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( + VkCommandBuffer commandBuffer, + const void* pCheckpointMarker); + +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData); + + + +static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( + VkDevice device, + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo); + +static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( + VkDevice device); + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( + VkDevice device, + const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration); + +static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( + VkDevice device, + VkPerformanceConfigurationINTEL configuration); + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( + VkQueue queue, + VkPerformanceConfigurationINTEL configuration); + +static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( + VkDevice device, + VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue); + + + +static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( + VkDevice device, + VkSwapchainKHR swapChain, + VkBool32 localDimmingEnable); + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( + VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_METAL_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMetalSurfaceEXT( + VkInstance instance, + const VkMetalSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); +#endif /* VK_USE_PLATFORM_METAL_EXT */ + + + + + + + + + + + + + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + VkPhysicalDevice physicalDevice, + uint32_t* pCombinationCount, + VkFramebufferMixedSamplesCombinationNV* pCombinations); + + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes); + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain); + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( + VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( + VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern); + + + +static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount); + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports); + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors); + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers2EXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes, + const VkDeviceSize* pStrides); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT( + VkDevice device, + const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo); + + + +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2* pMemoryRequirements); + +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, + uint32_t groupIndex); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout); + +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV( + VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator); + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT( + VkCommandBuffer commandBuffer, + const VkDepthBiasInfoEXT* pDepthBiasInfo); + + + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + VkDisplayKHR display); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + uint32_t connectorId, + VkDisplayKHR* display); + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot); + +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data); + +static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData); + + + + + +#ifdef VK_USE_PLATFORM_METAL_EXT + +static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT( + VkDevice device, + VkExportMetalObjectsInfoEXT* pMetalObjectsInfo); +#endif /* VK_USE_PLATFORM_METAL_EXT */ + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT( + VkDevice device, + VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes); + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT( + VkDevice device, + VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize* pOffset); + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT( + VkDevice device, + const VkDescriptorGetInfoEXT* pDescriptorInfo, + size_t dataSize, + void* pDescriptor); + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDescriptorBufferOffsetsEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t firstSet, + uint32_t setCount, + const uint32_t* pBufferIndices, + const VkDeviceSize* pOffsets); + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set); + +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, + void* pData); + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV( + VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]); + + + + + + + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( + VkDevice device, + VkImage image, + const VkImageSubresource2EXT* pSubresource, + VkSubresourceLayout2EXT* pLayout); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo); + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display); + +static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay); +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDirectFBSurfaceEXT( + VkInstance instance, + const VkDirectFBSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + IDirectFB* dfb); +#endif /* VK_USE_PLATFORM_DIRECTFB_EXT */ + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetVertexInputEXT( + VkCommandBuffer commandBuffer, + uint32_t vertexBindingDescriptionCount, + const VkVertexInputBindingDescription2EXT* pVertexBindingDescriptions, + uint32_t vertexAttributeDescriptionCount, + const VkVertexInputAttributeDescription2EXT* pVertexAttributeDescriptions); + + + + + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( + VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties); +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle); +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferCollectionFUCHSIA( + VkDevice device, + const VkBufferCollectionCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferCollectionFUCHSIA* pCollection); + +static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo); + +static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties); +#endif /* VK_USE_PLATFORM_FUCHSIA */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + VkDevice device, + VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize); + +static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI( + VkCommandBuffer commandBuffer); + + +static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV( + VkDevice device, + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT( + VkDevice device, + const VkPipelineInfoEXT* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties); + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT( + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT( + VkCommandBuffer commandBuffer, + VkLogicOp logicOp); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable); + +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX( + VkInstance instance, + const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface); + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window); +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ + + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkBool32* pColorWriteEnables); + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiIndexedEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawIndexedInfoEXT* pIndexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride, + const int32_t* pVertexOffset); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap); + +static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL WriteMicromapsPropertiesEXT( + VkDevice device, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); + +static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo); + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterHUAWEI( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset); + + + +static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( + VkDevice device, + VkDeviceMemory memory, + float priority); + + + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( + VkDevice device, + const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping); + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( + VkDevice device, + VkDescriptorSet descriptorSet, + void** ppData); + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources); + + +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV( + VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions); + +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride); + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples); + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask); + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream); + +static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced); + +static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable); + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode); + + + + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( + VkDevice device, + VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier); + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier); + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession); + +static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout); + +static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo); + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT( + VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders); + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT( + VkDevice device, + VkShaderEXT shader, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT( + VkDevice device, + VkShaderEXT shader, + size_t* pDataSize, + void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( + VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders); + + +static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( + VkDevice device, + VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties); + +static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties); + + + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( + VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask); + +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX( + VkDevice device, + const struct _screen_buffer* buffer, + VkScreenBufferPropertiesQNX* pProperties); +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure); + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( + VkDevice device, + VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresIndirectKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkDeviceAddress* pIndirectDeviceAddresses, + const uint32_t* pIndirectStrides, + const uint32_t* const* ppMaxPrimitiveCounts); + +static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); + +static VKAPI_ATTR VkResult VKAPI_CALL WriteAccelerationStructuresPropertiesKHR( + VkDevice device, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + size_t dataSize, + void* pData, + size_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo); + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( + VkDevice device, + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo); + +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery); + +static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( + VkDevice device, + const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility); + +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo); + + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + uint32_t width, + uint32_t height, + uint32_t depth); + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines); + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData); + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress); + +static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t group, + VkShaderGroupShaderKHR groupShader); + +static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR( + VkCommandBuffer commandBuffer, + uint32_t pipelineStackSize); + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride); + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride); + +// Map of all APIs to be intercepted by this layer +static const std::unordered_map<std::string, void*> name_to_funcptr_map = { + {"vkCreateInstance", (void*)CreateInstance}, + {"vkDestroyInstance", (void*)DestroyInstance}, + {"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices}, + {"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures}, + {"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties}, + {"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties}, + {"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties}, + {"vkGetPhysicalDeviceQueueFamilyProperties", (void*)GetPhysicalDeviceQueueFamilyProperties}, + {"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties}, + {"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr}, + {"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr}, + {"vkCreateDevice", (void*)CreateDevice}, + {"vkDestroyDevice", (void*)DestroyDevice}, + {"vkEnumerateInstanceExtensionProperties", (void*)EnumerateInstanceExtensionProperties}, + {"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties}, + {"vkEnumerateInstanceLayerProperties", (void*)EnumerateInstanceLayerProperties}, + {"vkEnumerateDeviceLayerProperties", (void*)EnumerateDeviceLayerProperties}, + {"vkGetDeviceQueue", (void*)GetDeviceQueue}, + {"vkQueueSubmit", (void*)QueueSubmit}, + {"vkQueueWaitIdle", (void*)QueueWaitIdle}, + {"vkDeviceWaitIdle", (void*)DeviceWaitIdle}, + {"vkAllocateMemory", (void*)AllocateMemory}, + {"vkFreeMemory", (void*)FreeMemory}, + {"vkMapMemory", (void*)MapMemory}, + {"vkUnmapMemory", (void*)UnmapMemory}, + {"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges}, + {"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges}, + {"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment}, + {"vkBindBufferMemory", (void*)BindBufferMemory}, + {"vkBindImageMemory", (void*)BindImageMemory}, + {"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements}, + {"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements}, + {"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements}, + {"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties}, + {"vkQueueBindSparse", (void*)QueueBindSparse}, + {"vkCreateFence", (void*)CreateFence}, + {"vkDestroyFence", (void*)DestroyFence}, + {"vkResetFences", (void*)ResetFences}, + {"vkGetFenceStatus", (void*)GetFenceStatus}, + {"vkWaitForFences", (void*)WaitForFences}, + {"vkCreateSemaphore", (void*)CreateSemaphore}, + {"vkDestroySemaphore", (void*)DestroySemaphore}, + {"vkCreateEvent", (void*)CreateEvent}, + {"vkDestroyEvent", (void*)DestroyEvent}, + {"vkGetEventStatus", (void*)GetEventStatus}, + {"vkSetEvent", (void*)SetEvent}, + {"vkResetEvent", (void*)ResetEvent}, + {"vkCreateQueryPool", (void*)CreateQueryPool}, + {"vkDestroyQueryPool", (void*)DestroyQueryPool}, + {"vkGetQueryPoolResults", (void*)GetQueryPoolResults}, + {"vkCreateBuffer", (void*)CreateBuffer}, + {"vkDestroyBuffer", (void*)DestroyBuffer}, + {"vkCreateBufferView", (void*)CreateBufferView}, + {"vkDestroyBufferView", (void*)DestroyBufferView}, + {"vkCreateImage", (void*)CreateImage}, + {"vkDestroyImage", (void*)DestroyImage}, + {"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout}, + {"vkCreateImageView", (void*)CreateImageView}, + {"vkDestroyImageView", (void*)DestroyImageView}, + {"vkCreateShaderModule", (void*)CreateShaderModule}, + {"vkDestroyShaderModule", (void*)DestroyShaderModule}, + {"vkCreatePipelineCache", (void*)CreatePipelineCache}, + {"vkDestroyPipelineCache", (void*)DestroyPipelineCache}, + {"vkGetPipelineCacheData", (void*)GetPipelineCacheData}, + {"vkMergePipelineCaches", (void*)MergePipelineCaches}, + {"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines}, + {"vkCreateComputePipelines", (void*)CreateComputePipelines}, + {"vkDestroyPipeline", (void*)DestroyPipeline}, + {"vkCreatePipelineLayout", (void*)CreatePipelineLayout}, + {"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout}, + {"vkCreateSampler", (void*)CreateSampler}, + {"vkDestroySampler", (void*)DestroySampler}, + {"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout}, + {"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout}, + {"vkCreateDescriptorPool", (void*)CreateDescriptorPool}, + {"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool}, + {"vkResetDescriptorPool", (void*)ResetDescriptorPool}, + {"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets}, + {"vkFreeDescriptorSets", (void*)FreeDescriptorSets}, + {"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets}, + {"vkCreateFramebuffer", (void*)CreateFramebuffer}, + {"vkDestroyFramebuffer", (void*)DestroyFramebuffer}, + {"vkCreateRenderPass", (void*)CreateRenderPass}, + {"vkDestroyRenderPass", (void*)DestroyRenderPass}, + {"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity}, + {"vkCreateCommandPool", (void*)CreateCommandPool}, + {"vkDestroyCommandPool", (void*)DestroyCommandPool}, + {"vkResetCommandPool", (void*)ResetCommandPool}, + {"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers}, + {"vkFreeCommandBuffers", (void*)FreeCommandBuffers}, + {"vkBeginCommandBuffer", (void*)BeginCommandBuffer}, + {"vkEndCommandBuffer", (void*)EndCommandBuffer}, + {"vkResetCommandBuffer", (void*)ResetCommandBuffer}, + {"vkCmdBindPipeline", (void*)CmdBindPipeline}, + {"vkCmdSetViewport", (void*)CmdSetViewport}, + {"vkCmdSetScissor", (void*)CmdSetScissor}, + {"vkCmdSetLineWidth", (void*)CmdSetLineWidth}, + {"vkCmdSetDepthBias", (void*)CmdSetDepthBias}, + {"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants}, + {"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds}, + {"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask}, + {"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask}, + {"vkCmdSetStencilReference", (void*)CmdSetStencilReference}, + {"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets}, + {"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer}, + {"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers}, + {"vkCmdDraw", (void*)CmdDraw}, + {"vkCmdDrawIndexed", (void*)CmdDrawIndexed}, + {"vkCmdDrawIndirect", (void*)CmdDrawIndirect}, + {"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect}, + {"vkCmdDispatch", (void*)CmdDispatch}, + {"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect}, + {"vkCmdCopyBuffer", (void*)CmdCopyBuffer}, + {"vkCmdCopyImage", (void*)CmdCopyImage}, + {"vkCmdBlitImage", (void*)CmdBlitImage}, + {"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage}, + {"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer}, + {"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer}, + {"vkCmdFillBuffer", (void*)CmdFillBuffer}, + {"vkCmdClearColorImage", (void*)CmdClearColorImage}, + {"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage}, + {"vkCmdClearAttachments", (void*)CmdClearAttachments}, + {"vkCmdResolveImage", (void*)CmdResolveImage}, + {"vkCmdSetEvent", (void*)CmdSetEvent}, + {"vkCmdResetEvent", (void*)CmdResetEvent}, + {"vkCmdWaitEvents", (void*)CmdWaitEvents}, + {"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier}, + {"vkCmdBeginQuery", (void*)CmdBeginQuery}, + {"vkCmdEndQuery", (void*)CmdEndQuery}, + {"vkCmdResetQueryPool", (void*)CmdResetQueryPool}, + {"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp}, + {"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults}, + {"vkCmdPushConstants", (void*)CmdPushConstants}, + {"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass}, + {"vkCmdNextSubpass", (void*)CmdNextSubpass}, + {"vkCmdEndRenderPass", (void*)CmdEndRenderPass}, + {"vkCmdExecuteCommands", (void*)CmdExecuteCommands}, + {"vkEnumerateInstanceVersion", (void*)EnumerateInstanceVersion}, + {"vkBindBufferMemory2", (void*)BindBufferMemory2}, + {"vkBindImageMemory2", (void*)BindImageMemory2}, + {"vkGetDeviceGroupPeerMemoryFeatures", (void*)GetDeviceGroupPeerMemoryFeatures}, + {"vkCmdSetDeviceMask", (void*)CmdSetDeviceMask}, + {"vkCmdDispatchBase", (void*)CmdDispatchBase}, + {"vkEnumeratePhysicalDeviceGroups", (void*)EnumeratePhysicalDeviceGroups}, + {"vkGetImageMemoryRequirements2", (void*)GetImageMemoryRequirements2}, + {"vkGetBufferMemoryRequirements2", (void*)GetBufferMemoryRequirements2}, + {"vkGetImageSparseMemoryRequirements2", (void*)GetImageSparseMemoryRequirements2}, + {"vkGetPhysicalDeviceFeatures2", (void*)GetPhysicalDeviceFeatures2}, + {"vkGetPhysicalDeviceProperties2", (void*)GetPhysicalDeviceProperties2}, + {"vkGetPhysicalDeviceFormatProperties2", (void*)GetPhysicalDeviceFormatProperties2}, + {"vkGetPhysicalDeviceImageFormatProperties2", (void*)GetPhysicalDeviceImageFormatProperties2}, + {"vkGetPhysicalDeviceQueueFamilyProperties2", (void*)GetPhysicalDeviceQueueFamilyProperties2}, + {"vkGetPhysicalDeviceMemoryProperties2", (void*)GetPhysicalDeviceMemoryProperties2}, + {"vkGetPhysicalDeviceSparseImageFormatProperties2", (void*)GetPhysicalDeviceSparseImageFormatProperties2}, + {"vkTrimCommandPool", (void*)TrimCommandPool}, + {"vkGetDeviceQueue2", (void*)GetDeviceQueue2}, + {"vkCreateSamplerYcbcrConversion", (void*)CreateSamplerYcbcrConversion}, + {"vkDestroySamplerYcbcrConversion", (void*)DestroySamplerYcbcrConversion}, + {"vkCreateDescriptorUpdateTemplate", (void*)CreateDescriptorUpdateTemplate}, + {"vkDestroyDescriptorUpdateTemplate", (void*)DestroyDescriptorUpdateTemplate}, + {"vkUpdateDescriptorSetWithTemplate", (void*)UpdateDescriptorSetWithTemplate}, + {"vkGetPhysicalDeviceExternalBufferProperties", (void*)GetPhysicalDeviceExternalBufferProperties}, + {"vkGetPhysicalDeviceExternalFenceProperties", (void*)GetPhysicalDeviceExternalFenceProperties}, + {"vkGetPhysicalDeviceExternalSemaphoreProperties", (void*)GetPhysicalDeviceExternalSemaphoreProperties}, + {"vkGetDescriptorSetLayoutSupport", (void*)GetDescriptorSetLayoutSupport}, + {"vkCmdDrawIndirectCount", (void*)CmdDrawIndirectCount}, + {"vkCmdDrawIndexedIndirectCount", (void*)CmdDrawIndexedIndirectCount}, + {"vkCreateRenderPass2", (void*)CreateRenderPass2}, + {"vkCmdBeginRenderPass2", (void*)CmdBeginRenderPass2}, + {"vkCmdNextSubpass2", (void*)CmdNextSubpass2}, + {"vkCmdEndRenderPass2", (void*)CmdEndRenderPass2}, + {"vkResetQueryPool", (void*)ResetQueryPool}, + {"vkGetSemaphoreCounterValue", (void*)GetSemaphoreCounterValue}, + {"vkWaitSemaphores", (void*)WaitSemaphores}, + {"vkSignalSemaphore", (void*)SignalSemaphore}, + {"vkGetBufferDeviceAddress", (void*)GetBufferDeviceAddress}, + {"vkGetBufferOpaqueCaptureAddress", (void*)GetBufferOpaqueCaptureAddress}, + {"vkGetDeviceMemoryOpaqueCaptureAddress", (void*)GetDeviceMemoryOpaqueCaptureAddress}, + {"vkGetPhysicalDeviceToolProperties", (void*)GetPhysicalDeviceToolProperties}, + {"vkCreatePrivateDataSlot", (void*)CreatePrivateDataSlot}, + {"vkDestroyPrivateDataSlot", (void*)DestroyPrivateDataSlot}, + {"vkSetPrivateData", (void*)SetPrivateData}, + {"vkGetPrivateData", (void*)GetPrivateData}, + {"vkCmdSetEvent2", (void*)CmdSetEvent2}, + {"vkCmdResetEvent2", (void*)CmdResetEvent2}, + {"vkCmdWaitEvents2", (void*)CmdWaitEvents2}, + {"vkCmdPipelineBarrier2", (void*)CmdPipelineBarrier2}, + {"vkCmdWriteTimestamp2", (void*)CmdWriteTimestamp2}, + {"vkQueueSubmit2", (void*)QueueSubmit2}, + {"vkCmdCopyBuffer2", (void*)CmdCopyBuffer2}, + {"vkCmdCopyImage2", (void*)CmdCopyImage2}, + {"vkCmdCopyBufferToImage2", (void*)CmdCopyBufferToImage2}, + {"vkCmdCopyImageToBuffer2", (void*)CmdCopyImageToBuffer2}, + {"vkCmdBlitImage2", (void*)CmdBlitImage2}, + {"vkCmdResolveImage2", (void*)CmdResolveImage2}, + {"vkCmdBeginRendering", (void*)CmdBeginRendering}, + {"vkCmdEndRendering", (void*)CmdEndRendering}, + {"vkCmdSetCullMode", (void*)CmdSetCullMode}, + {"vkCmdSetFrontFace", (void*)CmdSetFrontFace}, + {"vkCmdSetPrimitiveTopology", (void*)CmdSetPrimitiveTopology}, + {"vkCmdSetViewportWithCount", (void*)CmdSetViewportWithCount}, + {"vkCmdSetScissorWithCount", (void*)CmdSetScissorWithCount}, + {"vkCmdBindVertexBuffers2", (void*)CmdBindVertexBuffers2}, + {"vkCmdSetDepthTestEnable", (void*)CmdSetDepthTestEnable}, + {"vkCmdSetDepthWriteEnable", (void*)CmdSetDepthWriteEnable}, + {"vkCmdSetDepthCompareOp", (void*)CmdSetDepthCompareOp}, + {"vkCmdSetDepthBoundsTestEnable", (void*)CmdSetDepthBoundsTestEnable}, + {"vkCmdSetStencilTestEnable", (void*)CmdSetStencilTestEnable}, + {"vkCmdSetStencilOp", (void*)CmdSetStencilOp}, + {"vkCmdSetRasterizerDiscardEnable", (void*)CmdSetRasterizerDiscardEnable}, + {"vkCmdSetDepthBiasEnable", (void*)CmdSetDepthBiasEnable}, + {"vkCmdSetPrimitiveRestartEnable", (void*)CmdSetPrimitiveRestartEnable}, + {"vkGetDeviceBufferMemoryRequirements", (void*)GetDeviceBufferMemoryRequirements}, + {"vkGetDeviceImageMemoryRequirements", (void*)GetDeviceImageMemoryRequirements}, + {"vkGetDeviceImageSparseMemoryRequirements", (void*)GetDeviceImageSparseMemoryRequirements}, + {"vkDestroySurfaceKHR", (void*)DestroySurfaceKHR}, + {"vkGetPhysicalDeviceSurfaceSupportKHR", (void*)GetPhysicalDeviceSurfaceSupportKHR}, + {"vkGetPhysicalDeviceSurfaceCapabilitiesKHR", (void*)GetPhysicalDeviceSurfaceCapabilitiesKHR}, + {"vkGetPhysicalDeviceSurfaceFormatsKHR", (void*)GetPhysicalDeviceSurfaceFormatsKHR}, + {"vkGetPhysicalDeviceSurfacePresentModesKHR", (void*)GetPhysicalDeviceSurfacePresentModesKHR}, + {"vkCreateSwapchainKHR", (void*)CreateSwapchainKHR}, + {"vkDestroySwapchainKHR", (void*)DestroySwapchainKHR}, + {"vkGetSwapchainImagesKHR", (void*)GetSwapchainImagesKHR}, + {"vkAcquireNextImageKHR", (void*)AcquireNextImageKHR}, + {"vkQueuePresentKHR", (void*)QueuePresentKHR}, + {"vkGetDeviceGroupPresentCapabilitiesKHR", (void*)GetDeviceGroupPresentCapabilitiesKHR}, + {"vkGetDeviceGroupSurfacePresentModesKHR", (void*)GetDeviceGroupSurfacePresentModesKHR}, + {"vkGetPhysicalDevicePresentRectanglesKHR", (void*)GetPhysicalDevicePresentRectanglesKHR}, + {"vkAcquireNextImage2KHR", (void*)AcquireNextImage2KHR}, + {"vkGetPhysicalDeviceDisplayPropertiesKHR", (void*)GetPhysicalDeviceDisplayPropertiesKHR}, + {"vkGetPhysicalDeviceDisplayPlanePropertiesKHR", (void*)GetPhysicalDeviceDisplayPlanePropertiesKHR}, + {"vkGetDisplayPlaneSupportedDisplaysKHR", (void*)GetDisplayPlaneSupportedDisplaysKHR}, + {"vkGetDisplayModePropertiesKHR", (void*)GetDisplayModePropertiesKHR}, + {"vkCreateDisplayModeKHR", (void*)CreateDisplayModeKHR}, + {"vkGetDisplayPlaneCapabilitiesKHR", (void*)GetDisplayPlaneCapabilitiesKHR}, + {"vkCreateDisplayPlaneSurfaceKHR", (void*)CreateDisplayPlaneSurfaceKHR}, + {"vkCreateSharedSwapchainsKHR", (void*)CreateSharedSwapchainsKHR}, +#ifdef VK_USE_PLATFORM_XLIB_KHR + {"vkCreateXlibSurfaceKHR", (void*)CreateXlibSurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_XLIB_KHR + {"vkGetPhysicalDeviceXlibPresentationSupportKHR", (void*)GetPhysicalDeviceXlibPresentationSupportKHR}, +#endif +#ifdef VK_USE_PLATFORM_XCB_KHR + {"vkCreateXcbSurfaceKHR", (void*)CreateXcbSurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_XCB_KHR + {"vkGetPhysicalDeviceXcbPresentationSupportKHR", (void*)GetPhysicalDeviceXcbPresentationSupportKHR}, +#endif +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + {"vkCreateWaylandSurfaceKHR", (void*)CreateWaylandSurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_WAYLAND_KHR + {"vkGetPhysicalDeviceWaylandPresentationSupportKHR", (void*)GetPhysicalDeviceWaylandPresentationSupportKHR}, +#endif +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"vkCreateAndroidSurfaceKHR", (void*)CreateAndroidSurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkCreateWin32SurfaceKHR", (void*)CreateWin32SurfaceKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetPhysicalDeviceWin32PresentationSupportKHR", (void*)GetPhysicalDeviceWin32PresentationSupportKHR}, +#endif + {"vkGetPhysicalDeviceVideoCapabilitiesKHR", (void*)GetPhysicalDeviceVideoCapabilitiesKHR}, + {"vkGetPhysicalDeviceVideoFormatPropertiesKHR", (void*)GetPhysicalDeviceVideoFormatPropertiesKHR}, + {"vkCreateVideoSessionKHR", (void*)CreateVideoSessionKHR}, + {"vkDestroyVideoSessionKHR", (void*)DestroyVideoSessionKHR}, + {"vkGetVideoSessionMemoryRequirementsKHR", (void*)GetVideoSessionMemoryRequirementsKHR}, + {"vkBindVideoSessionMemoryKHR", (void*)BindVideoSessionMemoryKHR}, + {"vkCreateVideoSessionParametersKHR", (void*)CreateVideoSessionParametersKHR}, + {"vkUpdateVideoSessionParametersKHR", (void*)UpdateVideoSessionParametersKHR}, + {"vkDestroyVideoSessionParametersKHR", (void*)DestroyVideoSessionParametersKHR}, + {"vkCmdBeginVideoCodingKHR", (void*)CmdBeginVideoCodingKHR}, + {"vkCmdEndVideoCodingKHR", (void*)CmdEndVideoCodingKHR}, + {"vkCmdControlVideoCodingKHR", (void*)CmdControlVideoCodingKHR}, + {"vkCmdDecodeVideoKHR", (void*)CmdDecodeVideoKHR}, + {"vkCmdBeginRenderingKHR", (void*)CmdBeginRenderingKHR}, + {"vkCmdEndRenderingKHR", (void*)CmdEndRenderingKHR}, + {"vkGetPhysicalDeviceFeatures2KHR", (void*)GetPhysicalDeviceFeatures2KHR}, + {"vkGetPhysicalDeviceProperties2KHR", (void*)GetPhysicalDeviceProperties2KHR}, + {"vkGetPhysicalDeviceFormatProperties2KHR", (void*)GetPhysicalDeviceFormatProperties2KHR}, + {"vkGetPhysicalDeviceImageFormatProperties2KHR", (void*)GetPhysicalDeviceImageFormatProperties2KHR}, + {"vkGetPhysicalDeviceQueueFamilyProperties2KHR", (void*)GetPhysicalDeviceQueueFamilyProperties2KHR}, + {"vkGetPhysicalDeviceMemoryProperties2KHR", (void*)GetPhysicalDeviceMemoryProperties2KHR}, + {"vkGetPhysicalDeviceSparseImageFormatProperties2KHR", (void*)GetPhysicalDeviceSparseImageFormatProperties2KHR}, + {"vkGetDeviceGroupPeerMemoryFeaturesKHR", (void*)GetDeviceGroupPeerMemoryFeaturesKHR}, + {"vkCmdSetDeviceMaskKHR", (void*)CmdSetDeviceMaskKHR}, + {"vkCmdDispatchBaseKHR", (void*)CmdDispatchBaseKHR}, + {"vkTrimCommandPoolKHR", (void*)TrimCommandPoolKHR}, + {"vkEnumeratePhysicalDeviceGroupsKHR", (void*)EnumeratePhysicalDeviceGroupsKHR}, + {"vkGetPhysicalDeviceExternalBufferPropertiesKHR", (void*)GetPhysicalDeviceExternalBufferPropertiesKHR}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetMemoryWin32HandleKHR", (void*)GetMemoryWin32HandleKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetMemoryWin32HandlePropertiesKHR", (void*)GetMemoryWin32HandlePropertiesKHR}, +#endif + {"vkGetMemoryFdKHR", (void*)GetMemoryFdKHR}, + {"vkGetMemoryFdPropertiesKHR", (void*)GetMemoryFdPropertiesKHR}, + {"vkGetPhysicalDeviceExternalSemaphorePropertiesKHR", (void*)GetPhysicalDeviceExternalSemaphorePropertiesKHR}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkImportSemaphoreWin32HandleKHR", (void*)ImportSemaphoreWin32HandleKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetSemaphoreWin32HandleKHR", (void*)GetSemaphoreWin32HandleKHR}, +#endif + {"vkImportSemaphoreFdKHR", (void*)ImportSemaphoreFdKHR}, + {"vkGetSemaphoreFdKHR", (void*)GetSemaphoreFdKHR}, + {"vkCmdPushDescriptorSetKHR", (void*)CmdPushDescriptorSetKHR}, + {"vkCmdPushDescriptorSetWithTemplateKHR", (void*)CmdPushDescriptorSetWithTemplateKHR}, + {"vkCreateDescriptorUpdateTemplateKHR", (void*)CreateDescriptorUpdateTemplateKHR}, + {"vkDestroyDescriptorUpdateTemplateKHR", (void*)DestroyDescriptorUpdateTemplateKHR}, + {"vkUpdateDescriptorSetWithTemplateKHR", (void*)UpdateDescriptorSetWithTemplateKHR}, + {"vkCreateRenderPass2KHR", (void*)CreateRenderPass2KHR}, + {"vkCmdBeginRenderPass2KHR", (void*)CmdBeginRenderPass2KHR}, + {"vkCmdNextSubpass2KHR", (void*)CmdNextSubpass2KHR}, + {"vkCmdEndRenderPass2KHR", (void*)CmdEndRenderPass2KHR}, + {"vkGetSwapchainStatusKHR", (void*)GetSwapchainStatusKHR}, + {"vkGetPhysicalDeviceExternalFencePropertiesKHR", (void*)GetPhysicalDeviceExternalFencePropertiesKHR}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkImportFenceWin32HandleKHR", (void*)ImportFenceWin32HandleKHR}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetFenceWin32HandleKHR", (void*)GetFenceWin32HandleKHR}, +#endif + {"vkImportFenceFdKHR", (void*)ImportFenceFdKHR}, + {"vkGetFenceFdKHR", (void*)GetFenceFdKHR}, + {"vkEnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR", (void*)EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR}, + {"vkGetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR", (void*)GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR}, + {"vkAcquireProfilingLockKHR", (void*)AcquireProfilingLockKHR}, + {"vkReleaseProfilingLockKHR", (void*)ReleaseProfilingLockKHR}, + {"vkGetPhysicalDeviceSurfaceCapabilities2KHR", (void*)GetPhysicalDeviceSurfaceCapabilities2KHR}, + {"vkGetPhysicalDeviceSurfaceFormats2KHR", (void*)GetPhysicalDeviceSurfaceFormats2KHR}, + {"vkGetPhysicalDeviceDisplayProperties2KHR", (void*)GetPhysicalDeviceDisplayProperties2KHR}, + {"vkGetPhysicalDeviceDisplayPlaneProperties2KHR", (void*)GetPhysicalDeviceDisplayPlaneProperties2KHR}, + {"vkGetDisplayModeProperties2KHR", (void*)GetDisplayModeProperties2KHR}, + {"vkGetDisplayPlaneCapabilities2KHR", (void*)GetDisplayPlaneCapabilities2KHR}, + {"vkGetImageMemoryRequirements2KHR", (void*)GetImageMemoryRequirements2KHR}, + {"vkGetBufferMemoryRequirements2KHR", (void*)GetBufferMemoryRequirements2KHR}, + {"vkGetImageSparseMemoryRequirements2KHR", (void*)GetImageSparseMemoryRequirements2KHR}, + {"vkCreateSamplerYcbcrConversionKHR", (void*)CreateSamplerYcbcrConversionKHR}, + {"vkDestroySamplerYcbcrConversionKHR", (void*)DestroySamplerYcbcrConversionKHR}, + {"vkBindBufferMemory2KHR", (void*)BindBufferMemory2KHR}, + {"vkBindImageMemory2KHR", (void*)BindImageMemory2KHR}, + {"vkGetDescriptorSetLayoutSupportKHR", (void*)GetDescriptorSetLayoutSupportKHR}, + {"vkCmdDrawIndirectCountKHR", (void*)CmdDrawIndirectCountKHR}, + {"vkCmdDrawIndexedIndirectCountKHR", (void*)CmdDrawIndexedIndirectCountKHR}, + {"vkGetSemaphoreCounterValueKHR", (void*)GetSemaphoreCounterValueKHR}, + {"vkWaitSemaphoresKHR", (void*)WaitSemaphoresKHR}, + {"vkSignalSemaphoreKHR", (void*)SignalSemaphoreKHR}, + {"vkGetPhysicalDeviceFragmentShadingRatesKHR", (void*)GetPhysicalDeviceFragmentShadingRatesKHR}, + {"vkCmdSetFragmentShadingRateKHR", (void*)CmdSetFragmentShadingRateKHR}, + {"vkWaitForPresentKHR", (void*)WaitForPresentKHR}, + {"vkGetBufferDeviceAddressKHR", (void*)GetBufferDeviceAddressKHR}, + {"vkGetBufferOpaqueCaptureAddressKHR", (void*)GetBufferOpaqueCaptureAddressKHR}, + {"vkGetDeviceMemoryOpaqueCaptureAddressKHR", (void*)GetDeviceMemoryOpaqueCaptureAddressKHR}, + {"vkCreateDeferredOperationKHR", (void*)CreateDeferredOperationKHR}, + {"vkDestroyDeferredOperationKHR", (void*)DestroyDeferredOperationKHR}, + {"vkGetDeferredOperationMaxConcurrencyKHR", (void*)GetDeferredOperationMaxConcurrencyKHR}, + {"vkGetDeferredOperationResultKHR", (void*)GetDeferredOperationResultKHR}, + {"vkDeferredOperationJoinKHR", (void*)DeferredOperationJoinKHR}, + {"vkGetPipelineExecutablePropertiesKHR", (void*)GetPipelineExecutablePropertiesKHR}, + {"vkGetPipelineExecutableStatisticsKHR", (void*)GetPipelineExecutableStatisticsKHR}, + {"vkGetPipelineExecutableInternalRepresentationsKHR", (void*)GetPipelineExecutableInternalRepresentationsKHR}, + {"vkMapMemory2KHR", (void*)MapMemory2KHR}, + {"vkUnmapMemory2KHR", (void*)UnmapMemory2KHR}, +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkGetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR", (void*)GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkGetEncodedVideoSessionParametersKHR", (void*)GetEncodedVideoSessionParametersKHR}, +#endif +#ifdef VK_ENABLE_BETA_EXTENSIONS + {"vkCmdEncodeVideoKHR", (void*)CmdEncodeVideoKHR}, +#endif + {"vkCmdSetEvent2KHR", (void*)CmdSetEvent2KHR}, + {"vkCmdResetEvent2KHR", (void*)CmdResetEvent2KHR}, + {"vkCmdWaitEvents2KHR", (void*)CmdWaitEvents2KHR}, + {"vkCmdPipelineBarrier2KHR", (void*)CmdPipelineBarrier2KHR}, + {"vkCmdWriteTimestamp2KHR", (void*)CmdWriteTimestamp2KHR}, + {"vkQueueSubmit2KHR", (void*)QueueSubmit2KHR}, + {"vkCmdWriteBufferMarker2AMD", (void*)CmdWriteBufferMarker2AMD}, + {"vkGetQueueCheckpointData2NV", (void*)GetQueueCheckpointData2NV}, + {"vkCmdCopyBuffer2KHR", (void*)CmdCopyBuffer2KHR}, + {"vkCmdCopyImage2KHR", (void*)CmdCopyImage2KHR}, + {"vkCmdCopyBufferToImage2KHR", (void*)CmdCopyBufferToImage2KHR}, + {"vkCmdCopyImageToBuffer2KHR", (void*)CmdCopyImageToBuffer2KHR}, + {"vkCmdBlitImage2KHR", (void*)CmdBlitImage2KHR}, + {"vkCmdResolveImage2KHR", (void*)CmdResolveImage2KHR}, + {"vkCmdTraceRaysIndirect2KHR", (void*)CmdTraceRaysIndirect2KHR}, + {"vkGetDeviceBufferMemoryRequirementsKHR", (void*)GetDeviceBufferMemoryRequirementsKHR}, + {"vkGetDeviceImageMemoryRequirementsKHR", (void*)GetDeviceImageMemoryRequirementsKHR}, + {"vkGetDeviceImageSparseMemoryRequirementsKHR", (void*)GetDeviceImageSparseMemoryRequirementsKHR}, + {"vkCreateDebugReportCallbackEXT", (void*)CreateDebugReportCallbackEXT}, + {"vkDestroyDebugReportCallbackEXT", (void*)DestroyDebugReportCallbackEXT}, + {"vkDebugReportMessageEXT", (void*)DebugReportMessageEXT}, + {"vkDebugMarkerSetObjectTagEXT", (void*)DebugMarkerSetObjectTagEXT}, + {"vkDebugMarkerSetObjectNameEXT", (void*)DebugMarkerSetObjectNameEXT}, + {"vkCmdDebugMarkerBeginEXT", (void*)CmdDebugMarkerBeginEXT}, + {"vkCmdDebugMarkerEndEXT", (void*)CmdDebugMarkerEndEXT}, + {"vkCmdDebugMarkerInsertEXT", (void*)CmdDebugMarkerInsertEXT}, + {"vkCmdBindTransformFeedbackBuffersEXT", (void*)CmdBindTransformFeedbackBuffersEXT}, + {"vkCmdBeginTransformFeedbackEXT", (void*)CmdBeginTransformFeedbackEXT}, + {"vkCmdEndTransformFeedbackEXT", (void*)CmdEndTransformFeedbackEXT}, + {"vkCmdBeginQueryIndexedEXT", (void*)CmdBeginQueryIndexedEXT}, + {"vkCmdEndQueryIndexedEXT", (void*)CmdEndQueryIndexedEXT}, + {"vkCmdDrawIndirectByteCountEXT", (void*)CmdDrawIndirectByteCountEXT}, + {"vkCreateCuModuleNVX", (void*)CreateCuModuleNVX}, + {"vkCreateCuFunctionNVX", (void*)CreateCuFunctionNVX}, + {"vkDestroyCuModuleNVX", (void*)DestroyCuModuleNVX}, + {"vkDestroyCuFunctionNVX", (void*)DestroyCuFunctionNVX}, + {"vkCmdCuLaunchKernelNVX", (void*)CmdCuLaunchKernelNVX}, + {"vkGetImageViewHandleNVX", (void*)GetImageViewHandleNVX}, + {"vkGetImageViewAddressNVX", (void*)GetImageViewAddressNVX}, + {"vkCmdDrawIndirectCountAMD", (void*)CmdDrawIndirectCountAMD}, + {"vkCmdDrawIndexedIndirectCountAMD", (void*)CmdDrawIndexedIndirectCountAMD}, + {"vkGetShaderInfoAMD", (void*)GetShaderInfoAMD}, +#ifdef VK_USE_PLATFORM_GGP + {"vkCreateStreamDescriptorSurfaceGGP", (void*)CreateStreamDescriptorSurfaceGGP}, +#endif + {"vkGetPhysicalDeviceExternalImageFormatPropertiesNV", (void*)GetPhysicalDeviceExternalImageFormatPropertiesNV}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetMemoryWin32HandleNV", (void*)GetMemoryWin32HandleNV}, +#endif +#ifdef VK_USE_PLATFORM_VI_NN + {"vkCreateViSurfaceNN", (void*)CreateViSurfaceNN}, +#endif + {"vkCmdBeginConditionalRenderingEXT", (void*)CmdBeginConditionalRenderingEXT}, + {"vkCmdEndConditionalRenderingEXT", (void*)CmdEndConditionalRenderingEXT}, + {"vkCmdSetViewportWScalingNV", (void*)CmdSetViewportWScalingNV}, + {"vkReleaseDisplayEXT", (void*)ReleaseDisplayEXT}, +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + {"vkAcquireXlibDisplayEXT", (void*)AcquireXlibDisplayEXT}, +#endif +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + {"vkGetRandROutputDisplayEXT", (void*)GetRandROutputDisplayEXT}, +#endif + {"vkGetPhysicalDeviceSurfaceCapabilities2EXT", (void*)GetPhysicalDeviceSurfaceCapabilities2EXT}, + {"vkDisplayPowerControlEXT", (void*)DisplayPowerControlEXT}, + {"vkRegisterDeviceEventEXT", (void*)RegisterDeviceEventEXT}, + {"vkRegisterDisplayEventEXT", (void*)RegisterDisplayEventEXT}, + {"vkGetSwapchainCounterEXT", (void*)GetSwapchainCounterEXT}, + {"vkGetRefreshCycleDurationGOOGLE", (void*)GetRefreshCycleDurationGOOGLE}, + {"vkGetPastPresentationTimingGOOGLE", (void*)GetPastPresentationTimingGOOGLE}, + {"vkCmdSetDiscardRectangleEXT", (void*)CmdSetDiscardRectangleEXT}, + {"vkCmdSetDiscardRectangleEnableEXT", (void*)CmdSetDiscardRectangleEnableEXT}, + {"vkCmdSetDiscardRectangleModeEXT", (void*)CmdSetDiscardRectangleModeEXT}, + {"vkSetHdrMetadataEXT", (void*)SetHdrMetadataEXT}, +#ifdef VK_USE_PLATFORM_IOS_MVK + {"vkCreateIOSSurfaceMVK", (void*)CreateIOSSurfaceMVK}, +#endif +#ifdef VK_USE_PLATFORM_MACOS_MVK + {"vkCreateMacOSSurfaceMVK", (void*)CreateMacOSSurfaceMVK}, +#endif + {"vkSetDebugUtilsObjectNameEXT", (void*)SetDebugUtilsObjectNameEXT}, + {"vkSetDebugUtilsObjectTagEXT", (void*)SetDebugUtilsObjectTagEXT}, + {"vkQueueBeginDebugUtilsLabelEXT", (void*)QueueBeginDebugUtilsLabelEXT}, + {"vkQueueEndDebugUtilsLabelEXT", (void*)QueueEndDebugUtilsLabelEXT}, + {"vkQueueInsertDebugUtilsLabelEXT", (void*)QueueInsertDebugUtilsLabelEXT}, + {"vkCmdBeginDebugUtilsLabelEXT", (void*)CmdBeginDebugUtilsLabelEXT}, + {"vkCmdEndDebugUtilsLabelEXT", (void*)CmdEndDebugUtilsLabelEXT}, + {"vkCmdInsertDebugUtilsLabelEXT", (void*)CmdInsertDebugUtilsLabelEXT}, + {"vkCreateDebugUtilsMessengerEXT", (void*)CreateDebugUtilsMessengerEXT}, + {"vkDestroyDebugUtilsMessengerEXT", (void*)DestroyDebugUtilsMessengerEXT}, + {"vkSubmitDebugUtilsMessageEXT", (void*)SubmitDebugUtilsMessageEXT}, +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"vkGetAndroidHardwareBufferPropertiesANDROID", (void*)GetAndroidHardwareBufferPropertiesANDROID}, +#endif +#ifdef VK_USE_PLATFORM_ANDROID_KHR + {"vkGetMemoryAndroidHardwareBufferANDROID", (void*)GetMemoryAndroidHardwareBufferANDROID}, +#endif + {"vkCmdSetSampleLocationsEXT", (void*)CmdSetSampleLocationsEXT}, + {"vkGetPhysicalDeviceMultisamplePropertiesEXT", (void*)GetPhysicalDeviceMultisamplePropertiesEXT}, + {"vkGetImageDrmFormatModifierPropertiesEXT", (void*)GetImageDrmFormatModifierPropertiesEXT}, + {"vkCreateValidationCacheEXT", (void*)CreateValidationCacheEXT}, + {"vkDestroyValidationCacheEXT", (void*)DestroyValidationCacheEXT}, + {"vkMergeValidationCachesEXT", (void*)MergeValidationCachesEXT}, + {"vkGetValidationCacheDataEXT", (void*)GetValidationCacheDataEXT}, + {"vkCmdBindShadingRateImageNV", (void*)CmdBindShadingRateImageNV}, + {"vkCmdSetViewportShadingRatePaletteNV", (void*)CmdSetViewportShadingRatePaletteNV}, + {"vkCmdSetCoarseSampleOrderNV", (void*)CmdSetCoarseSampleOrderNV}, + {"vkCreateAccelerationStructureNV", (void*)CreateAccelerationStructureNV}, + {"vkDestroyAccelerationStructureNV", (void*)DestroyAccelerationStructureNV}, + {"vkGetAccelerationStructureMemoryRequirementsNV", (void*)GetAccelerationStructureMemoryRequirementsNV}, + {"vkBindAccelerationStructureMemoryNV", (void*)BindAccelerationStructureMemoryNV}, + {"vkCmdBuildAccelerationStructureNV", (void*)CmdBuildAccelerationStructureNV}, + {"vkCmdCopyAccelerationStructureNV", (void*)CmdCopyAccelerationStructureNV}, + {"vkCmdTraceRaysNV", (void*)CmdTraceRaysNV}, + {"vkCreateRayTracingPipelinesNV", (void*)CreateRayTracingPipelinesNV}, + {"vkGetRayTracingShaderGroupHandlesKHR", (void*)GetRayTracingShaderGroupHandlesKHR}, + {"vkGetRayTracingShaderGroupHandlesNV", (void*)GetRayTracingShaderGroupHandlesNV}, + {"vkGetAccelerationStructureHandleNV", (void*)GetAccelerationStructureHandleNV}, + {"vkCmdWriteAccelerationStructuresPropertiesNV", (void*)CmdWriteAccelerationStructuresPropertiesNV}, + {"vkCompileDeferredNV", (void*)CompileDeferredNV}, + {"vkGetMemoryHostPointerPropertiesEXT", (void*)GetMemoryHostPointerPropertiesEXT}, + {"vkCmdWriteBufferMarkerAMD", (void*)CmdWriteBufferMarkerAMD}, + {"vkGetPhysicalDeviceCalibrateableTimeDomainsEXT", (void*)GetPhysicalDeviceCalibrateableTimeDomainsEXT}, + {"vkGetCalibratedTimestampsEXT", (void*)GetCalibratedTimestampsEXT}, + {"vkCmdDrawMeshTasksNV", (void*)CmdDrawMeshTasksNV}, + {"vkCmdDrawMeshTasksIndirectNV", (void*)CmdDrawMeshTasksIndirectNV}, + {"vkCmdDrawMeshTasksIndirectCountNV", (void*)CmdDrawMeshTasksIndirectCountNV}, + {"vkCmdSetExclusiveScissorEnableNV", (void*)CmdSetExclusiveScissorEnableNV}, + {"vkCmdSetExclusiveScissorNV", (void*)CmdSetExclusiveScissorNV}, + {"vkCmdSetCheckpointNV", (void*)CmdSetCheckpointNV}, + {"vkGetQueueCheckpointDataNV", (void*)GetQueueCheckpointDataNV}, + {"vkInitializePerformanceApiINTEL", (void*)InitializePerformanceApiINTEL}, + {"vkUninitializePerformanceApiINTEL", (void*)UninitializePerformanceApiINTEL}, + {"vkCmdSetPerformanceMarkerINTEL", (void*)CmdSetPerformanceMarkerINTEL}, + {"vkCmdSetPerformanceStreamMarkerINTEL", (void*)CmdSetPerformanceStreamMarkerINTEL}, + {"vkCmdSetPerformanceOverrideINTEL", (void*)CmdSetPerformanceOverrideINTEL}, + {"vkAcquirePerformanceConfigurationINTEL", (void*)AcquirePerformanceConfigurationINTEL}, + {"vkReleasePerformanceConfigurationINTEL", (void*)ReleasePerformanceConfigurationINTEL}, + {"vkQueueSetPerformanceConfigurationINTEL", (void*)QueueSetPerformanceConfigurationINTEL}, + {"vkGetPerformanceParameterINTEL", (void*)GetPerformanceParameterINTEL}, + {"vkSetLocalDimmingAMD", (void*)SetLocalDimmingAMD}, +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkCreateImagePipeSurfaceFUCHSIA", (void*)CreateImagePipeSurfaceFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_METAL_EXT + {"vkCreateMetalSurfaceEXT", (void*)CreateMetalSurfaceEXT}, +#endif + {"vkGetBufferDeviceAddressEXT", (void*)GetBufferDeviceAddressEXT}, + {"vkGetPhysicalDeviceToolPropertiesEXT", (void*)GetPhysicalDeviceToolPropertiesEXT}, + {"vkGetPhysicalDeviceCooperativeMatrixPropertiesNV", (void*)GetPhysicalDeviceCooperativeMatrixPropertiesNV}, + {"vkGetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV", (void*)GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetPhysicalDeviceSurfacePresentModes2EXT", (void*)GetPhysicalDeviceSurfacePresentModes2EXT}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkAcquireFullScreenExclusiveModeEXT", (void*)AcquireFullScreenExclusiveModeEXT}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkReleaseFullScreenExclusiveModeEXT", (void*)ReleaseFullScreenExclusiveModeEXT}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetDeviceGroupSurfacePresentModes2EXT", (void*)GetDeviceGroupSurfacePresentModes2EXT}, +#endif + {"vkCreateHeadlessSurfaceEXT", (void*)CreateHeadlessSurfaceEXT}, + {"vkCmdSetLineStippleEXT", (void*)CmdSetLineStippleEXT}, + {"vkResetQueryPoolEXT", (void*)ResetQueryPoolEXT}, + {"vkCmdSetCullModeEXT", (void*)CmdSetCullModeEXT}, + {"vkCmdSetFrontFaceEXT", (void*)CmdSetFrontFaceEXT}, + {"vkCmdSetPrimitiveTopologyEXT", (void*)CmdSetPrimitiveTopologyEXT}, + {"vkCmdSetViewportWithCountEXT", (void*)CmdSetViewportWithCountEXT}, + {"vkCmdSetScissorWithCountEXT", (void*)CmdSetScissorWithCountEXT}, + {"vkCmdBindVertexBuffers2EXT", (void*)CmdBindVertexBuffers2EXT}, + {"vkCmdSetDepthTestEnableEXT", (void*)CmdSetDepthTestEnableEXT}, + {"vkCmdSetDepthWriteEnableEXT", (void*)CmdSetDepthWriteEnableEXT}, + {"vkCmdSetDepthCompareOpEXT", (void*)CmdSetDepthCompareOpEXT}, + {"vkCmdSetDepthBoundsTestEnableEXT", (void*)CmdSetDepthBoundsTestEnableEXT}, + {"vkCmdSetStencilTestEnableEXT", (void*)CmdSetStencilTestEnableEXT}, + {"vkCmdSetStencilOpEXT", (void*)CmdSetStencilOpEXT}, + {"vkReleaseSwapchainImagesEXT", (void*)ReleaseSwapchainImagesEXT}, + {"vkGetGeneratedCommandsMemoryRequirementsNV", (void*)GetGeneratedCommandsMemoryRequirementsNV}, + {"vkCmdPreprocessGeneratedCommandsNV", (void*)CmdPreprocessGeneratedCommandsNV}, + {"vkCmdExecuteGeneratedCommandsNV", (void*)CmdExecuteGeneratedCommandsNV}, + {"vkCmdBindPipelineShaderGroupNV", (void*)CmdBindPipelineShaderGroupNV}, + {"vkCreateIndirectCommandsLayoutNV", (void*)CreateIndirectCommandsLayoutNV}, + {"vkDestroyIndirectCommandsLayoutNV", (void*)DestroyIndirectCommandsLayoutNV}, + {"vkCmdSetDepthBias2EXT", (void*)CmdSetDepthBias2EXT}, + {"vkAcquireDrmDisplayEXT", (void*)AcquireDrmDisplayEXT}, + {"vkGetDrmDisplayEXT", (void*)GetDrmDisplayEXT}, + {"vkCreatePrivateDataSlotEXT", (void*)CreatePrivateDataSlotEXT}, + {"vkDestroyPrivateDataSlotEXT", (void*)DestroyPrivateDataSlotEXT}, + {"vkSetPrivateDataEXT", (void*)SetPrivateDataEXT}, + {"vkGetPrivateDataEXT", (void*)GetPrivateDataEXT}, +#ifdef VK_USE_PLATFORM_METAL_EXT + {"vkExportMetalObjectsEXT", (void*)ExportMetalObjectsEXT}, +#endif + {"vkGetDescriptorSetLayoutSizeEXT", (void*)GetDescriptorSetLayoutSizeEXT}, + {"vkGetDescriptorSetLayoutBindingOffsetEXT", (void*)GetDescriptorSetLayoutBindingOffsetEXT}, + {"vkGetDescriptorEXT", (void*)GetDescriptorEXT}, + {"vkCmdBindDescriptorBuffersEXT", (void*)CmdBindDescriptorBuffersEXT}, + {"vkCmdSetDescriptorBufferOffsetsEXT", (void*)CmdSetDescriptorBufferOffsetsEXT}, + {"vkCmdBindDescriptorBufferEmbeddedSamplersEXT", (void*)CmdBindDescriptorBufferEmbeddedSamplersEXT}, + {"vkGetBufferOpaqueCaptureDescriptorDataEXT", (void*)GetBufferOpaqueCaptureDescriptorDataEXT}, + {"vkGetImageOpaqueCaptureDescriptorDataEXT", (void*)GetImageOpaqueCaptureDescriptorDataEXT}, + {"vkGetImageViewOpaqueCaptureDescriptorDataEXT", (void*)GetImageViewOpaqueCaptureDescriptorDataEXT}, + {"vkGetSamplerOpaqueCaptureDescriptorDataEXT", (void*)GetSamplerOpaqueCaptureDescriptorDataEXT}, + {"vkGetAccelerationStructureOpaqueCaptureDescriptorDataEXT", (void*)GetAccelerationStructureOpaqueCaptureDescriptorDataEXT}, + {"vkCmdSetFragmentShadingRateEnumNV", (void*)CmdSetFragmentShadingRateEnumNV}, + {"vkGetImageSubresourceLayout2EXT", (void*)GetImageSubresourceLayout2EXT}, + {"vkGetDeviceFaultInfoEXT", (void*)GetDeviceFaultInfoEXT}, +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkAcquireWinrtDisplayNV", (void*)AcquireWinrtDisplayNV}, +#endif +#ifdef VK_USE_PLATFORM_WIN32_KHR + {"vkGetWinrtDisplayNV", (void*)GetWinrtDisplayNV}, +#endif +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + {"vkCreateDirectFBSurfaceEXT", (void*)CreateDirectFBSurfaceEXT}, +#endif +#ifdef VK_USE_PLATFORM_DIRECTFB_EXT + {"vkGetPhysicalDeviceDirectFBPresentationSupportEXT", (void*)GetPhysicalDeviceDirectFBPresentationSupportEXT}, +#endif + {"vkCmdSetVertexInputEXT", (void*)CmdSetVertexInputEXT}, +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkGetMemoryZirconHandleFUCHSIA", (void*)GetMemoryZirconHandleFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkGetMemoryZirconHandlePropertiesFUCHSIA", (void*)GetMemoryZirconHandlePropertiesFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkImportSemaphoreZirconHandleFUCHSIA", (void*)ImportSemaphoreZirconHandleFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkGetSemaphoreZirconHandleFUCHSIA", (void*)GetSemaphoreZirconHandleFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkCreateBufferCollectionFUCHSIA", (void*)CreateBufferCollectionFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkSetBufferCollectionImageConstraintsFUCHSIA", (void*)SetBufferCollectionImageConstraintsFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkSetBufferCollectionBufferConstraintsFUCHSIA", (void*)SetBufferCollectionBufferConstraintsFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkDestroyBufferCollectionFUCHSIA", (void*)DestroyBufferCollectionFUCHSIA}, +#endif +#ifdef VK_USE_PLATFORM_FUCHSIA + {"vkGetBufferCollectionPropertiesFUCHSIA", (void*)GetBufferCollectionPropertiesFUCHSIA}, +#endif + {"vkGetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI", (void*)GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI}, + {"vkCmdSubpassShadingHUAWEI", (void*)CmdSubpassShadingHUAWEI}, + {"vkCmdBindInvocationMaskHUAWEI", (void*)CmdBindInvocationMaskHUAWEI}, + {"vkGetMemoryRemoteAddressNV", (void*)GetMemoryRemoteAddressNV}, + {"vkGetPipelinePropertiesEXT", (void*)GetPipelinePropertiesEXT}, + {"vkCmdSetPatchControlPointsEXT", (void*)CmdSetPatchControlPointsEXT}, + {"vkCmdSetRasterizerDiscardEnableEXT", (void*)CmdSetRasterizerDiscardEnableEXT}, + {"vkCmdSetDepthBiasEnableEXT", (void*)CmdSetDepthBiasEnableEXT}, + {"vkCmdSetLogicOpEXT", (void*)CmdSetLogicOpEXT}, + {"vkCmdSetPrimitiveRestartEnableEXT", (void*)CmdSetPrimitiveRestartEnableEXT}, +#ifdef VK_USE_PLATFORM_SCREEN_QNX + {"vkCreateScreenSurfaceQNX", (void*)CreateScreenSurfaceQNX}, +#endif +#ifdef VK_USE_PLATFORM_SCREEN_QNX + {"vkGetPhysicalDeviceScreenPresentationSupportQNX", (void*)GetPhysicalDeviceScreenPresentationSupportQNX}, +#endif + {"vkCmdSetColorWriteEnableEXT", (void*)CmdSetColorWriteEnableEXT}, + {"vkCmdDrawMultiEXT", (void*)CmdDrawMultiEXT}, + {"vkCmdDrawMultiIndexedEXT", (void*)CmdDrawMultiIndexedEXT}, + {"vkCreateMicromapEXT", (void*)CreateMicromapEXT}, + {"vkDestroyMicromapEXT", (void*)DestroyMicromapEXT}, + {"vkCmdBuildMicromapsEXT", (void*)CmdBuildMicromapsEXT}, + {"vkBuildMicromapsEXT", (void*)BuildMicromapsEXT}, + {"vkCopyMicromapEXT", (void*)CopyMicromapEXT}, + {"vkCopyMicromapToMemoryEXT", (void*)CopyMicromapToMemoryEXT}, + {"vkCopyMemoryToMicromapEXT", (void*)CopyMemoryToMicromapEXT}, + {"vkWriteMicromapsPropertiesEXT", (void*)WriteMicromapsPropertiesEXT}, + {"vkCmdCopyMicromapEXT", (void*)CmdCopyMicromapEXT}, + {"vkCmdCopyMicromapToMemoryEXT", (void*)CmdCopyMicromapToMemoryEXT}, + {"vkCmdCopyMemoryToMicromapEXT", (void*)CmdCopyMemoryToMicromapEXT}, + {"vkCmdWriteMicromapsPropertiesEXT", (void*)CmdWriteMicromapsPropertiesEXT}, + {"vkGetDeviceMicromapCompatibilityEXT", (void*)GetDeviceMicromapCompatibilityEXT}, + {"vkGetMicromapBuildSizesEXT", (void*)GetMicromapBuildSizesEXT}, + {"vkCmdDrawClusterHUAWEI", (void*)CmdDrawClusterHUAWEI}, + {"vkCmdDrawClusterIndirectHUAWEI", (void*)CmdDrawClusterIndirectHUAWEI}, + {"vkSetDeviceMemoryPriorityEXT", (void*)SetDeviceMemoryPriorityEXT}, + {"vkGetDescriptorSetLayoutHostMappingInfoVALVE", (void*)GetDescriptorSetLayoutHostMappingInfoVALVE}, + {"vkGetDescriptorSetHostMappingVALVE", (void*)GetDescriptorSetHostMappingVALVE}, + {"vkCmdCopyMemoryIndirectNV", (void*)CmdCopyMemoryIndirectNV}, + {"vkCmdCopyMemoryToImageIndirectNV", (void*)CmdCopyMemoryToImageIndirectNV}, + {"vkCmdDecompressMemoryNV", (void*)CmdDecompressMemoryNV}, + {"vkCmdDecompressMemoryIndirectCountNV", (void*)CmdDecompressMemoryIndirectCountNV}, + {"vkCmdSetTessellationDomainOriginEXT", (void*)CmdSetTessellationDomainOriginEXT}, + {"vkCmdSetDepthClampEnableEXT", (void*)CmdSetDepthClampEnableEXT}, + {"vkCmdSetPolygonModeEXT", (void*)CmdSetPolygonModeEXT}, + {"vkCmdSetRasterizationSamplesEXT", (void*)CmdSetRasterizationSamplesEXT}, + {"vkCmdSetSampleMaskEXT", (void*)CmdSetSampleMaskEXT}, + {"vkCmdSetAlphaToCoverageEnableEXT", (void*)CmdSetAlphaToCoverageEnableEXT}, + {"vkCmdSetAlphaToOneEnableEXT", (void*)CmdSetAlphaToOneEnableEXT}, + {"vkCmdSetLogicOpEnableEXT", (void*)CmdSetLogicOpEnableEXT}, + {"vkCmdSetColorBlendEnableEXT", (void*)CmdSetColorBlendEnableEXT}, + {"vkCmdSetColorBlendEquationEXT", (void*)CmdSetColorBlendEquationEXT}, + {"vkCmdSetColorWriteMaskEXT", (void*)CmdSetColorWriteMaskEXT}, + {"vkCmdSetRasterizationStreamEXT", (void*)CmdSetRasterizationStreamEXT}, + {"vkCmdSetConservativeRasterizationModeEXT", (void*)CmdSetConservativeRasterizationModeEXT}, + {"vkCmdSetExtraPrimitiveOverestimationSizeEXT", (void*)CmdSetExtraPrimitiveOverestimationSizeEXT}, + {"vkCmdSetDepthClipEnableEXT", (void*)CmdSetDepthClipEnableEXT}, + {"vkCmdSetSampleLocationsEnableEXT", (void*)CmdSetSampleLocationsEnableEXT}, + {"vkCmdSetColorBlendAdvancedEXT", (void*)CmdSetColorBlendAdvancedEXT}, + {"vkCmdSetProvokingVertexModeEXT", (void*)CmdSetProvokingVertexModeEXT}, + {"vkCmdSetLineRasterizationModeEXT", (void*)CmdSetLineRasterizationModeEXT}, + {"vkCmdSetLineStippleEnableEXT", (void*)CmdSetLineStippleEnableEXT}, + {"vkCmdSetDepthClipNegativeOneToOneEXT", (void*)CmdSetDepthClipNegativeOneToOneEXT}, + {"vkCmdSetViewportWScalingEnableNV", (void*)CmdSetViewportWScalingEnableNV}, + {"vkCmdSetViewportSwizzleNV", (void*)CmdSetViewportSwizzleNV}, + {"vkCmdSetCoverageToColorEnableNV", (void*)CmdSetCoverageToColorEnableNV}, + {"vkCmdSetCoverageToColorLocationNV", (void*)CmdSetCoverageToColorLocationNV}, + {"vkCmdSetCoverageModulationModeNV", (void*)CmdSetCoverageModulationModeNV}, + {"vkCmdSetCoverageModulationTableEnableNV", (void*)CmdSetCoverageModulationTableEnableNV}, + {"vkCmdSetCoverageModulationTableNV", (void*)CmdSetCoverageModulationTableNV}, + {"vkCmdSetShadingRateImageEnableNV", (void*)CmdSetShadingRateImageEnableNV}, + {"vkCmdSetRepresentativeFragmentTestEnableNV", (void*)CmdSetRepresentativeFragmentTestEnableNV}, + {"vkCmdSetCoverageReductionModeNV", (void*)CmdSetCoverageReductionModeNV}, + {"vkGetShaderModuleIdentifierEXT", (void*)GetShaderModuleIdentifierEXT}, + {"vkGetShaderModuleCreateInfoIdentifierEXT", (void*)GetShaderModuleCreateInfoIdentifierEXT}, + {"vkGetPhysicalDeviceOpticalFlowImageFormatsNV", (void*)GetPhysicalDeviceOpticalFlowImageFormatsNV}, + {"vkCreateOpticalFlowSessionNV", (void*)CreateOpticalFlowSessionNV}, + {"vkDestroyOpticalFlowSessionNV", (void*)DestroyOpticalFlowSessionNV}, + {"vkBindOpticalFlowSessionImageNV", (void*)BindOpticalFlowSessionImageNV}, + {"vkCmdOpticalFlowExecuteNV", (void*)CmdOpticalFlowExecuteNV}, + {"vkCreateShadersEXT", (void*)CreateShadersEXT}, + {"vkDestroyShaderEXT", (void*)DestroyShaderEXT}, + {"vkGetShaderBinaryDataEXT", (void*)GetShaderBinaryDataEXT}, + {"vkCmdBindShadersEXT", (void*)CmdBindShadersEXT}, + {"vkGetFramebufferTilePropertiesQCOM", (void*)GetFramebufferTilePropertiesQCOM}, + {"vkGetDynamicRenderingTilePropertiesQCOM", (void*)GetDynamicRenderingTilePropertiesQCOM}, + {"vkCmdSetAttachmentFeedbackLoopEnableEXT", (void*)CmdSetAttachmentFeedbackLoopEnableEXT}, +#ifdef VK_USE_PLATFORM_SCREEN_QNX + {"vkGetScreenBufferPropertiesQNX", (void*)GetScreenBufferPropertiesQNX}, +#endif + {"vkCreateAccelerationStructureKHR", (void*)CreateAccelerationStructureKHR}, + {"vkDestroyAccelerationStructureKHR", (void*)DestroyAccelerationStructureKHR}, + {"vkCmdBuildAccelerationStructuresKHR", (void*)CmdBuildAccelerationStructuresKHR}, + {"vkCmdBuildAccelerationStructuresIndirectKHR", (void*)CmdBuildAccelerationStructuresIndirectKHR}, + {"vkBuildAccelerationStructuresKHR", (void*)BuildAccelerationStructuresKHR}, + {"vkCopyAccelerationStructureKHR", (void*)CopyAccelerationStructureKHR}, + {"vkCopyAccelerationStructureToMemoryKHR", (void*)CopyAccelerationStructureToMemoryKHR}, + {"vkCopyMemoryToAccelerationStructureKHR", (void*)CopyMemoryToAccelerationStructureKHR}, + {"vkWriteAccelerationStructuresPropertiesKHR", (void*)WriteAccelerationStructuresPropertiesKHR}, + {"vkCmdCopyAccelerationStructureKHR", (void*)CmdCopyAccelerationStructureKHR}, + {"vkCmdCopyAccelerationStructureToMemoryKHR", (void*)CmdCopyAccelerationStructureToMemoryKHR}, + {"vkCmdCopyMemoryToAccelerationStructureKHR", (void*)CmdCopyMemoryToAccelerationStructureKHR}, + {"vkGetAccelerationStructureDeviceAddressKHR", (void*)GetAccelerationStructureDeviceAddressKHR}, + {"vkCmdWriteAccelerationStructuresPropertiesKHR", (void*)CmdWriteAccelerationStructuresPropertiesKHR}, + {"vkGetDeviceAccelerationStructureCompatibilityKHR", (void*)GetDeviceAccelerationStructureCompatibilityKHR}, + {"vkGetAccelerationStructureBuildSizesKHR", (void*)GetAccelerationStructureBuildSizesKHR}, + {"vkCmdTraceRaysKHR", (void*)CmdTraceRaysKHR}, + {"vkCreateRayTracingPipelinesKHR", (void*)CreateRayTracingPipelinesKHR}, + {"vkGetRayTracingCaptureReplayShaderGroupHandlesKHR", (void*)GetRayTracingCaptureReplayShaderGroupHandlesKHR}, + {"vkCmdTraceRaysIndirectKHR", (void*)CmdTraceRaysIndirectKHR}, + {"vkGetRayTracingShaderGroupStackSizeKHR", (void*)GetRayTracingShaderGroupStackSizeKHR}, + {"vkCmdSetRayTracingPipelineStackSizeKHR", (void*)CmdSetRayTracingPipelineStackSizeKHR}, + {"vkCmdDrawMeshTasksEXT", (void*)CmdDrawMeshTasksEXT}, + {"vkCmdDrawMeshTasksIndirectEXT", (void*)CmdDrawMeshTasksIndirectEXT}, + {"vkCmdDrawMeshTasksIndirectCountEXT", (void*)CmdDrawMeshTasksIndirectCountEXT}, +}; + +} // namespace vkmock + |