From ca8bb4ee3cc9afdeca4b49c5ef758bad7cce2c72 Mon Sep 17 00:00:00 2001 From: Charles Giessen Date: Thu, 15 Jun 2023 12:22:52 -0600 Subject: 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. --- icd/generated/function_declarations.h | 4982 +++++++++++++++++++++++ icd/generated/function_definitions.h | 6796 +++++++++++++++++++++++++++++++ icd/generated/mock_icd.cpp | 7211 --------------------------------- icd/generated/mock_icd.h | 5001 ----------------------- 4 files changed, 11778 insertions(+), 12212 deletions(-) create mode 100644 icd/generated/function_declarations.h create mode 100644 icd/generated/function_definitions.h delete mode 100644 icd/generated/mock_icd.cpp delete mode 100644 icd/generated/mock_icd.h (limited to 'icd/generated') 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 +#include +#include +#include + +namespace vkmock { + +// Map of instance extension name to version +static const std::unordered_map 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 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 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 + diff --git a/icd/generated/function_definitions.h b/icd/generated/function_definitions.h new file mode 100644 index 00000000..5eb09156 --- /dev/null +++ b/icd/generated/function_definitions.h @@ -0,0 +1,6796 @@ +/* +** 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 "mock_icd.h" +#include "function_declarations.h" + +namespace vkmock { + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( + const VkInstanceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkInstance* pInstance) +{ + + // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with + // apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the + // ICD should behave as normal. + if (loader_interface_version <= 4) { + return VK_ERROR_INCOMPATIBLE_DRIVER; + } + *pInstance = (VkInstance)CreateDispObjHandle(); + for (auto& physical_device : physical_device_map[*pInstance]) + physical_device = (VkPhysicalDevice)CreateDispObjHandle(); + // TODO: If emulating specific device caps, will need to add intelligence here + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyInstance( + VkInstance instance, + const VkAllocationCallbacks* pAllocator) +{ + + if (instance) { + for (const auto physical_device : physical_device_map.at(instance)) + DestroyDispObjHandle((void*)physical_device); + physical_device_map.erase(instance); + DestroyDispObjHandle((void*)instance); + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( + VkInstance instance, + uint32_t* pPhysicalDeviceCount, + VkPhysicalDevice* pPhysicalDevices) +{ + VkResult result_code = VK_SUCCESS; + if (pPhysicalDevices) { + const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count); + for (uint32_t i = 0; i < return_count; ++i) pPhysicalDevices[i] = physical_device_map.at(instance)[i]; + if (return_count < icd_physical_device_count) result_code = VK_INCOMPLETE; + *pPhysicalDeviceCount = return_count; + } else { + *pPhysicalDeviceCount = icd_physical_device_count; + } + return result_code; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures* pFeatures) +{ + uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); + VkBool32 *bool_array = &pFeatures->robustBufferAccess; + SetBoolArrayTrue(bool_array, num_bools); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties* pFormatProperties) +{ + if (VK_FORMAT_UNDEFINED == format) { + *pFormatProperties = { 0x0, 0x0, 0x0 }; + } else { + // Default to a color format, skip DS bit + *pFormatProperties = { 0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF }; + switch (format) { + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D32_SFLOAT: + case VK_FORMAT_S8_UINT: + case VK_FORMAT_D16_UNORM_S8_UINT: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + // Don't set color bits for DS formats + *pFormatProperties = { 0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F }; + break; + default: + break; + } + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkImageTiling tiling, + VkImageUsageFlags usage, + VkImageCreateFlags flags, + VkImageFormatProperties* pImageFormatProperties) +{ + // A hardcoded unsupported format + if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) { + return VK_ERROR_FORMAT_NOT_SUPPORTED; + } + + // TODO: Just hard-coding some values for now + // TODO: If tiling is linear, limit the mips, levels, & sample count + if (VK_IMAGE_TILING_LINEAR == tiling) { + *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 }; + } else { + // We hard-code support for all sample counts except 64 bits. + *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 }; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties* pProperties) +{ + pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE; + pProperties->driverVersion = 1; + pProperties->vendorID = 0xba5eba11; + pProperties->deviceID = 0xf005ba11; + pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU; + //std::string devName = "Vulkan Mock Device"; + strcpy(pProperties->deviceName, "Vulkan Mock Device"); + pProperties->pipelineCacheUUID[0] = 18; + pProperties->limits = SetLimits(&pProperties->limits); + pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE }; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties* pQueueFamilyProperties) +{ + if (!pQueueFamilyProperties) { + *pQueueFamilyPropertyCount = 1; + } else { + if (*pQueueFamilyPropertyCount) { + pQueueFamilyProperties[0].queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_PROTECTED_BIT; + pQueueFamilyProperties[0].queueCount = 1; + pQueueFamilyProperties[0].timestampValidBits = 16; + pQueueFamilyProperties[0].minImageTransferGranularity = {1,1,1}; + } + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties* pMemoryProperties) +{ + pMemoryProperties->memoryTypeCount = 6; + // Host visible Coherent + pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + pMemoryProperties->memoryTypes[0].heapIndex = 0; + // Host visible Cached + pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; + pMemoryProperties->memoryTypes[1].heapIndex = 0; + // Device local and Host visible + pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; + pMemoryProperties->memoryTypes[2].heapIndex = 1; + // Device local lazily + pMemoryProperties->memoryTypes[3].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT; + pMemoryProperties->memoryTypes[3].heapIndex = 1; + // Device local protected + pMemoryProperties->memoryTypes[4].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_PROTECTED_BIT; + pMemoryProperties->memoryTypes[4].heapIndex = 1; + // Device local only + pMemoryProperties->memoryTypes[5].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; + pMemoryProperties->memoryTypes[5].heapIndex = 1; + pMemoryProperties->memoryHeapCount = 2; + pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT; + pMemoryProperties->memoryHeaps[0].size = 8000000000; + pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; + pMemoryProperties->memoryHeaps[1].size = 8000000000; +} + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( + VkInstance instance, + const char* pName) +{ + + if (!negotiate_loader_icd_interface_called) { + loader_interface_version = 0; + } + const auto &item = name_to_funcptr_map.find(pName); + if (item != name_to_funcptr_map.end()) { + return reinterpret_cast(item->second); + } + // Mock should intercept all functions so if we get here just return null + return nullptr; +} + +static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( + VkDevice device, + const char* pName) +{ + + return GetInstanceProcAddr(nullptr, pName); +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( + VkPhysicalDevice physicalDevice, + const VkDeviceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDevice* pDevice) +{ + + *pDevice = (VkDevice)CreateDispObjHandle(); + // TODO: If emulating specific device caps, will need to add intelligence here + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDevice( + VkDevice device, + const VkAllocationCallbacks* pAllocator) +{ + + unique_lock_t lock(global_lock); + // First destroy sub-device objects + // Destroy Queues + for (auto queue_family_map_pair : queue_map[device]) { + for (auto index_queue_pair : queue_map[device][queue_family_map_pair.first]) { + DestroyDispObjHandle((void*)index_queue_pair.second); + } + } + + queue_map.erase(device); + buffer_map.erase(device); + image_memory_size_map.erase(device); + // Now destroy device + DestroyDispObjHandle((void*)device); + // TODO: If emulating specific device caps, will need to add intelligence here +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) +{ + + // If requesting number of extensions, return that + if (!pLayerName) { + if (!pProperties) { + *pPropertyCount = (uint32_t)instance_extension_map.size(); + } else { + uint32_t i = 0; + for (const auto &name_ver_pair : instance_extension_map) { + if (i == *pPropertyCount) { + break; + } + std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName)); + pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0; + pProperties[i].specVersion = name_ver_pair.second; + ++i; + } + if (i != instance_extension_map.size()) { + return VK_INCOMPLETE; + } + } + } + // If requesting extension properties, fill in data struct for number of extensions + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( + VkPhysicalDevice physicalDevice, + const char* pLayerName, + uint32_t* pPropertyCount, + VkExtensionProperties* pProperties) +{ + + // If requesting number of extensions, return that + if (!pLayerName) { + if (!pProperties) { + *pPropertyCount = (uint32_t)device_extension_map.size(); + } else { + uint32_t i = 0; + for (const auto &name_ver_pair : device_extension_map) { + if (i == *pPropertyCount) { + break; + } + std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName)); + pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0; + pProperties[i].specVersion = name_ver_pair.second; + ++i; + } + if (i != device_extension_map.size()) { + return VK_INCOMPLETE; + } + } + } + // If requesting extension properties, fill in data struct for number of extensions + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( + uint32_t* pPropertyCount, + VkLayerProperties* pProperties) +{ + + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkLayerProperties* pProperties) +{ + + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( + VkDevice device, + uint32_t queueFamilyIndex, + uint32_t queueIndex, + VkQueue* pQueue) +{ + unique_lock_t lock(global_lock); + auto queue = queue_map[device][queueFamilyIndex][queueIndex]; + if (queue) { + *pQueue = queue; + } else { + *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle(); + } + // TODO: If emulating specific device caps, will need to add intelligence here + return; +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo* pSubmits, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( + VkQueue queue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( + VkDevice device) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( + VkDevice device, + const VkMemoryAllocateInfo* pAllocateInfo, + const VkAllocationCallbacks* pAllocator, + VkDeviceMemory* pMemory) +{ + unique_lock_t lock(global_lock); + allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize; + *pMemory = (VkDeviceMemory)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL FreeMemory( + VkDevice device, + VkDeviceMemory memory, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object + unique_lock_t lock(global_lock); + allocated_memory_size_map.erase(memory); +} + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize offset, + VkDeviceSize size, + VkMemoryMapFlags flags, + void** ppData) +{ + unique_lock_t lock(global_lock); + if (VK_WHOLE_SIZE == size) { + if (allocated_memory_size_map.count(memory) != 0) + size = allocated_memory_size_map[memory] - offset; + else + size = 0x10000; + } + void* map_addr = malloc((size_t)size); + mapped_memory_map[memory].push_back(map_addr); + *ppData = map_addr; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL UnmapMemory( + VkDevice device, + VkDeviceMemory memory) +{ + unique_lock_t lock(global_lock); + for (auto map_addr : mapped_memory_map[memory]) { + free(map_addr); + } + mapped_memory_map.erase(memory); +} + +static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( + VkDevice device, + uint32_t memoryRangeCount, + const VkMappedMemoryRange* pMemoryRanges) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( + VkDevice device, + VkDeviceMemory memory, + VkDeviceSize* pCommittedMemoryInBytes) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( + VkDevice device, + VkBuffer buffer, + VkDeviceMemory memory, + VkDeviceSize memoryOffset) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( + VkDevice device, + VkImage image, + VkDeviceMemory memory, + VkDeviceSize memoryOffset) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( + VkDevice device, + VkBuffer buffer, + VkMemoryRequirements* pMemoryRequirements) +{ + // TODO: Just hard-coding reqs for now + pMemoryRequirements->size = 4096; + pMemoryRequirements->alignment = 1; + pMemoryRequirements->memoryTypeBits = 0xFFFF; + // Return a better size based on the buffer size from the create info. + unique_lock_t lock(global_lock); + auto d_iter = buffer_map.find(device); + if (d_iter != buffer_map.end()) { + auto iter = d_iter->second.find(buffer); + if (iter != d_iter->second.end()) { + pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096; + } + } +} + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( + VkDevice device, + VkImage image, + VkMemoryRequirements* pMemoryRequirements) +{ + pMemoryRequirements->size = 0; + pMemoryRequirements->alignment = 1; + + unique_lock_t lock(global_lock); + auto d_iter = image_memory_size_map.find(device); + if(d_iter != image_memory_size_map.end()){ + auto iter = d_iter->second.find(image); + if (iter != d_iter->second.end()) { + pMemoryRequirements->size = iter->second; + } + } + // Here we hard-code that the memory type at index 3 doesn't support this image. + pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( + VkDevice device, + VkImage image, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements* pSparseMemoryRequirements) +{ + if (!pSparseMemoryRequirements) { + *pSparseMemoryRequirementCount = 1; + } else { + // arbitrary + pSparseMemoryRequirements->imageMipTailFirstLod = 0; + pSparseMemoryRequirements->imageMipTailSize = 8; + pSparseMemoryRequirements->imageMipTailOffset = 0; + pSparseMemoryRequirements->imageMipTailStride = 4; + pSparseMemoryRequirements->formatProperties.imageGranularity = {4, 4, 4}; + pSparseMemoryRequirements->formatProperties.flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; + // Would need to track the VkImage to know format for better value here + pSparseMemoryRequirements->formatProperties.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; + } + +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkImageType type, + VkSampleCountFlagBits samples, + VkImageUsageFlags usage, + VkImageTiling tiling, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties* pProperties) +{ + if (!pProperties) { + *pPropertyCount = 1; + } else { + // arbitrary + pProperties->imageGranularity = {4, 4, 4}; + pProperties->flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; + switch (format) { + case VK_FORMAT_D16_UNORM: + case VK_FORMAT_D32_SFLOAT: + pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; + break; + case VK_FORMAT_S8_UINT: + pProperties->aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; + break; + case VK_FORMAT_X8_D24_UNORM_PACK32: + case VK_FORMAT_D16_UNORM_S8_UINT: + case VK_FORMAT_D24_UNORM_S8_UINT: + case VK_FORMAT_D32_SFLOAT_S8_UINT: + pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; + break; + default: + pProperties->aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; + break; + } + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( + VkQueue queue, + uint32_t bindInfoCount, + const VkBindSparseInfo* pBindInfo, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateFence( + VkDevice device, + const VkFenceCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) +{ + unique_lock_t lock(global_lock); + *pFence = (VkFence)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyFence( + VkDevice device, + VkFence fence, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( + VkDevice device, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( + VkDevice device, + uint32_t fenceCount, + const VkFence* pFences, + VkBool32 waitAll, + uint64_t timeout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( + VkDevice device, + const VkSemaphoreCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSemaphore* pSemaphore) +{ + unique_lock_t lock(global_lock); + *pSemaphore = (VkSemaphore)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySemaphore( + VkDevice device, + VkSemaphore semaphore, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( + VkDevice device, + const VkEventCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkEvent* pEvent) +{ + unique_lock_t lock(global_lock); + *pEvent = (VkEvent)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyEvent( + VkDevice device, + VkEvent event, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( + VkDevice device, + VkEvent event) +{ +//Not a CREATE or DESTROY function + return VK_EVENT_SET; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetEvent( + VkDevice device, + VkEvent event) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( + VkDevice device, + VkEvent event) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( + VkDevice device, + const VkQueryPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkQueryPool* pQueryPool) +{ + unique_lock_t lock(global_lock); + *pQueryPool = (VkQueryPool)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( + VkDevice device, + VkQueryPool queryPool, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +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) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( + VkDevice device, + const VkBufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBuffer* pBuffer) +{ + unique_lock_t lock(global_lock); + *pBuffer = (VkBuffer)global_unique_handle++; + buffer_map[device][*pBuffer] = { + pCreateInfo->size, + current_available_address + }; + current_available_address += pCreateInfo->size; + // Always align to next 64-bit pointer + const uint64_t alignment = current_available_address % 64; + if (alignment != 0) { + current_available_address += (64 - alignment); + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyBuffer( + VkDevice device, + VkBuffer buffer, + const VkAllocationCallbacks* pAllocator) +{ + unique_lock_t lock(global_lock); + buffer_map[device].erase(buffer); +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( + VkDevice device, + const VkBufferViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkBufferView* pView) +{ + unique_lock_t lock(global_lock); + *pView = (VkBufferView)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyBufferView( + VkDevice device, + VkBufferView bufferView, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImage( + VkDevice device, + const VkImageCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImage* pImage) +{ + unique_lock_t lock(global_lock); + *pImage = (VkImage)global_unique_handle++; + image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo); + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyImage( + VkDevice device, + VkImage image, + const VkAllocationCallbacks* pAllocator) +{ + unique_lock_t lock(global_lock); + image_memory_size_map[device].erase(image); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( + VkDevice device, + VkImage image, + const VkImageSubresource* pSubresource, + VkSubresourceLayout* pLayout) +{ + // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. + *pLayout = VkSubresourceLayout(); // Default constructor zero values. +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( + VkDevice device, + const VkImageViewCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkImageView* pView) +{ + unique_lock_t lock(global_lock); + *pView = (VkImageView)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyImageView( + VkDevice device, + VkImageView imageView, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkShaderModule* pShaderModule) +{ + unique_lock_t lock(global_lock); + *pShaderModule = (VkShaderModule)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( + VkDevice device, + VkShaderModule shaderModule, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( + VkDevice device, + const VkPipelineCacheCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineCache* pPipelineCache) +{ + unique_lock_t lock(global_lock); + *pPipelineCache = (VkPipelineCache)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( + VkDevice device, + VkPipelineCache pipelineCache, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( + VkDevice device, + VkPipelineCache pipelineCache, + size_t* pDataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( + VkDevice device, + VkPipelineCache dstCache, + uint32_t srcCacheCount, + const VkPipelineCache* pSrcCaches) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkGraphicsPipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkComputePipelineCreateInfo* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPipeline( + VkDevice device, + VkPipeline pipeline, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( + VkDevice device, + const VkPipelineLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPipelineLayout* pPipelineLayout) +{ + unique_lock_t lock(global_lock); + *pPipelineLayout = (VkPipelineLayout)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( + VkDevice device, + VkPipelineLayout pipelineLayout, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( + VkDevice device, + const VkSamplerCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSampler* pSampler) +{ + unique_lock_t lock(global_lock); + *pSampler = (VkSampler)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySampler( + VkDevice device, + VkSampler sampler, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorSetLayout* pSetLayout) +{ + unique_lock_t lock(global_lock); + *pSetLayout = (VkDescriptorSetLayout)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( + VkDevice device, + VkDescriptorSetLayout descriptorSetLayout, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( + VkDevice device, + const VkDescriptorPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorPool* pDescriptorPool) +{ + unique_lock_t lock(global_lock); + *pDescriptorPool = (VkDescriptorPool)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( + VkDevice device, + VkDescriptorPool descriptorPool, + VkDescriptorPoolResetFlags flags) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( + VkDevice device, + const VkDescriptorSetAllocateInfo* pAllocateInfo, + VkDescriptorSet* pDescriptorSets) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) { + pDescriptorSets[i] = (VkDescriptorSet)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( + VkDevice device, + VkDescriptorPool descriptorPool, + uint32_t descriptorSetCount, + const VkDescriptorSet* pDescriptorSets) +{ +//Destroy object + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( + VkDevice device, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites, + uint32_t descriptorCopyCount, + const VkCopyDescriptorSet* pDescriptorCopies) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( + VkDevice device, + const VkFramebufferCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkFramebuffer* pFramebuffer) +{ + unique_lock_t lock(global_lock); + *pFramebuffer = (VkFramebuffer)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( + VkDevice device, + VkFramebuffer framebuffer, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( + VkDevice device, + const VkRenderPassCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) +{ + unique_lock_t lock(global_lock); + *pRenderPass = (VkRenderPass)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( + VkDevice device, + VkRenderPass renderPass, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( + VkDevice device, + VkRenderPass renderPass, + VkExtent2D* pGranularity) +{ + pGranularity->width = 1; + pGranularity->height = 1; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( + VkDevice device, + const VkCommandPoolCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCommandPool* pCommandPool) +{ + unique_lock_t lock(global_lock); + *pCommandPool = (VkCommandPool)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( + VkDevice device, + VkCommandPool commandPool, + const VkAllocationCallbacks* pAllocator) +{ + + // destroy command buffers for this pool + unique_lock_t lock(global_lock); + auto it = command_pool_buffer_map.find(commandPool); + if (it != command_pool_buffer_map.end()) { + for (auto& cb : it->second) { + DestroyDispObjHandle((void*) cb); + } + command_pool_buffer_map.erase(it); + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolResetFlags flags) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( + VkDevice device, + const VkCommandBufferAllocateInfo* pAllocateInfo, + VkCommandBuffer* pCommandBuffers) +{ + + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) { + pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle(); + command_pool_buffer_map[pAllocateInfo->commandPool].push_back(pCommandBuffers[i]); + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( + VkDevice device, + VkCommandPool commandPool, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) +{ + + unique_lock_t lock(global_lock); + for (auto i = 0u; i < commandBufferCount; ++i) { + if (!pCommandBuffers[i]) { + continue; + } + + for (auto& pair : command_pool_buffer_map) { + auto& cbs = pair.second; + auto it = std::find(cbs.begin(), cbs.end(), pCommandBuffers[i]); + if (it != cbs.end()) { + cbs.erase(it); + } + } + + DestroyDispObjHandle((void*) pCommandBuffers[i]); + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( + VkCommandBuffer commandBuffer, + const VkCommandBufferBeginInfo* pBeginInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( + VkCommandBuffer commandBuffer, + VkCommandBufferResetFlags flags) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewport( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewport* pViewports) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissor( + VkCommandBuffer commandBuffer, + uint32_t firstScissor, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( + VkCommandBuffer commandBuffer, + float lineWidth) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( + VkCommandBuffer commandBuffer, + float depthBiasConstantFactor, + float depthBiasClamp, + float depthBiasSlopeFactor) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( + VkCommandBuffer commandBuffer, + const float blendConstants[4]) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( + VkCommandBuffer commandBuffer, + float minDepthBounds, + float maxDepthBounds) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t compareMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t writeMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + uint32_t reference) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkIndexType indexType) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDraw( + VkCommandBuffer commandBuffer, + uint32_t vertexCount, + uint32_t instanceCount, + uint32_t firstVertex, + uint32_t firstInstance) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( + VkCommandBuffer commandBuffer, + uint32_t indexCount, + uint32_t instanceCount, + uint32_t firstIndex, + int32_t vertexOffset, + uint32_t firstInstance) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatch( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferCopy* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageCopy* pRegions) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( + VkCommandBuffer commandBuffer, + VkBuffer srcBuffer, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkBuffer dstBuffer, + uint32_t regionCount, + const VkBufferImageCopy* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize dataSize, + const void* pData) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( + VkCommandBuffer commandBuffer, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + VkDeviceSize size, + uint32_t data) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearColorValue* pColor, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( + VkCommandBuffer commandBuffer, + VkImage image, + VkImageLayout imageLayout, + const VkClearDepthStencilValue* pDepthStencil, + uint32_t rangeCount, + const VkImageSubresourceRange* pRanges) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkClearAttachment* pAttachments, + uint32_t rectCount, + const VkClearRect* pRects) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage( + VkCommandBuffer commandBuffer, + VkImage srcImage, + VkImageLayout srcImageLayout, + VkImage dstImage, + VkImageLayout dstImageLayout, + uint32_t regionCount, + const VkImageResolve* pRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags stageMask) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndQuery( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkQueryPool queryPool, + uint32_t query) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPushConstants( + VkCommandBuffer commandBuffer, + VkPipelineLayout layout, + VkShaderStageFlags stageFlags, + uint32_t offset, + uint32_t size, + const void* pValues) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + VkSubpassContents contents) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( + VkCommandBuffer commandBuffer, + VkSubpassContents contents) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( + VkCommandBuffer commandBuffer, + uint32_t commandBufferCount, + const VkCommandBuffer* pCommandBuffers) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion( + uint32_t* pApiVersion) +{ + + *pApiVersion = VK_HEADER_VERSION_COMPLETE; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( + VkCommandBuffer commandBuffer, + uint32_t deviceMask) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + return EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures) +{ + GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties) +{ + GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties) +{ + GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties) +{ + return GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) +{ + GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); +} + +static VKAPI_ATTR void VKAPI_CALL TrimCommandPool( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( + VkDevice device, + const VkDeviceQueueInfo2* pQueueInfo, + VkQueue* pQueue) +{ + GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue); + // TODO: Add further support for GetDeviceQueue2 features +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion) +{ + unique_lock_t lock(global_lock); + *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + unique_lock_t lock(global_lock); + *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties) +{ + constexpr VkExternalMemoryHandleTypeFlags supported_flags = 0x1FF; + if (pExternalBufferInfo->handleType & supported_flags) { + pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7; + pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = supported_flags; + pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = supported_flags; + } else { + pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0; + pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0; + // According to spec, handle type is always compatible with itself. Even if export/import + // not supported, it's important to properly implement self-compatibility property since + // application's control flow can rely on this. + pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType; + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties) +{ + // Hard-code support for all handle types and features + pExternalFenceProperties->exportFromImportedHandleTypes = 0xF; + pExternalFenceProperties->compatibleHandleTypes = 0xF; + pExternalFenceProperties->externalFenceFeatures = 0x3; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, + VkExternalSemaphoreProperties* pExternalSemaphoreProperties) +{ + // Hard code support for all handle types and features + pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F; + pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F; + pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3; +} + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport) +{ + if (pSupport) { + pSupport->supported = VK_TRUE; + } +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) +{ + unique_lock_t lock(global_lock); + *pRenderPass = (VkRenderPass)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL ResetQueryPool( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ + VkDeviceAddress address = 0; + auto d_iter = buffer_map.find(device); + if (d_iter != buffer_map.end()) { + auto iter = d_iter->second.find(pInfo->buffer); + if (iter != d_iter->second.end()) { + address = iter->second.address; + } + } + return address; +} + +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot) +{ + unique_lock_t lock(global_lock); + *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetPrivateData( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRendering( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + // TODO: Just hard-coding reqs for now + pMemoryRequirements->memoryRequirements.alignment = 1; + pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; + + // Return a size based on the buffer size from the create info. + pMemoryRequirements->memoryRequirements.size = ((pInfo->pCreateInfo->size + 4095) / 4096) * 4096; +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + pMemoryRequirements->memoryRequirements.size = GetImageSizeFromCreateInfo(pInfo->pCreateInfo); + pMemoryRequirements->memoryRequirements.alignment = 1; + // Here we hard-code that the memory type at index 3 doesn't support this image. + pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF & ~(0x1 << 3); +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( + VkInstance instance, + VkSurfaceKHR surface, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + VkSurfaceKHR surface, + VkBool32* pSupported) +{ + // Currently say that all surface/queue combos are supported + *pSupported = VK_TRUE; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) +{ + // In general just say max supported is available for requested surface + pSurfaceCapabilities->minImageCount = 1; + pSurfaceCapabilities->maxImageCount = 0; + pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF; + pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF; + pSurfaceCapabilities->minImageExtent.width = 1; + pSurfaceCapabilities->minImageExtent.height = 1; + pSurfaceCapabilities->maxImageExtent.width = 0xFFFF; + pSurfaceCapabilities->maxImageExtent.height = 0xFFFF; + pSurfaceCapabilities->maxImageArrayLayers = 128; + pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR | + VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR | + VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR | + VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR | + VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR | + VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; + pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; + pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | + VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR | + VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR | + VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; + pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | + VK_IMAGE_USAGE_TRANSFER_DST_BIT | + VK_IMAGE_USAGE_SAMPLED_BIT | + VK_IMAGE_USAGE_STORAGE_BIT | + VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | + VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | + VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | + VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormatKHR* pSurfaceFormats) +{ + // Currently always say that RGBA8 & BGRA8 are supported + if (!pSurfaceFormats) { + *pSurfaceFormatCount = 2; + } else { + if (*pSurfaceFormatCount >= 2) { + pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM; + pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + if (*pSurfaceFormatCount >= 1) { + pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM; + pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) +{ + // Currently always say that all present modes are supported + if (!pPresentModes) { + *pPresentModeCount = 6; + } else { + if (*pPresentModeCount >= 6) pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR; + if (*pPresentModeCount >= 5) pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR; + if (*pPresentModeCount >= 4) pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR; + if (*pPresentModeCount >= 3) pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR; + if (*pPresentModeCount >= 2) pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR; + if (*pPresentModeCount >= 1) pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR; + } + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( + VkDevice device, + const VkSwapchainCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchain) +{ + unique_lock_t lock(global_lock); + *pSwapchain = (VkSwapchainKHR)global_unique_handle++; + for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){ + swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( + VkDevice device, + VkSwapchainKHR swapchain, + const VkAllocationCallbacks* pAllocator) +{ + unique_lock_t lock(global_lock); + swapchain_image_map.clear(); +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pSwapchainImageCount, + VkImage* pSwapchainImages) +{ + if (!pSwapchainImages) { + *pSwapchainImageCount = icd_swapchain_image_count; + } else { + unique_lock_t lock(global_lock); + for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){ + pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i]; + } + + if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE; + else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t timeout, + VkSemaphore semaphore, + VkFence fence, + uint32_t* pImageIndex) +{ + *pImageIndex = 0; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( + VkQueue queue, + const VkPresentInfoKHR* pPresentInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, + VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( + VkDevice device, + VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR* pModes) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + uint32_t* pRectCount, + VkRect2D* pRects) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( + VkDevice device, + const VkAcquireNextImageInfoKHR* pAcquireInfo, + uint32_t* pImageIndex) +{ + *pImageIndex = 0; + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPropertiesKHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlanePropertiesKHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( + VkPhysicalDevice physicalDevice, + uint32_t planeIndex, + uint32_t* pDisplayCount, + VkDisplayKHR* pDisplays) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModePropertiesKHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + const VkDisplayModeCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDisplayModeKHR* pMode) +{ + unique_lock_t lock(global_lock); + *pMode = (VkDisplayModeKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + VkDisplayModeKHR mode, + uint32_t planeIndex, + VkDisplayPlaneCapabilitiesKHR* pCapabilities) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( + VkInstance instance, + const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkSwapchainKHR* pSwapchains) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < swapchainCount; ++i) { + pSwapchains[i] = (VkSwapchainKHR)global_unique_handle++; + } + return VK_SUCCESS; +} + +#ifdef VK_USE_PLATFORM_XLIB_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( + VkInstance instance, + const VkXlibSurfaceCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + Display* dpy, + VisualID visualID) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + xcb_connection_t* connection, + xcb_visualid_t visual_id) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct wl_display* display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR( + VkPhysicalDevice physicalDevice, + const VkVideoProfileInfoKHR* pVideoProfile, + VkVideoCapabilitiesKHR* pCapabilities) +{ + // arbitrary + auto *decode_caps = lvl_find_mod_in_chain(pCapabilities->pNext); + if (decode_caps) { + decode_caps->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; + } + pCapabilities->flags = 0; + pCapabilities->minBitstreamBufferOffsetAlignment = 4; + pCapabilities->minBitstreamBufferSizeAlignment = 4; + pCapabilities->pictureAccessGranularity = {1, 1}; + pCapabilities->minCodedExtent = {4, 4}; + pCapabilities->maxCodedExtent = {16, 16}; + pCapabilities->maxDpbSlots = 4; + pCapabilities->maxActiveReferencePictures = 4; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, + uint32_t* pVideoFormatPropertyCount, + VkVideoFormatPropertiesKHR* pVideoFormatProperties) +{ + if (!pVideoFormatProperties) { + *pVideoFormatPropertyCount = 2; + } else { + // arbitrary + pVideoFormatProperties[0].format = VK_FORMAT_R8G8B8A8_UNORM; + pVideoFormatProperties[0].imageCreateFlags = VK_IMAGE_TYPE_2D; + pVideoFormatProperties[0].imageType = VK_IMAGE_TYPE_2D; + pVideoFormatProperties[0].imageTiling = VK_IMAGE_TILING_OPTIMAL; + pVideoFormatProperties[0].imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; + pVideoFormatProperties[1].format = VK_FORMAT_R8G8B8A8_SNORM; + pVideoFormatProperties[1].imageCreateFlags = VK_IMAGE_TYPE_2D; + pVideoFormatProperties[1].imageType = VK_IMAGE_TYPE_2D; + pVideoFormatProperties[1].imageTiling = VK_IMAGE_TILING_OPTIMAL; + pVideoFormatProperties[1].imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; + + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR( + VkDevice device, + const VkVideoSessionCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionKHR* pVideoSession) +{ + unique_lock_t lock(global_lock); + *pVideoSession = (VkVideoSessionKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t* pMemoryRequirementsCount, + VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) +{ + if (!pMemoryRequirements) { + *pMemoryRequirementsCount = 1; + } else { + // arbitrary + pMemoryRequirements[0].memoryBindIndex = 0; + pMemoryRequirements[0].memoryRequirements.size = 4096; + pMemoryRequirements[0].memoryRequirements.alignment = 1; + pMemoryRequirements[0].memoryRequirements.memoryTypeBits = 0xFFFF; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR( + VkDevice device, + VkVideoSessionKHR videoSession, + uint32_t bindSessionMemoryInfoCount, + const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR( + VkDevice device, + const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkVideoSessionParametersKHR* pVideoSessionParameters) +{ + unique_lock_t lock(global_lock); + *pVideoSessionParameters = (VkVideoSessionParametersKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR( + VkDevice device, + VkVideoSessionParametersKHR videoSessionParameters, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoBeginCodingInfoKHR* pBeginInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoEndCodingInfoKHR* pEndCodingInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR( + VkCommandBuffer commandBuffer, + const VkVideoCodingControlInfoKHR* pCodingControlInfo) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoDecodeInfoKHR* pDecodeInfo) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR( + VkCommandBuffer commandBuffer, + const VkRenderingInfo* pRenderingInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceFeatures2* pFeatures) +{ + GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); + uint32_t num_bools = 0; // Count number of VkBool32s in extension structs + VkBool32* feat_bools = nullptr; + const auto *desc_idx_features = lvl_find_in_chain(pFeatures->pNext); + if (desc_idx_features) { + const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing); + num_bools = bool_size/sizeof(VkBool32); + feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing; + SetBoolArrayTrue(feat_bools, num_bools); + } + const auto *blendop_features = lvl_find_in_chain(pFeatures->pNext); + if (blendop_features) { + const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations); + num_bools = bool_size/sizeof(VkBool32); + feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations; + SetBoolArrayTrue(feat_bools, num_bools); + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceProperties2* pProperties) +{ + // The only value that need to be set are those the Profile layer can't set + // see https://github.com/KhronosGroup/Vulkan-Profiles/issues/352 + // All values set are arbitrary + GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); + + auto *props_11 = lvl_find_mod_in_chain(pProperties->pNext); + if (props_11) { + props_11->protectedNoFault = VK_FALSE; + } + + auto *props_12 = lvl_find_mod_in_chain(pProperties->pNext); + if (props_12) { + props_12->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; + props_12->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; + } + + auto *props_13 = lvl_find_mod_in_chain(pProperties->pNext); + if (props_13) { + props_13->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; + props_13->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; + props_13->storageTexelBufferOffsetAlignmentBytes = 16; + props_13->uniformTexelBufferOffsetAlignmentBytes = 16; + } + + auto *protected_memory_props = lvl_find_mod_in_chain(pProperties->pNext); + if (protected_memory_props) { + protected_memory_props->protectedNoFault = VK_FALSE; + } + + auto *float_controls_props = lvl_find_mod_in_chain(pProperties->pNext); + if (float_controls_props) { + float_controls_props->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; + float_controls_props->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; + } + + auto *conservative_raster_props = lvl_find_mod_in_chain(pProperties->pNext); + if (conservative_raster_props) { + conservative_raster_props->primitiveOverestimationSize = 0.00195313f; + conservative_raster_props->conservativePointAndLineRasterization = VK_TRUE; + conservative_raster_props->degenerateTrianglesRasterized = VK_TRUE; + conservative_raster_props->degenerateLinesRasterized = VK_TRUE; + } + + auto *rt_pipeline_props = lvl_find_mod_in_chain(pProperties->pNext); + if (rt_pipeline_props) { + rt_pipeline_props->shaderGroupHandleSize = 32; + rt_pipeline_props->shaderGroupBaseAlignment = 64; + rt_pipeline_props->shaderGroupHandleCaptureReplaySize = 32; + } + + auto *rt_pipeline_nv_props = lvl_find_mod_in_chain(pProperties->pNext); + if (rt_pipeline_nv_props) { + rt_pipeline_nv_props->shaderGroupHandleSize = 32; + rt_pipeline_nv_props->shaderGroupBaseAlignment = 64; + } + + auto *texel_buffer_props = lvl_find_mod_in_chain(pProperties->pNext); + if (texel_buffer_props) { + texel_buffer_props->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; + texel_buffer_props->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; + texel_buffer_props->storageTexelBufferOffsetAlignmentBytes = 16; + texel_buffer_props->uniformTexelBufferOffsetAlignmentBytes = 16; + } + + auto *descriptor_buffer_props = lvl_find_mod_in_chain(pProperties->pNext); + if (descriptor_buffer_props) { + descriptor_buffer_props->combinedImageSamplerDescriptorSingleArray = VK_TRUE; + descriptor_buffer_props->bufferlessPushDescriptors = VK_TRUE; + descriptor_buffer_props->allowSamplerImageViewPostSubmitCreation = VK_TRUE; + descriptor_buffer_props->descriptorBufferOffsetAlignment = 4; + } + + auto *mesh_shader_props = lvl_find_mod_in_chain(pProperties->pNext); + if (mesh_shader_props) { + mesh_shader_props->meshOutputPerVertexGranularity = 32; + mesh_shader_props->meshOutputPerPrimitiveGranularity = 32; + mesh_shader_props->prefersLocalInvocationVertexOutput = VK_TRUE; + mesh_shader_props->prefersLocalInvocationPrimitiveOutput = VK_TRUE; + mesh_shader_props->prefersCompactVertexOutput = VK_TRUE; + mesh_shader_props->prefersCompactPrimitiveOutput = VK_TRUE; + } + + auto *fragment_density_map2_props = lvl_find_mod_in_chain(pProperties->pNext); + if (fragment_density_map2_props) { + fragment_density_map2_props->subsampledLoads = VK_FALSE; + fragment_density_map2_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE; + fragment_density_map2_props->maxSubsampledArrayLayers = 2; + fragment_density_map2_props->maxDescriptorSetSubsampledSamplers = 1; + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + VkFormat format, + VkFormatProperties2* pFormatProperties) +{ + GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties); + VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain(pFormatProperties->pNext); + if (props_3) { + props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures; + props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures; + props_3->bufferFeatures = pFormatProperties->formatProperties.bufferFeatures; + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, + VkImageFormatProperties2* pImageFormatProperties) +{ + GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties); + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pQueueFamilyPropertyCount, + VkQueueFamilyProperties2* pQueueFamilyProperties) +{ + if (pQueueFamilyPropertyCount && pQueueFamilyProperties) { + GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, &pQueueFamilyProperties->queueFamilyProperties); + } else { + GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, nullptr); + } +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( + VkPhysicalDevice physicalDevice, + VkPhysicalDeviceMemoryProperties2* pMemoryProperties) +{ + GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties); +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, + uint32_t* pPropertyCount, + VkSparseImageFormatProperties2* pProperties) +{ + if (pPropertyCount && pProperties) { + GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, &pProperties->properties); + } else { + GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr); + } +} + + +static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( + VkDevice device, + uint32_t heapIndex, + uint32_t localDeviceIndex, + uint32_t remoteDeviceIndex, + VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( + VkCommandBuffer commandBuffer, + uint32_t deviceMask) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( + VkDevice device, + VkCommandPool commandPool, + VkCommandPoolTrimFlags flags) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( + VkInstance instance, + uint32_t* pPhysicalDeviceGroupCount, + VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) +{ + if (!pPhysicalDeviceGroupProperties) { + *pPhysicalDeviceGroupCount = 1; + } else { + // arbitrary + pPhysicalDeviceGroupProperties->physicalDeviceCount = 1; + pPhysicalDeviceGroupProperties->physicalDevices[0] = physical_device_map.at(instance)[0]; + pPhysicalDeviceGroupProperties->subsetAllocation = VK_FALSE; + } + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, + VkExternalBufferProperties* pExternalBufferProperties) +{ + GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); +} + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( + VkDevice device, + const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + HANDLE handle, + VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( + VkDevice device, + const VkMemoryGetFdInfoKHR* pGetFdInfo, + int* pFd) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + int fd, + VkMemoryFdPropertiesKHR* pMemoryFdProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +#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) +{ + GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); +} + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( + VkDevice device, + const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( + VkDevice device, + const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( + VkDevice device, + const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( + VkDevice device, + const VkSemaphoreGetFdInfoKHR* pGetFdInfo, + int* pFd) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set, + uint32_t descriptorWriteCount, + const VkWriteDescriptorSet* pDescriptorWrites) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( + VkCommandBuffer commandBuffer, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + VkPipelineLayout layout, + uint32_t set, + const void* pData) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( + VkDevice device, + const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) +{ + unique_lock_t lock(global_lock); + *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( + VkDevice device, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( + VkDevice device, + VkDescriptorSet descriptorSet, + VkDescriptorUpdateTemplate descriptorUpdateTemplate, + const void* pData) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( + VkDevice device, + const VkRenderPassCreateInfo2* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkRenderPass* pRenderPass) +{ + unique_lock_t lock(global_lock); + *pRenderPass = (VkRenderPass)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkRenderPassBeginInfo* pRenderPassBegin, + const VkSubpassBeginInfo* pSubpassBeginInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassBeginInfo* pSubpassBeginInfo, + const VkSubpassEndInfo* pSubpassEndInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( + VkCommandBuffer commandBuffer, + const VkSubpassEndInfo* pSubpassEndInfo) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( + VkDevice device, + VkSwapchainKHR swapchain) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, + VkExternalFenceProperties* pExternalFenceProperties) +{ + GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); +} + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( + VkDevice device, + const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( + VkDevice device, + const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, + HANDLE* pHandle) +{ + *pHandle = (HANDLE)0x12345678; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( + VkDevice device, + const VkImportFenceFdInfoKHR* pImportFenceFdInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( + VkDevice device, + const VkFenceGetFdInfoKHR* pGetFdInfo, + int* pFd) +{ + *pFd = 0x42; + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + uint32_t* pCounterCount, + VkPerformanceCounterKHR* pCounters, + VkPerformanceCounterDescriptionKHR* pCounterDescriptions) +{ + if (!pCounters) { + *pCounterCount = 3; + } else { + if (*pCounterCount == 0){ + return VK_INCOMPLETE; + } + // arbitrary + pCounters[0].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; + pCounters[0].scope = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR; + pCounters[0].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; + pCounters[0].uuid[0] = 0x01; + if (*pCounterCount == 1){ + return VK_INCOMPLETE; + } + pCounters[1].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; + pCounters[1].scope = VK_QUERY_SCOPE_RENDER_PASS_KHR; + pCounters[1].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; + pCounters[1].uuid[0] = 0x02; + if (*pCounterCount == 2){ + return VK_INCOMPLETE; + } + pCounters[2].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; + pCounters[2].scope = VK_QUERY_SCOPE_COMMAND_KHR; + pCounters[2].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; + pCounters[2].uuid[0] = 0x03; + *pCounterCount = 3; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( + VkPhysicalDevice physicalDevice, + const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, + uint32_t* pNumPasses) +{ + if (pNumPasses) { + // arbitrary + *pNumPasses = 1; + } +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR( + VkDevice device, + const VkAcquireProfilingLockInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR( + VkDevice device) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkSurfaceCapabilities2KHR* pSurfaceCapabilities) +{ + GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities); + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pSurfaceFormatCount, + VkSurfaceFormat2KHR* pSurfaceFormats) +{ + // Currently always say that RGBA8 & BGRA8 are supported + if (!pSurfaceFormats) { + *pSurfaceFormatCount = 2; + } else { + if (*pSurfaceFormatCount >= 2) { + pSurfaceFormats[1].pNext = nullptr; + pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM; + pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + if (*pSurfaceFormatCount >= 1) { + pSurfaceFormats[1].pNext = nullptr; + pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM; + pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; + } + } + return VK_SUCCESS; +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayProperties2KHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkDisplayPlaneProperties2KHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display, + uint32_t* pPropertyCount, + VkDisplayModeProperties2KHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( + VkPhysicalDevice physicalDevice, + const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, + VkDisplayPlaneCapabilities2KHR* pCapabilities) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + +static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( + VkDevice device, + const VkImageMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( + VkDevice device, + const VkBufferMemoryRequirementsInfo2* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( + VkDevice device, + const VkImageSparseMemoryRequirementsInfo2* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ + if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) { + GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &pSparseMemoryRequirements->memoryRequirements); + } else { + GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr); + } +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( + VkDevice device, + const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSamplerYcbcrConversion* pYcbcrConversion) +{ + unique_lock_t lock(global_lock); + *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( + VkDevice device, + VkSamplerYcbcrConversion ycbcrConversion, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + + +static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindBufferMemoryInfo* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( + VkDevice device, + uint32_t bindInfoCount, + const VkBindImageMemoryInfo* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +#ifdef VK_ENABLE_BETA_EXTENSIONS +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( + VkDevice device, + const VkDescriptorSetLayoutCreateInfo* pCreateInfo, + VkDescriptorSetLayoutSupport* pSupport) +{ + GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + + + + + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR( + VkDevice device, + VkSemaphore semaphore, + uint64_t* pValue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR( + VkDevice device, + const VkSemaphoreWaitInfo* pWaitInfo, + uint64_t timeout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR( + VkDevice device, + const VkSemaphoreSignalInfo* pSignalInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR( + VkPhysicalDevice physicalDevice, + uint32_t* pFragmentShadingRateCount, + VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) +{ + if (!pFragmentShadingRates) { + *pFragmentShadingRateCount = 1; + } else { + // arbitrary + pFragmentShadingRates->sampleCounts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT; + pFragmentShadingRates->fragmentSize = {8, 8}; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR( + VkCommandBuffer commandBuffer, + const VkExtent2D* pFragmentSize, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR( + VkDevice device, + VkSwapchainKHR swapchain, + uint64_t presentId, + uint64_t timeout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ + return GetBufferDeviceAddress(device, pInfo); +} + +static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR( + VkDevice device, + const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR( + VkDevice device, + const VkAllocationCallbacks* pAllocator, + VkDeferredOperationKHR* pDeferredOperation) +{ + unique_lock_t lock(global_lock); + *pDeferredOperation = (VkDeferredOperationKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR( + VkDevice device, + VkDeferredOperationKHR operation, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR( + VkDevice device, + VkDeferredOperationKHR operation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR( + VkDevice device, + VkDeferredOperationKHR operation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR( + VkDevice device, + VkDeferredOperationKHR operation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( + VkDevice device, + const VkPipelineInfoKHR* pPipelineInfo, + uint32_t* pExecutableCount, + VkPipelineExecutablePropertiesKHR* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pStatisticCount, + VkPipelineExecutableStatisticKHR* pStatistics) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( + VkDevice device, + const VkPipelineExecutableInfoKHR* pExecutableInfo, + uint32_t* pInternalRepresentationCount, + VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR( + VkDevice device, + const VkMemoryMapInfoKHR* pMemoryMapInfo, + void** ppData) +{ + return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData); +} + +static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR( + VkDevice device, + const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) +{ + UnmapMemory(device, pMemoryUnmapInfo->memory); + return VK_SUCCESS; +} + + + + + +#ifdef VK_ENABLE_BETA_EXTENSIONS + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, + VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetEncodedVideoSessionParametersKHR( + VkDevice device, + const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, + VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, + size_t* pDataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR( + VkCommandBuffer commandBuffer, + const VkVideoEncodeInfoKHR* pEncodeInfo) +{ +//Not a CREATE or DESTROY function +} +#endif /* VK_ENABLE_BETA_EXTENSIONS */ + + +static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + const VkDependencyInfo* pDependencyInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR( + VkCommandBuffer commandBuffer, + VkEvent event, + VkPipelineStageFlags2 stageMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR( + VkCommandBuffer commandBuffer, + uint32_t eventCount, + const VkEvent* pEvents, + const VkDependencyInfo* pDependencyInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR( + VkCommandBuffer commandBuffer, + const VkDependencyInfo* pDependencyInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkQueryPool queryPool, + uint32_t query) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR( + VkQueue queue, + uint32_t submitCount, + const VkSubmitInfo2* pSubmits, + VkFence fence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlags2 stage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointData2NV* pCheckpointData) +{ +//Not a CREATE or DESTROY function +} + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferInfo2* pCopyBufferInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageInfo2* pCopyImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR( + VkCommandBuffer commandBuffer, + const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR( + VkCommandBuffer commandBuffer, + const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR( + VkCommandBuffer commandBuffer, + const VkBlitImageInfo2* pBlitImageInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR( + VkCommandBuffer commandBuffer, + const VkResolveImageInfo2* pResolveImageInfo) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectDeviceAddress) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR( + VkDevice device, + const VkDeviceBufferMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ + GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( + VkDevice device, + const VkDeviceImageMemoryRequirements* pInfo, + uint32_t* pSparseMemoryRequirementCount, + VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( + VkInstance instance, + const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugReportCallbackEXT* pCallback) +{ + unique_lock_t lock(global_lock); + *pCallback = (VkDebugReportCallbackEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( + VkInstance instance, + VkDebugReportCallbackEXT callback, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +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) +{ +//Not a CREATE or DESTROY function +} + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( + VkDevice device, + const VkDebugMarkerObjectTagInfoEXT* pTagInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( + VkDevice device, + const VkDebugMarkerObjectNameInfoEXT* pNameInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( + VkCommandBuffer commandBuffer, + const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t firstBinding, + uint32_t bindingCount, + const VkBuffer* pBuffers, + const VkDeviceSize* pOffsets, + const VkDeviceSize* pSizes) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( + VkCommandBuffer commandBuffer, + uint32_t firstCounterBuffer, + uint32_t counterBufferCount, + const VkBuffer* pCounterBuffers, + const VkDeviceSize* pCounterBufferOffsets) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + VkQueryControlFlags flags, + uint32_t index) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( + VkCommandBuffer commandBuffer, + VkQueryPool queryPool, + uint32_t query, + uint32_t index) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX( + VkDevice device, + const VkCuModuleCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuModuleNVX* pModule) +{ + unique_lock_t lock(global_lock); + *pModule = (VkCuModuleNVX)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX( + VkDevice device, + const VkCuFunctionCreateInfoNVX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkCuFunctionNVX* pFunction) +{ + unique_lock_t lock(global_lock); + *pFunction = (VkCuFunctionNVX)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX( + VkDevice device, + VkCuModuleNVX module, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX( + VkDevice device, + VkCuFunctionNVX function, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX( + VkCommandBuffer commandBuffer, + const VkCuLaunchInfoNVX* pLaunchInfo) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( + VkDevice device, + const VkImageViewHandleInfoNVX* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( + VkDevice device, + VkImageView imageView, + VkImageViewAddressPropertiesNVX* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + + + + +#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) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +#ifdef VK_USE_PLATFORM_GGP + +static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( + VkInstance instance, + const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#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) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( + VkDevice device, + VkDeviceMemory memory, + VkExternalMemoryHandleTypeFlagsNV handleType, + HANDLE* pHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_VI_NN */ + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( + VkCommandBuffer commandBuffer, + const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportWScalingNV* pViewportWScalings) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + VkDisplayKHR display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( + VkPhysicalDevice physicalDevice, + Display* dpy, + RROutput rrOutput, + VkDisplayKHR* pDisplay) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( + VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, + VkSurfaceCapabilities2EXT* pSurfaceCapabilities) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayPowerInfoEXT* pDisplayPowerInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( + VkDevice device, + const VkDeviceEventInfoEXT* pDeviceEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( + VkDevice device, + VkDisplayKHR display, + const VkDisplayEventInfoEXT* pDisplayEventInfo, + const VkAllocationCallbacks* pAllocator, + VkFence* pFence) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( + VkDevice device, + VkSwapchainKHR swapchain, + VkSurfaceCounterFlagBitsEXT counter, + uint64_t* pCounterValue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( + VkDevice device, + VkSwapchainKHR swapchain, + uint32_t* pPresentationTimingCount, + VkPastPresentationTimingGOOGLE* pPresentationTimings) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( + VkCommandBuffer commandBuffer, + uint32_t firstDiscardRectangle, + uint32_t discardRectangleCount, + const VkRect2D* pDiscardRectangles) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 discardRectangleEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT( + VkCommandBuffer commandBuffer, + VkDiscardRectangleModeEXT discardRectangleMode) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( + VkDevice device, + uint32_t swapchainCount, + const VkSwapchainKHR* pSwapchains, + const VkHdrMetadataEXT* pMetadata) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_IOS_MVK + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( + VkInstance instance, + const VkIOSSurfaceCreateInfoMVK* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_MACOS_MVK */ + + + + +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( + VkDevice device, + const VkDebugUtilsObjectNameInfoEXT* pNameInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( + VkDevice device, + const VkDebugUtilsObjectTagInfoEXT* pTagInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( + VkQueue queue) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( + VkQueue queue, + const VkDebugUtilsLabelEXT* pLabelInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( + VkCommandBuffer commandBuffer, + const VkDebugUtilsLabelEXT* pLabelInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( + VkInstance instance, + const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkDebugUtilsMessengerEXT* pMessenger) +{ + unique_lock_t lock(global_lock); + *pMessenger = (VkDebugUtilsMessengerEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( + VkInstance instance, + VkDebugUtilsMessengerEXT messenger, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( + VkInstance instance, + VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, + VkDebugUtilsMessageTypeFlagsEXT messageTypes, + const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_ANDROID_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( + VkDevice device, + const struct AHardwareBuffer* buffer, + VkAndroidHardwareBufferPropertiesANDROID* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( + VkDevice device, + const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, + struct AHardwareBuffer** pBuffer) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_ANDROID_KHR */ + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( + VkCommandBuffer commandBuffer, + const VkSampleLocationsInfoEXT* pSampleLocationsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( + VkPhysicalDevice physicalDevice, + VkSampleCountFlagBits samples, + VkMultisamplePropertiesEXT* pMultisampleProperties) +{ + if (pMultisampleProperties) { + // arbitrary + pMultisampleProperties->maxSampleLocationGridSize = {32, 32}; + } +} + + + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( + VkDevice device, + VkImage image, + VkImageDrmFormatModifierPropertiesEXT* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( + VkDevice device, + const VkValidationCacheCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkValidationCacheEXT* pValidationCache) +{ + unique_lock_t lock(global_lock); + *pValidationCache = (VkValidationCacheEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( + VkDevice device, + VkValidationCacheEXT dstCache, + uint32_t srcCacheCount, + const VkValidationCacheEXT* pSrcCaches) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( + VkDevice device, + VkValidationCacheEXT validationCache, + size_t* pDataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkShadingRatePaletteNV* pShadingRatePalettes) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( + VkCommandBuffer commandBuffer, + VkCoarseSampleOrderTypeNV sampleOrderType, + uint32_t customSampleOrderCount, + const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( + VkDevice device, + const VkAccelerationStructureCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureNV* pAccelerationStructure) +{ + unique_lock_t lock(global_lock); + *pAccelerationStructure = (VkAccelerationStructureNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( + VkDevice device, + const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2KHR* pMemoryRequirements) +{ + // arbitrary + pMemoryRequirements->memoryRequirements.size = 4096; + pMemoryRequirements->memoryRequirements.alignment = 1; + pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( + VkDevice device, + uint32_t bindInfoCount, + const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( + VkCommandBuffer commandBuffer, + VkAccelerationStructureNV dst, + VkAccelerationStructureNV src, + VkCopyAccelerationStructureModeKHR mode) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( + VkDevice device, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoNV* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( + VkDevice device, + VkAccelerationStructureNV accelerationStructure, + size_t dataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureNV* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( + VkDevice device, + VkPipeline pipeline, + uint32_t shader) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + const void* pHostPointer, + VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( + VkCommandBuffer commandBuffer, + VkPipelineStageFlagBits pipelineStage, + VkBuffer dstBuffer, + VkDeviceSize dstOffset, + uint32_t marker) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pTimeDomainCount, + VkTimeDomainEXT* pTimeDomains) +{ + if (!pTimeDomains) { + *pTimeDomainCount = 1; + } else { + // arbitrary + *pTimeDomains = VK_TIME_DOMAIN_DEVICE_EXT; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( + VkDevice device, + uint32_t timestampCount, + const VkCalibratedTimestampInfoEXT* pTimestampInfos, + uint64_t* pTimestamps, + uint64_t* pMaxDeviation) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +#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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkBool32* pExclusiveScissorEnables) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( + VkCommandBuffer commandBuffer, + uint32_t firstExclusiveScissor, + uint32_t exclusiveScissorCount, + const VkRect2D* pExclusiveScissors) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( + VkCommandBuffer commandBuffer, + const void* pCheckpointMarker) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( + VkQueue queue, + uint32_t* pCheckpointDataCount, + VkCheckpointDataNV* pCheckpointData) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( + VkDevice device, + const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( + VkDevice device) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceMarkerInfoINTEL* pMarkerInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( + VkCommandBuffer commandBuffer, + const VkPerformanceOverrideInfoINTEL* pOverrideInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( + VkDevice device, + const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, + VkPerformanceConfigurationINTEL* pConfiguration) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( + VkDevice device, + VkPerformanceConfigurationINTEL configuration) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( + VkQueue queue, + VkPerformanceConfigurationINTEL configuration) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( + VkDevice device, + VkPerformanceParameterTypeINTEL parameter, + VkPerformanceValueINTEL* pValue) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( + VkDevice device, + VkSwapchainKHR swapChain, + VkBool32 localDimmingEnable) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( + VkInstance instance, + const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_METAL_EXT */ + + + + + + + + + + + + + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( + VkDevice device, + const VkBufferDeviceAddressInfo* pInfo) +{ + return GetBufferDeviceAddress(device, pInfo); +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT( + VkPhysicalDevice physicalDevice, + uint32_t* pToolCount, + VkPhysicalDeviceToolProperties* pToolProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( + VkPhysicalDevice physicalDevice, + uint32_t* pPropertyCount, + VkCooperativeMatrixPropertiesNV* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( + VkPhysicalDevice physicalDevice, + uint32_t* pCombinationCount, + VkFramebufferMixedSamplesCombinationNV* pCombinations) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( + VkPhysicalDevice physicalDevice, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + uint32_t* pPresentModeCount, + VkPresentModeKHR* pPresentModes) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( + VkDevice device, + VkSwapchainKHR swapchain) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( + VkDevice device, + const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, + VkDeviceGroupPresentModeFlagsKHR* pModes) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_WIN32_KHR */ + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( + VkInstance instance, + const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( + VkCommandBuffer commandBuffer, + uint32_t lineStippleFactor, + uint16_t lineStipplePattern) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( + VkDevice device, + VkQueryPool queryPool, + uint32_t firstQuery, + uint32_t queryCount) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT( + VkCommandBuffer commandBuffer, + VkCullModeFlags cullMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT( + VkCommandBuffer commandBuffer, + VkFrontFace frontFace) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT( + VkCommandBuffer commandBuffer, + VkPrimitiveTopology primitiveTopology) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t viewportCount, + const VkViewport* pViewports) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT( + VkCommandBuffer commandBuffer, + uint32_t scissorCount, + const VkRect2D* pScissors) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthWriteEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT( + VkCommandBuffer commandBuffer, + VkCompareOp depthCompareOp) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBoundsTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stencilTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT( + VkCommandBuffer commandBuffer, + VkStencilFaceFlags faceMask, + VkStencilOp failOp, + VkStencilOp passOp, + VkStencilOp depthFailOp, + VkCompareOp compareOp) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT( + VkDevice device, + const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV( + VkDevice device, + const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, + VkMemoryRequirements2* pMemoryRequirements) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV( + VkCommandBuffer commandBuffer, + VkBool32 isPreprocessed, + const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipeline pipeline, + uint32_t groupIndex) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV( + VkDevice device, + const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) +{ + unique_lock_t lock(global_lock); + *pIndirectCommandsLayout = (VkIndirectCommandsLayoutNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV( + VkDevice device, + VkIndirectCommandsLayoutNV indirectCommandsLayout, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT( + VkCommandBuffer commandBuffer, + const VkDepthBiasInfoEXT* pDepthBiasInfo) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + VkDisplayKHR display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( + VkPhysicalDevice physicalDevice, + int32_t drmFd, + uint32_t connectorId, + VkDisplayKHR* display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( + VkDevice device, + const VkPrivateDataSlotCreateInfo* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkPrivateDataSlot* pPrivateDataSlot) +{ + unique_lock_t lock(global_lock); + *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT( + VkDevice device, + VkPrivateDataSlot privateDataSlot, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t data) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT( + VkDevice device, + VkObjectType objectType, + uint64_t objectHandle, + VkPrivateDataSlot privateDataSlot, + uint64_t* pData) +{ +//Not a CREATE or DESTROY function +} + + + + + +#ifdef VK_USE_PLATFORM_METAL_EXT + +static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT( + VkDevice device, + VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) +{ +//Not a CREATE or DESTROY function +} +#endif /* VK_USE_PLATFORM_METAL_EXT */ + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT( + VkDevice device, + VkDescriptorSetLayout layout, + VkDeviceSize* pLayoutSizeInBytes) +{ + // Need to give something non-zero + *pLayoutSizeInBytes = 4; +} + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT( + VkDevice device, + VkDescriptorSetLayout layout, + uint32_t binding, + VkDeviceSize* pOffset) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT( + VkDevice device, + const VkDescriptorGetInfoEXT* pDescriptorInfo, + size_t dataSize, + void* pDescriptor) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT( + VkCommandBuffer commandBuffer, + uint32_t bufferCount, + const VkDescriptorBufferBindingInfoEXT* pBindingInfos) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT( + VkCommandBuffer commandBuffer, + VkPipelineBindPoint pipelineBindPoint, + VkPipelineLayout layout, + uint32_t set) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkBufferCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT( + VkDevice device, + const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV( + VkCommandBuffer commandBuffer, + VkFragmentShadingRateNV shadingRate, + const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) +{ +//Not a CREATE or DESTROY function +} + + + + + + + +static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( + VkDevice device, + VkImage image, + const VkImageSubresource2EXT* pSubresource, + VkSubresourceLayout2EXT* pLayout) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( + VkDevice device, + VkDeviceFaultCountsEXT* pFaultCounts, + VkDeviceFaultInfoEXT* pFaultInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +#ifdef VK_USE_PLATFORM_WIN32_KHR + +static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + VkDisplayKHR display) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV( + VkPhysicalDevice physicalDevice, + uint32_t deviceRelativeId, + VkDisplayKHR* pDisplay) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + IDirectFB* dfb) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#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) +{ +//Not a CREATE or DESTROY function +} + + + + + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( + VkDevice device, + const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA( + VkDevice device, + VkExternalMemoryHandleTypeFlagBits handleType, + zx_handle_t zirconHandle, + VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_FUCHSIA */ + +#ifdef VK_USE_PLATFORM_FUCHSIA + +static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA( + VkDevice device, + const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, + zx_handle_t* pZirconHandle) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#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) +{ + unique_lock_t lock(global_lock); + *pCollection = (VkBufferCollectionFUCHSIA)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA( + VkDevice device, + VkBufferCollectionFUCHSIA collection, + VkBufferCollectionPropertiesFUCHSIA* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_FUCHSIA */ + + +static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( + VkDevice device, + VkRenderPass renderpass, + VkExtent2D* pMaxWorkgroupSize) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI( + VkCommandBuffer commandBuffer) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI( + VkCommandBuffer commandBuffer, + VkImageView imageView, + VkImageLayout imageLayout) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV( + VkDevice device, + const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, + VkRemoteAddressNV* pAddress) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT( + VkDevice device, + const VkPipelineInfoEXT* pPipelineInfo, + VkBaseOutStructure* pPipelineProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT( + VkCommandBuffer commandBuffer, + uint32_t patchControlPoints) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 rasterizerDiscardEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthBiasEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT( + VkCommandBuffer commandBuffer, + VkLogicOp logicOp) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 primitiveRestartEnable) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX( + VkInstance instance, + const VkScreenSurfaceCreateInfoQNX* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkSurfaceKHR* pSurface) +{ + unique_lock_t lock(global_lock); + *pSurface = (VkSurfaceKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX( + VkPhysicalDevice physicalDevice, + uint32_t queueFamilyIndex, + struct _screen_window* window) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ + + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t attachmentCount, + const VkBool32* pColorWriteEnables) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT( + VkCommandBuffer commandBuffer, + uint32_t drawCount, + const VkMultiDrawInfoEXT* pVertexInfo, + uint32_t instanceCount, + uint32_t firstInstance, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( + VkDevice device, + const VkMicromapCreateInfoEXT* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkMicromapEXT* pMicromap) +{ + unique_lock_t lock(global_lock); + *pMicromap = (VkMicromapEXT)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( + VkDevice device, + VkMicromapEXT micromap, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkMicromapBuildInfoEXT* pInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +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) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( + VkCommandBuffer commandBuffer, + const VkCopyMicromapToMemoryInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToMicromapInfoEXT* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( + VkCommandBuffer commandBuffer, + uint32_t micromapCount, + const VkMicromapEXT* pMicromaps, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( + VkDevice device, + const VkMicromapVersionInfoEXT* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkMicromapBuildInfoEXT* pBuildInfo, + VkMicromapBuildSizesInfoEXT* pSizeInfo) +{ +//Not a CREATE or DESTROY function +} + +#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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( + VkDevice device, + VkDeviceMemory memory, + float priority) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( + VkDevice device, + const VkDescriptorSetBindingReferenceVALVE* pBindingReference, + VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( + VkDevice device, + VkDescriptorSet descriptorSet, + void** ppData) +{ +//Not a CREATE or DESTROY function +} + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress copyBufferAddress, + uint32_t copyCount, + uint32_t stride, + VkImage dstImage, + VkImageLayout dstImageLayout, + const VkImageSubresourceLayers* pImageSubresources) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV( + VkCommandBuffer commandBuffer, + uint32_t decompressRegionCount, + const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV( + VkCommandBuffer commandBuffer, + VkDeviceAddress indirectCommandsAddress, + VkDeviceAddress indirectCommandsCountAddress, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( + VkCommandBuffer commandBuffer, + VkTessellationDomainOrigin domainOrigin) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClampEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( + VkCommandBuffer commandBuffer, + VkPolygonMode polygonMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits rasterizationSamples) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( + VkCommandBuffer commandBuffer, + VkSampleCountFlagBits samples, + const VkSampleMask* pSampleMask) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToCoverageEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 alphaToOneEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 logicOpEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkBool32* pColorBlendEnables) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendEquationEXT* pColorBlendEquations) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorComponentFlags* pColorWriteMasks) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( + VkCommandBuffer commandBuffer, + uint32_t rasterizationStream) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkConservativeRasterizationModeEXT conservativeRasterizationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( + VkCommandBuffer commandBuffer, + float extraPrimitiveOverestimationSize) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 depthClipEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 sampleLocationsEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( + VkCommandBuffer commandBuffer, + uint32_t firstAttachment, + uint32_t attachmentCount, + const VkColorBlendAdvancedEXT* pColorBlendAdvanced) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( + VkCommandBuffer commandBuffer, + VkProvokingVertexModeEXT provokingVertexMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( + VkCommandBuffer commandBuffer, + VkLineRasterizationModeEXT lineRasterizationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( + VkCommandBuffer commandBuffer, + VkBool32 stippledLineEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( + VkCommandBuffer commandBuffer, + VkBool32 negativeOneToOne) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 viewportWScalingEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( + VkCommandBuffer commandBuffer, + uint32_t firstViewport, + uint32_t viewportCount, + const VkViewportSwizzleNV* pViewportSwizzles) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageToColorEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( + VkCommandBuffer commandBuffer, + uint32_t coverageToColorLocation) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( + VkCommandBuffer commandBuffer, + VkCoverageModulationModeNV coverageModulationMode) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 coverageModulationTableEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( + VkCommandBuffer commandBuffer, + uint32_t coverageModulationTableCount, + const float* pCoverageModulationTable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 shadingRateImageEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( + VkCommandBuffer commandBuffer, + VkBool32 representativeFragmentTestEnable) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( + VkCommandBuffer commandBuffer, + VkCoverageReductionModeNV coverageReductionMode) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( + VkDevice device, + VkShaderModule shaderModule, + VkShaderModuleIdentifierEXT* pIdentifier) +{ + if (pIdentifier) { + // arbitrary + pIdentifier->identifierSize = 1; + pIdentifier->identifier[0] = 0x01; + } +} + +static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( + VkDevice device, + const VkShaderModuleCreateInfo* pCreateInfo, + VkShaderModuleIdentifierEXT* pIdentifier) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( + VkPhysicalDevice physicalDevice, + const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, + uint32_t* pFormatCount, + VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( + VkDevice device, + const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkOpticalFlowSessionNV* pSession) +{ + unique_lock_t lock(global_lock); + *pSession = (VkOpticalFlowSessionNV)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( + VkDevice device, + VkOpticalFlowSessionNV session, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( + VkDevice device, + VkOpticalFlowSessionNV session, + VkOpticalFlowSessionBindingPointNV bindingPoint, + VkImageView view, + VkImageLayout layout) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( + VkCommandBuffer commandBuffer, + VkOpticalFlowSessionNV session, + const VkOpticalFlowExecuteInfoNV* pExecuteInfo) +{ +//Not a CREATE or DESTROY function +} + + + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT( + VkDevice device, + uint32_t createInfoCount, + const VkShaderCreateInfoEXT* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkShaderEXT* pShaders) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pShaders[i] = (VkShaderEXT)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT( + VkDevice device, + VkShaderEXT shader, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT( + VkDevice device, + VkShaderEXT shader, + size_t* pDataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( + VkCommandBuffer commandBuffer, + uint32_t stageCount, + const VkShaderStageFlagBits* pStages, + const VkShaderEXT* pShaders) +{ +//Not a CREATE or DESTROY function +} + + +static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( + VkDevice device, + VkFramebuffer framebuffer, + uint32_t* pPropertiesCount, + VkTilePropertiesQCOM* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( + VkDevice device, + const VkRenderingInfo* pRenderingInfo, + VkTilePropertiesQCOM* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + + + + + + + + + + +static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( + VkCommandBuffer commandBuffer, + VkImageAspectFlags aspectMask) +{ +//Not a CREATE or DESTROY function +} + +#ifdef VK_USE_PLATFORM_SCREEN_QNX + +static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX( + VkDevice device, + const struct _screen_buffer* buffer, + VkScreenBufferPropertiesQNX* pProperties) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} +#endif /* VK_USE_PLATFORM_SCREEN_QNX */ + + +static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( + VkDevice device, + const VkAccelerationStructureCreateInfoKHR* pCreateInfo, + const VkAllocationCallbacks* pAllocator, + VkAccelerationStructureKHR* pAccelerationStructure) +{ + unique_lock_t lock(global_lock); + *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++; + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( + VkDevice device, + VkAccelerationStructureKHR accelerationStructure, + const VkAllocationCallbacks* pAllocator) +{ +//Destroy object +} + +static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( + VkCommandBuffer commandBuffer, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ +//Not a CREATE or DESTROY function +} + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + uint32_t infoCount, + const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, + const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +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) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( + VkCommandBuffer commandBuffer, + const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( + VkCommandBuffer commandBuffer, + const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( + VkDevice device, + const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) +{ + // arbitrary - need to be aligned to 256 bytes + return 0x262144; +} + +static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( + VkCommandBuffer commandBuffer, + uint32_t accelerationStructureCount, + const VkAccelerationStructureKHR* pAccelerationStructures, + VkQueryType queryType, + VkQueryPool queryPool, + uint32_t firstQuery) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( + VkDevice device, + const VkAccelerationStructureVersionInfoKHR* pVersionInfo, + VkAccelerationStructureCompatibilityKHR* pCompatibility) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( + VkDevice device, + VkAccelerationStructureBuildTypeKHR buildType, + const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, + const uint32_t* pMaxPrimitiveCounts, + VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) +{ + // arbitrary + pSizeInfo->accelerationStructureSize = 4; + pSizeInfo->updateScratchSize = 4; + pSizeInfo->buildScratchSize = 4; +} + + +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) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR( + VkDevice device, + VkDeferredOperationKHR deferredOperation, + VkPipelineCache pipelineCache, + uint32_t createInfoCount, + const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, + const VkAllocationCallbacks* pAllocator, + VkPipeline* pPipelines) +{ + unique_lock_t lock(global_lock); + for (uint32_t i = 0; i < createInfoCount; ++i) { + pPipelines[i] = (VkPipeline)global_unique_handle++; + } + return VK_SUCCESS; +} + +static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t firstGroup, + uint32_t groupCount, + size_t dataSize, + void* pData) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR( + VkCommandBuffer commandBuffer, + const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, + const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, + VkDeviceAddress indirectDeviceAddress) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR( + VkDevice device, + VkPipeline pipeline, + uint32_t group, + VkShaderGroupShaderKHR groupShader) +{ +//Not a CREATE or DESTROY function + return VK_SUCCESS; +} + +static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR( + VkCommandBuffer commandBuffer, + uint32_t pipelineStackSize) +{ +//Not a CREATE or DESTROY function +} + + + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT( + VkCommandBuffer commandBuffer, + uint32_t groupCountX, + uint32_t groupCountY, + uint32_t groupCountZ) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + uint32_t drawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT( + VkCommandBuffer commandBuffer, + VkBuffer buffer, + VkDeviceSize offset, + VkBuffer countBuffer, + VkDeviceSize countBufferOffset, + uint32_t maxDrawCount, + uint32_t stride) +{ +//Not a CREATE or DESTROY function +} + +} // namespace vkmock + diff --git a/icd/generated/mock_icd.cpp b/icd/generated/mock_icd.cpp deleted file mode 100644 index f3e8f127..00000000 --- a/icd/generated/mock_icd.cpp +++ /dev/null @@ -1,7211 +0,0 @@ -/* -** 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. -** -*/ - -#include "mock_icd.h" -#include -#include -#include -#include -#include "vk_typemap_helper.h" -namespace vkmock { - - -using std::unordered_map; - -static constexpr uint32_t icd_physical_device_count = 1; -static unordered_map> physical_device_map; - -// Map device memory handle to any mapped allocations that we'll need to free on unmap -static unordered_map> mapped_memory_map; - -// Map device memory allocation handle to the size -static unordered_map allocated_memory_size_map; - -static unordered_map>> queue_map; -static VkDeviceAddress current_available_address = 0x10000000; -struct BufferState { - VkDeviceSize size; - VkDeviceAddress address; -}; -static unordered_map> buffer_map; -static unordered_map> image_memory_size_map; -static unordered_map> command_pool_buffer_map; - -static constexpr uint32_t icd_swapchain_image_count = 1; -static unordered_map swapchain_image_map; - -// TODO: Would like to codegen this but limits aren't in XML -static VkPhysicalDeviceLimits SetLimits(VkPhysicalDeviceLimits *limits) { - limits->maxImageDimension1D = 4096; - limits->maxImageDimension2D = 4096; - limits->maxImageDimension3D = 256; - limits->maxImageDimensionCube = 4096; - limits->maxImageArrayLayers = 256; - limits->maxTexelBufferElements = 65536; - limits->maxUniformBufferRange = 16384; - limits->maxStorageBufferRange = 134217728; - limits->maxPushConstantsSize = 128; - limits->maxMemoryAllocationCount = 4096; - limits->maxSamplerAllocationCount = 4000; - limits->bufferImageGranularity = 1; - limits->sparseAddressSpaceSize = 2147483648; - limits->maxBoundDescriptorSets = 4; - limits->maxPerStageDescriptorSamplers = 16; - limits->maxPerStageDescriptorUniformBuffers = 12; - limits->maxPerStageDescriptorStorageBuffers = 4; - limits->maxPerStageDescriptorSampledImages = 16; - limits->maxPerStageDescriptorStorageImages = 4; - limits->maxPerStageDescriptorInputAttachments = 4; - limits->maxPerStageResources = 128; - limits->maxDescriptorSetSamplers = 96; - limits->maxDescriptorSetUniformBuffers = 72; - limits->maxDescriptorSetUniformBuffersDynamic = 8; - limits->maxDescriptorSetStorageBuffers = 24; - limits->maxDescriptorSetStorageBuffersDynamic = 4; - limits->maxDescriptorSetSampledImages = 96; - limits->maxDescriptorSetStorageImages = 24; - limits->maxDescriptorSetInputAttachments = 4; - limits->maxVertexInputAttributes = 16; - limits->maxVertexInputBindings = 16; - limits->maxVertexInputAttributeOffset = 2047; - limits->maxVertexInputBindingStride = 2048; - limits->maxVertexOutputComponents = 64; - limits->maxTessellationGenerationLevel = 64; - limits->maxTessellationPatchSize = 32; - limits->maxTessellationControlPerVertexInputComponents = 64; - limits->maxTessellationControlPerVertexOutputComponents = 64; - limits->maxTessellationControlPerPatchOutputComponents = 120; - limits->maxTessellationControlTotalOutputComponents = 2048; - limits->maxTessellationEvaluationInputComponents = 64; - limits->maxTessellationEvaluationOutputComponents = 64; - limits->maxGeometryShaderInvocations = 32; - limits->maxGeometryInputComponents = 64; - limits->maxGeometryOutputComponents = 64; - limits->maxGeometryOutputVertices = 256; - limits->maxGeometryTotalOutputComponents = 1024; - limits->maxFragmentInputComponents = 64; - limits->maxFragmentOutputAttachments = 4; - limits->maxFragmentDualSrcAttachments = 1; - limits->maxFragmentCombinedOutputResources = 4; - limits->maxComputeSharedMemorySize = 16384; - limits->maxComputeWorkGroupCount[0] = 65535; - limits->maxComputeWorkGroupCount[1] = 65535; - limits->maxComputeWorkGroupCount[2] = 65535; - limits->maxComputeWorkGroupInvocations = 128; - limits->maxComputeWorkGroupSize[0] = 128; - limits->maxComputeWorkGroupSize[1] = 128; - limits->maxComputeWorkGroupSize[2] = 64; - limits->subPixelPrecisionBits = 4; - limits->subTexelPrecisionBits = 4; - limits->mipmapPrecisionBits = 4; - limits->maxDrawIndexedIndexValue = UINT32_MAX; - limits->maxDrawIndirectCount = UINT16_MAX; - limits->maxSamplerLodBias = 2.0f; - limits->maxSamplerAnisotropy = 16; - limits->maxViewports = 16; - limits->maxViewportDimensions[0] = 4096; - limits->maxViewportDimensions[1] = 4096; - limits->viewportBoundsRange[0] = -8192; - limits->viewportBoundsRange[1] = 8191; - limits->viewportSubPixelBits = 0; - limits->minMemoryMapAlignment = 64; - limits->minTexelBufferOffsetAlignment = 16; - limits->minUniformBufferOffsetAlignment = 16; - limits->minStorageBufferOffsetAlignment = 16; - limits->minTexelOffset = -8; - limits->maxTexelOffset = 7; - limits->minTexelGatherOffset = -8; - limits->maxTexelGatherOffset = 7; - limits->minInterpolationOffset = 0.0f; - limits->maxInterpolationOffset = 0.5f; - limits->subPixelInterpolationOffsetBits = 4; - limits->maxFramebufferWidth = 4096; - limits->maxFramebufferHeight = 4096; - limits->maxFramebufferLayers = 256; - limits->framebufferColorSampleCounts = 0x7F; - limits->framebufferDepthSampleCounts = 0x7F; - limits->framebufferStencilSampleCounts = 0x7F; - limits->framebufferNoAttachmentsSampleCounts = 0x7F; - limits->maxColorAttachments = 4; - limits->sampledImageColorSampleCounts = 0x7F; - limits->sampledImageIntegerSampleCounts = 0x7F; - limits->sampledImageDepthSampleCounts = 0x7F; - limits->sampledImageStencilSampleCounts = 0x7F; - limits->storageImageSampleCounts = 0x7F; - limits->maxSampleMaskWords = 1; - limits->timestampComputeAndGraphics = VK_TRUE; - limits->timestampPeriod = 1; - limits->maxClipDistances = 8; - limits->maxCullDistances = 8; - limits->maxCombinedClipAndCullDistances = 8; - limits->discreteQueuePriorities = 2; - limits->pointSizeRange[0] = 1.0f; - limits->pointSizeRange[1] = 64.0f; - limits->lineWidthRange[0] = 1.0f; - limits->lineWidthRange[1] = 8.0f; - limits->pointSizeGranularity = 1.0f; - limits->lineWidthGranularity = 1.0f; - limits->strictLines = VK_TRUE; - limits->standardSampleLocations = VK_TRUE; - limits->optimalBufferCopyOffsetAlignment = 1; - limits->optimalBufferCopyRowPitchAlignment = 1; - limits->nonCoherentAtomSize = 256; - - return *limits; -} - -void SetBoolArrayTrue(VkBool32* bool_array, uint32_t num_bools) -{ - for (uint32_t i = 0; i < num_bools; ++i) { - bool_array[i] = VK_TRUE; - } -} - -VkDeviceSize GetImageSizeFromCreateInfo(const VkImageCreateInfo* pCreateInfo) -{ - VkDeviceSize size = pCreateInfo->extent.width; - size *= pCreateInfo->extent.height; - size *= pCreateInfo->extent.depth; - // TODO: A pixel size is 32 bytes. This accounts for the largest possible pixel size of any format. It could be changed to more accurate size if need be. - size *= 32; - size *= pCreateInfo->arrayLayers; - size *= (pCreateInfo->mipLevels > 1 ? 2 : 1); - - switch (pCreateInfo->format) { - case VK_FORMAT_G8_B8_R8_3PLANE_420_UNORM: - case VK_FORMAT_G8_B8_R8_3PLANE_422_UNORM: - case VK_FORMAT_G8_B8_R8_3PLANE_444_UNORM: - case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_420_UNORM_3PACK16: - case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_422_UNORM_3PACK16: - case VK_FORMAT_G10X6_B10X6_R10X6_3PLANE_444_UNORM_3PACK16: - case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_420_UNORM_3PACK16: - case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_422_UNORM_3PACK16: - case VK_FORMAT_G12X4_B12X4_R12X4_3PLANE_444_UNORM_3PACK16: - case VK_FORMAT_G16_B16_R16_3PLANE_420_UNORM: - case VK_FORMAT_G16_B16_R16_3PLANE_422_UNORM: - case VK_FORMAT_G16_B16_R16_3PLANE_444_UNORM: - size *= 3; - break; - case VK_FORMAT_G8_B8R8_2PLANE_420_UNORM: - case VK_FORMAT_G8_B8R8_2PLANE_422_UNORM: - case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_420_UNORM_3PACK16: - case VK_FORMAT_G10X6_B10X6R10X6_2PLANE_422_UNORM_3PACK16: - case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_420_UNORM_3PACK16: - case VK_FORMAT_G12X4_B12X4R12X4_2PLANE_422_UNORM_3PACK16: - case VK_FORMAT_G16_B16R16_2PLANE_420_UNORM: - case VK_FORMAT_G16_B16R16_2PLANE_422_UNORM: - size *= 2; - break; - default: - break; - } - - return size; -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateInstance( - const VkInstanceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkInstance* pInstance) -{ - - // TODO: If loader ver <=4 ICD must fail with VK_ERROR_INCOMPATIBLE_DRIVER for all vkCreateInstance calls with - // apiVersion set to > Vulkan 1.0 because the loader is still at interface version <= 4. Otherwise, the - // ICD should behave as normal. - if (loader_interface_version <= 4) { - return VK_ERROR_INCOMPATIBLE_DRIVER; - } - *pInstance = (VkInstance)CreateDispObjHandle(); - for (auto& physical_device : physical_device_map[*pInstance]) - physical_device = (VkPhysicalDevice)CreateDispObjHandle(); - // TODO: If emulating specific device caps, will need to add intelligence here - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyInstance( - VkInstance instance, - const VkAllocationCallbacks* pAllocator) -{ - - if (instance) { - for (const auto physical_device : physical_device_map.at(instance)) - DestroyDispObjHandle((void*)physical_device); - physical_device_map.erase(instance); - DestroyDispObjHandle((void*)instance); - } -} - -static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDevices( - VkInstance instance, - uint32_t* pPhysicalDeviceCount, - VkPhysicalDevice* pPhysicalDevices) -{ - VkResult result_code = VK_SUCCESS; - if (pPhysicalDevices) { - const auto return_count = (std::min)(*pPhysicalDeviceCount, icd_physical_device_count); - for (uint32_t i = 0; i < return_count; ++i) pPhysicalDevices[i] = physical_device_map.at(instance)[i]; - if (return_count < icd_physical_device_count) result_code = VK_INCOMPLETE; - *pPhysicalDeviceCount = return_count; - } else { - *pPhysicalDeviceCount = icd_physical_device_count; - } - return result_code; -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures* pFeatures) -{ - uint32_t num_bools = sizeof(VkPhysicalDeviceFeatures) / sizeof(VkBool32); - VkBool32 *bool_array = &pFeatures->robustBufferAccess; - SetBoolArrayTrue(bool_array, num_bools); -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties* pFormatProperties) -{ - if (VK_FORMAT_UNDEFINED == format) { - *pFormatProperties = { 0x0, 0x0, 0x0 }; - } else { - // Default to a color format, skip DS bit - *pFormatProperties = { 0x00FFFDFF, 0x00FFFDFF, 0x00FFFDFF }; - switch (format) { - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_X8_D24_UNORM_PACK32: - case VK_FORMAT_D32_SFLOAT: - case VK_FORMAT_S8_UINT: - case VK_FORMAT_D16_UNORM_S8_UINT: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: - // Don't set color bits for DS formats - *pFormatProperties = { 0x00FFFE7F, 0x00FFFE7F, 0x00FFFE7F }; - break; - default: - break; - } - } -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkImageTiling tiling, - VkImageUsageFlags usage, - VkImageCreateFlags flags, - VkImageFormatProperties* pImageFormatProperties) -{ - // A hardcoded unsupported format - if (format == VK_FORMAT_E5B9G9R9_UFLOAT_PACK32) { - return VK_ERROR_FORMAT_NOT_SUPPORTED; - } - - // TODO: Just hard-coding some values for now - // TODO: If tiling is linear, limit the mips, levels, & sample count - if (VK_IMAGE_TILING_LINEAR == tiling) { - *pImageFormatProperties = { { 4096, 4096, 256 }, 1, 1, VK_SAMPLE_COUNT_1_BIT, 4294967296 }; - } else { - // We hard-code support for all sample counts except 64 bits. - *pImageFormatProperties = { { 4096, 4096, 256 }, 12, 256, 0x7F & ~VK_SAMPLE_COUNT_64_BIT, 4294967296 }; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties* pProperties) -{ - pProperties->apiVersion = VK_HEADER_VERSION_COMPLETE; - pProperties->driverVersion = 1; - pProperties->vendorID = 0xba5eba11; - pProperties->deviceID = 0xf005ba11; - pProperties->deviceType = VK_PHYSICAL_DEVICE_TYPE_VIRTUAL_GPU; - //std::string devName = "Vulkan Mock Device"; - strcpy(pProperties->deviceName, "Vulkan Mock Device"); - pProperties->pipelineCacheUUID[0] = 18; - pProperties->limits = SetLimits(&pProperties->limits); - pProperties->sparseProperties = { VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE, VK_TRUE }; -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties* pQueueFamilyProperties) -{ - if (!pQueueFamilyProperties) { - *pQueueFamilyPropertyCount = 1; - } else { - if (*pQueueFamilyPropertyCount) { - pQueueFamilyProperties[0].queueFlags = VK_QUEUE_GRAPHICS_BIT | VK_QUEUE_COMPUTE_BIT | VK_QUEUE_TRANSFER_BIT | VK_QUEUE_SPARSE_BINDING_BIT | VK_QUEUE_PROTECTED_BIT; - pQueueFamilyProperties[0].queueCount = 1; - pQueueFamilyProperties[0].timestampValidBits = 16; - pQueueFamilyProperties[0].minImageTransferGranularity = {1,1,1}; - } - } -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties* pMemoryProperties) -{ - pMemoryProperties->memoryTypeCount = 6; - // Host visible Coherent - pMemoryProperties->memoryTypes[0].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - pMemoryProperties->memoryTypes[0].heapIndex = 0; - // Host visible Cached - pMemoryProperties->memoryTypes[1].propertyFlags = VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT; - pMemoryProperties->memoryTypes[1].heapIndex = 0; - // Device local and Host visible - pMemoryProperties->memoryTypes[2].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_HOST_VISIBLE_BIT | VK_MEMORY_PROPERTY_HOST_CACHED_BIT | VK_MEMORY_PROPERTY_HOST_COHERENT_BIT; - pMemoryProperties->memoryTypes[2].heapIndex = 1; - // Device local lazily - pMemoryProperties->memoryTypes[3].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_LAZILY_ALLOCATED_BIT; - pMemoryProperties->memoryTypes[3].heapIndex = 1; - // Device local protected - pMemoryProperties->memoryTypes[4].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT | VK_MEMORY_PROPERTY_PROTECTED_BIT; - pMemoryProperties->memoryTypes[4].heapIndex = 1; - // Device local only - pMemoryProperties->memoryTypes[5].propertyFlags = VK_MEMORY_PROPERTY_DEVICE_LOCAL_BIT; - pMemoryProperties->memoryTypes[5].heapIndex = 1; - pMemoryProperties->memoryHeapCount = 2; - pMemoryProperties->memoryHeaps[0].flags = VK_MEMORY_HEAP_MULTI_INSTANCE_BIT; - pMemoryProperties->memoryHeaps[0].size = 8000000000; - pMemoryProperties->memoryHeaps[1].flags = VK_MEMORY_HEAP_DEVICE_LOCAL_BIT; - pMemoryProperties->memoryHeaps[1].size = 8000000000; -} - -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetInstanceProcAddr( - VkInstance instance, - const char* pName) -{ - - if (!negotiate_loader_icd_interface_called) { - loader_interface_version = 0; - } - const auto &item = name_to_funcptr_map.find(pName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - // Mock should intercept all functions so if we get here just return null - return nullptr; -} - -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetDeviceProcAddr( - VkDevice device, - const char* pName) -{ - - return GetInstanceProcAddr(nullptr, pName); -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDevice( - VkPhysicalDevice physicalDevice, - const VkDeviceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDevice* pDevice) -{ - - *pDevice = (VkDevice)CreateDispObjHandle(); - // TODO: If emulating specific device caps, will need to add intelligence here - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDevice( - VkDevice device, - const VkAllocationCallbacks* pAllocator) -{ - - unique_lock_t lock(global_lock); - // First destroy sub-device objects - // Destroy Queues - for (auto queue_family_map_pair : queue_map[device]) { - for (auto index_queue_pair : queue_map[device][queue_family_map_pair.first]) { - DestroyDispObjHandle((void*)index_queue_pair.second); - } - } - - queue_map.erase(device); - buffer_map.erase(device); - image_memory_size_map.erase(device); - // Now destroy device - DestroyDispObjHandle((void*)device); - // TODO: If emulating specific device caps, will need to add intelligence here -} - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceExtensionProperties( - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) -{ - - // If requesting number of extensions, return that - if (!pLayerName) { - if (!pProperties) { - *pPropertyCount = (uint32_t)instance_extension_map.size(); - } else { - uint32_t i = 0; - for (const auto &name_ver_pair : instance_extension_map) { - if (i == *pPropertyCount) { - break; - } - std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName)); - pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0; - pProperties[i].specVersion = name_ver_pair.second; - ++i; - } - if (i != instance_extension_map.size()) { - return VK_INCOMPLETE; - } - } - } - // If requesting extension properties, fill in data struct for number of extensions - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceExtensionProperties( - VkPhysicalDevice physicalDevice, - const char* pLayerName, - uint32_t* pPropertyCount, - VkExtensionProperties* pProperties) -{ - - // If requesting number of extensions, return that - if (!pLayerName) { - if (!pProperties) { - *pPropertyCount = (uint32_t)device_extension_map.size(); - } else { - uint32_t i = 0; - for (const auto &name_ver_pair : device_extension_map) { - if (i == *pPropertyCount) { - break; - } - std::strncpy(pProperties[i].extensionName, name_ver_pair.first.c_str(), sizeof(pProperties[i].extensionName)); - pProperties[i].extensionName[sizeof(pProperties[i].extensionName) - 1] = 0; - pProperties[i].specVersion = name_ver_pair.second; - ++i; - } - if (i != device_extension_map.size()) { - return VK_INCOMPLETE; - } - } - } - // If requesting extension properties, fill in data struct for number of extensions - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceLayerProperties( - uint32_t* pPropertyCount, - VkLayerProperties* pProperties) -{ - - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateDeviceLayerProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkLayerProperties* pProperties) -{ - - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue( - VkDevice device, - uint32_t queueFamilyIndex, - uint32_t queueIndex, - VkQueue* pQueue) -{ - unique_lock_t lock(global_lock); - auto queue = queue_map[device][queueFamilyIndex][queueIndex]; - if (queue) { - *pQueue = queue; - } else { - *pQueue = queue_map[device][queueFamilyIndex][queueIndex] = (VkQueue)CreateDispObjHandle(); - } - // TODO: If emulating specific device caps, will need to add intelligence here - return; -} - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo* pSubmits, - VkFence fence) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL QueueWaitIdle( - VkQueue queue) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL DeviceWaitIdle( - VkDevice device) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL AllocateMemory( - VkDevice device, - const VkMemoryAllocateInfo* pAllocateInfo, - const VkAllocationCallbacks* pAllocator, - VkDeviceMemory* pMemory) -{ - unique_lock_t lock(global_lock); - allocated_memory_size_map[(VkDeviceMemory)global_unique_handle] = pAllocateInfo->allocationSize; - *pMemory = (VkDeviceMemory)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL FreeMemory( - VkDevice device, - VkDeviceMemory memory, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object - unique_lock_t lock(global_lock); - allocated_memory_size_map.erase(memory); -} - -static VKAPI_ATTR VkResult VKAPI_CALL MapMemory( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize offset, - VkDeviceSize size, - VkMemoryMapFlags flags, - void** ppData) -{ - unique_lock_t lock(global_lock); - if (VK_WHOLE_SIZE == size) { - if (allocated_memory_size_map.count(memory) != 0) - size = allocated_memory_size_map[memory] - offset; - else - size = 0x10000; - } - void* map_addr = malloc((size_t)size); - mapped_memory_map[memory].push_back(map_addr); - *ppData = map_addr; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL UnmapMemory( - VkDevice device, - VkDeviceMemory memory) -{ - unique_lock_t lock(global_lock); - for (auto map_addr : mapped_memory_map[memory]) { - free(map_addr); - } - mapped_memory_map.erase(memory); -} - -static VKAPI_ATTR VkResult VKAPI_CALL FlushMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL InvalidateMappedMemoryRanges( - VkDevice device, - uint32_t memoryRangeCount, - const VkMappedMemoryRange* pMemoryRanges) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceMemoryCommitment( - VkDevice device, - VkDeviceMemory memory, - VkDeviceSize* pCommittedMemoryInBytes) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory( - VkDevice device, - VkBuffer buffer, - VkDeviceMemory memory, - VkDeviceSize memoryOffset) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory( - VkDevice device, - VkImage image, - VkDeviceMemory memory, - VkDeviceSize memoryOffset) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements( - VkDevice device, - VkBuffer buffer, - VkMemoryRequirements* pMemoryRequirements) -{ - // TODO: Just hard-coding reqs for now - pMemoryRequirements->size = 4096; - pMemoryRequirements->alignment = 1; - pMemoryRequirements->memoryTypeBits = 0xFFFF; - // Return a better size based on the buffer size from the create info. - unique_lock_t lock(global_lock); - auto d_iter = buffer_map.find(device); - if (d_iter != buffer_map.end()) { - auto iter = d_iter->second.find(buffer); - if (iter != d_iter->second.end()) { - pMemoryRequirements->size = ((iter->second.size + 4095) / 4096) * 4096; - } - } -} - -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements( - VkDevice device, - VkImage image, - VkMemoryRequirements* pMemoryRequirements) -{ - pMemoryRequirements->size = 0; - pMemoryRequirements->alignment = 1; - - unique_lock_t lock(global_lock); - auto d_iter = image_memory_size_map.find(device); - if(d_iter != image_memory_size_map.end()){ - auto iter = d_iter->second.find(image); - if (iter != d_iter->second.end()) { - pMemoryRequirements->size = iter->second; - } - } - // Here we hard-code that the memory type at index 3 doesn't support this image. - pMemoryRequirements->memoryTypeBits = 0xFFFF & ~(0x1 << 3); -} - -static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements( - VkDevice device, - VkImage image, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements* pSparseMemoryRequirements) -{ - if (!pSparseMemoryRequirements) { - *pSparseMemoryRequirementCount = 1; - } else { - // arbitrary - pSparseMemoryRequirements->imageMipTailFirstLod = 0; - pSparseMemoryRequirements->imageMipTailSize = 8; - pSparseMemoryRequirements->imageMipTailOffset = 0; - pSparseMemoryRequirements->imageMipTailStride = 4; - pSparseMemoryRequirements->formatProperties.imageGranularity = {4, 4, 4}; - pSparseMemoryRequirements->formatProperties.flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; - // Would need to track the VkImage to know format for better value here - pSparseMemoryRequirements->formatProperties.aspectMask = VK_IMAGE_ASPECT_COLOR_BIT | VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT | VK_IMAGE_ASPECT_METADATA_BIT; - } - -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkImageType type, - VkSampleCountFlagBits samples, - VkImageUsageFlags usage, - VkImageTiling tiling, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties* pProperties) -{ - if (!pProperties) { - *pPropertyCount = 1; - } else { - // arbitrary - pProperties->imageGranularity = {4, 4, 4}; - pProperties->flags = VK_SPARSE_IMAGE_FORMAT_SINGLE_MIPTAIL_BIT; - switch (format) { - case VK_FORMAT_D16_UNORM: - case VK_FORMAT_D32_SFLOAT: - pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT; - break; - case VK_FORMAT_S8_UINT: - pProperties->aspectMask = VK_IMAGE_ASPECT_STENCIL_BIT; - break; - case VK_FORMAT_X8_D24_UNORM_PACK32: - case VK_FORMAT_D16_UNORM_S8_UINT: - case VK_FORMAT_D24_UNORM_S8_UINT: - case VK_FORMAT_D32_SFLOAT_S8_UINT: - pProperties->aspectMask = VK_IMAGE_ASPECT_DEPTH_BIT | VK_IMAGE_ASPECT_STENCIL_BIT; - break; - default: - pProperties->aspectMask = VK_IMAGE_ASPECT_COLOR_BIT; - break; - } - } -} - -static VKAPI_ATTR VkResult VKAPI_CALL QueueBindSparse( - VkQueue queue, - uint32_t bindInfoCount, - const VkBindSparseInfo* pBindInfo, - VkFence fence) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateFence( - VkDevice device, - const VkFenceCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) -{ - unique_lock_t lock(global_lock); - *pFence = (VkFence)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyFence( - VkDevice device, - VkFence fence, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL ResetFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceStatus( - VkDevice device, - VkFence fence) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL WaitForFences( - VkDevice device, - uint32_t fenceCount, - const VkFence* pFences, - VkBool32 waitAll, - uint64_t timeout) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSemaphore( - VkDevice device, - const VkSemaphoreCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSemaphore* pSemaphore) -{ - unique_lock_t lock(global_lock); - *pSemaphore = (VkSemaphore)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroySemaphore( - VkDevice device, - VkSemaphore semaphore, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateEvent( - VkDevice device, - const VkEventCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkEvent* pEvent) -{ - unique_lock_t lock(global_lock); - *pEvent = (VkEvent)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyEvent( - VkDevice device, - VkEvent event, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetEventStatus( - VkDevice device, - VkEvent event) -{ -//Not a CREATE or DESTROY function - return VK_EVENT_SET; -} - -static VKAPI_ATTR VkResult VKAPI_CALL SetEvent( - VkDevice device, - VkEvent event) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL ResetEvent( - VkDevice device, - VkEvent event) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateQueryPool( - VkDevice device, - const VkQueryPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkQueryPool* pQueryPool) -{ - unique_lock_t lock(global_lock); - *pQueryPool = (VkQueryPool)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyQueryPool( - VkDevice device, - VkQueryPool queryPool, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -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) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateBuffer( - VkDevice device, - const VkBufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBuffer* pBuffer) -{ - unique_lock_t lock(global_lock); - *pBuffer = (VkBuffer)global_unique_handle++; - buffer_map[device][*pBuffer] = { - pCreateInfo->size, - current_available_address - }; - current_available_address += pCreateInfo->size; - // Always align to next 64-bit pointer - const uint64_t alignment = current_available_address % 64; - if (alignment != 0) { - current_available_address += (64 - alignment); - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyBuffer( - VkDevice device, - VkBuffer buffer, - const VkAllocationCallbacks* pAllocator) -{ - unique_lock_t lock(global_lock); - buffer_map[device].erase(buffer); -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateBufferView( - VkDevice device, - const VkBufferViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkBufferView* pView) -{ - unique_lock_t lock(global_lock); - *pView = (VkBufferView)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyBufferView( - VkDevice device, - VkBufferView bufferView, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateImage( - VkDevice device, - const VkImageCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImage* pImage) -{ - unique_lock_t lock(global_lock); - *pImage = (VkImage)global_unique_handle++; - image_memory_size_map[device][*pImage] = GetImageSizeFromCreateInfo(pCreateInfo); - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyImage( - VkDevice device, - VkImage image, - const VkAllocationCallbacks* pAllocator) -{ - unique_lock_t lock(global_lock); - image_memory_size_map[device].erase(image); -} - -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout( - VkDevice device, - VkImage image, - const VkImageSubresource* pSubresource, - VkSubresourceLayout* pLayout) -{ - // Need safe values. Callers are computing memory offsets from pLayout, with no return code to flag failure. - *pLayout = VkSubresourceLayout(); // Default constructor zero values. -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateImageView( - VkDevice device, - const VkImageViewCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkImageView* pView) -{ - unique_lock_t lock(global_lock); - *pView = (VkImageView)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyImageView( - VkDevice device, - VkImageView imageView, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateShaderModule( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkShaderModule* pShaderModule) -{ - unique_lock_t lock(global_lock); - *pShaderModule = (VkShaderModule)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyShaderModule( - VkDevice device, - VkShaderModule shaderModule, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineCache( - VkDevice device, - const VkPipelineCacheCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineCache* pPipelineCache) -{ - unique_lock_t lock(global_lock); - *pPipelineCache = (VkPipelineCache)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyPipelineCache( - VkDevice device, - VkPipelineCache pipelineCache, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineCacheData( - VkDevice device, - VkPipelineCache pipelineCache, - size_t* pDataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL MergePipelineCaches( - VkDevice device, - VkPipelineCache dstCache, - uint32_t srcCacheCount, - const VkPipelineCache* pSrcCaches) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateGraphicsPipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkGraphicsPipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - pPipelines[i] = (VkPipeline)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateComputePipelines( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkComputePipelineCreateInfo* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - pPipelines[i] = (VkPipeline)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyPipeline( - VkDevice device, - VkPipeline pipeline, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePipelineLayout( - VkDevice device, - const VkPipelineLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPipelineLayout* pPipelineLayout) -{ - unique_lock_t lock(global_lock); - *pPipelineLayout = (VkPipelineLayout)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyPipelineLayout( - VkDevice device, - VkPipelineLayout pipelineLayout, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSampler( - VkDevice device, - const VkSamplerCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSampler* pSampler) -{ - unique_lock_t lock(global_lock); - *pSampler = (VkSampler)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroySampler( - VkDevice device, - VkSampler sampler, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorSetLayout( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorSetLayout* pSetLayout) -{ - unique_lock_t lock(global_lock); - *pSetLayout = (VkDescriptorSetLayout)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorSetLayout( - VkDevice device, - VkDescriptorSetLayout descriptorSetLayout, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorPool( - VkDevice device, - const VkDescriptorPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorPool* pDescriptorPool) -{ - unique_lock_t lock(global_lock); - *pDescriptorPool = (VkDescriptorPool)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL ResetDescriptorPool( - VkDevice device, - VkDescriptorPool descriptorPool, - VkDescriptorPoolResetFlags flags) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL AllocateDescriptorSets( - VkDevice device, - const VkDescriptorSetAllocateInfo* pAllocateInfo, - VkDescriptorSet* pDescriptorSets) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < pAllocateInfo->descriptorSetCount; ++i) { - pDescriptorSets[i] = (VkDescriptorSet)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL FreeDescriptorSets( - VkDevice device, - VkDescriptorPool descriptorPool, - uint32_t descriptorSetCount, - const VkDescriptorSet* pDescriptorSets) -{ -//Destroy object - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSets( - VkDevice device, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites, - uint32_t descriptorCopyCount, - const VkCopyDescriptorSet* pDescriptorCopies) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateFramebuffer( - VkDevice device, - const VkFramebufferCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkFramebuffer* pFramebuffer) -{ - unique_lock_t lock(global_lock); - *pFramebuffer = (VkFramebuffer)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyFramebuffer( - VkDevice device, - VkFramebuffer framebuffer, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass( - VkDevice device, - const VkRenderPassCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass) -{ - unique_lock_t lock(global_lock); - *pRenderPass = (VkRenderPass)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyRenderPass( - VkDevice device, - VkRenderPass renderPass, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL GetRenderAreaGranularity( - VkDevice device, - VkRenderPass renderPass, - VkExtent2D* pGranularity) -{ - pGranularity->width = 1; - pGranularity->height = 1; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateCommandPool( - VkDevice device, - const VkCommandPoolCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCommandPool* pCommandPool) -{ - unique_lock_t lock(global_lock); - *pCommandPool = (VkCommandPool)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyCommandPool( - VkDevice device, - VkCommandPool commandPool, - const VkAllocationCallbacks* pAllocator) -{ - - // destroy command buffers for this pool - unique_lock_t lock(global_lock); - auto it = command_pool_buffer_map.find(commandPool); - if (it != command_pool_buffer_map.end()) { - for (auto& cb : it->second) { - DestroyDispObjHandle((void*) cb); - } - command_pool_buffer_map.erase(it); - } -} - -static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolResetFlags flags) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL AllocateCommandBuffers( - VkDevice device, - const VkCommandBufferAllocateInfo* pAllocateInfo, - VkCommandBuffer* pCommandBuffers) -{ - - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; ++i) { - pCommandBuffers[i] = (VkCommandBuffer)CreateDispObjHandle(); - command_pool_buffer_map[pAllocateInfo->commandPool].push_back(pCommandBuffers[i]); - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL FreeCommandBuffers( - VkDevice device, - VkCommandPool commandPool, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers) -{ - - unique_lock_t lock(global_lock); - for (auto i = 0u; i < commandBufferCount; ++i) { - if (!pCommandBuffers[i]) { - continue; - } - - for (auto& pair : command_pool_buffer_map) { - auto& cbs = pair.second; - auto it = std::find(cbs.begin(), cbs.end(), pCommandBuffers[i]); - if (it != cbs.end()) { - cbs.erase(it); - } - } - - DestroyDispObjHandle((void*) pCommandBuffers[i]); - } -} - -static VKAPI_ATTR VkResult VKAPI_CALL BeginCommandBuffer( - VkCommandBuffer commandBuffer, - const VkCommandBufferBeginInfo* pBeginInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL EndCommandBuffer( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL ResetCommandBuffer( - VkCommandBuffer commandBuffer, - VkCommandBufferResetFlags flags) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdBindPipeline( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewport( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewport* pViewports) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetScissor( - VkCommandBuffer commandBuffer, - uint32_t firstScissor, - uint32_t scissorCount, - const VkRect2D* pScissors) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineWidth( - VkCommandBuffer commandBuffer, - float lineWidth) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias( - VkCommandBuffer commandBuffer, - float depthBiasConstantFactor, - float depthBiasClamp, - float depthBiasSlopeFactor) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetBlendConstants( - VkCommandBuffer commandBuffer, - const float blendConstants[4]) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBounds( - VkCommandBuffer commandBuffer, - float minDepthBounds, - float maxDepthBounds) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilCompareMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t compareMask) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilWriteMask( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t writeMask) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilReference( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - uint32_t reference) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBindIndexBuffer( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkIndexType indexType) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBindVertexBuffers( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDraw( - VkCommandBuffer commandBuffer, - uint32_t vertexCount, - uint32_t instanceCount, - uint32_t firstVertex, - uint32_t firstInstance) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexed( - VkCommandBuffer commandBuffer, - uint32_t indexCount, - uint32_t instanceCount, - uint32_t firstIndex, - int32_t vertexOffset, - uint32_t firstInstance) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDispatch( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDispatchIndirect( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferCopy* pRegions) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageCopy* pRegions) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage( - VkCommandBuffer commandBuffer, - VkBuffer srcBuffer, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkBufferImageCopy* pRegions) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkBuffer dstBuffer, - uint32_t regionCount, - const VkBufferImageCopy* pRegions) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdUpdateBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize dataSize, - const void* pData) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdFillBuffer( - VkCommandBuffer commandBuffer, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - VkDeviceSize size, - uint32_t data) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdClearColorImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearColorValue* pColor, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdClearDepthStencilImage( - VkCommandBuffer commandBuffer, - VkImage image, - VkImageLayout imageLayout, - const VkClearDepthStencilValue* pDepthStencil, - uint32_t rangeCount, - const VkImageSubresourceRange* pRanges) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdClearAttachments( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkClearAttachment* pAttachments, - uint32_t rectCount, - const VkClearRect* pRects) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage( - VkCommandBuffer commandBuffer, - VkImage srcImage, - VkImageLayout srcImageLayout, - VkImage dstImage, - VkImageLayout dstImageLayout, - uint32_t regionCount, - const VkImageResolve* pRegions) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags stageMask) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndQuery( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdResetQueryPool( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkQueryPool queryPool, - uint32_t query) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdPushConstants( - VkCommandBuffer commandBuffer, - VkPipelineLayout layout, - VkShaderStageFlags stageFlags, - uint32_t offset, - uint32_t size, - const void* pValues) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - VkSubpassContents contents) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass( - VkCommandBuffer commandBuffer, - VkSubpassContents contents) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdExecuteCommands( - VkCommandBuffer commandBuffer, - uint32_t commandBufferCount, - const VkCommandBuffer* pCommandBuffers) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR VkResult VKAPI_CALL EnumerateInstanceVersion( - uint32_t* pApiVersion) -{ - - *pApiVersion = VK_HEADER_VERSION_COMPLETE; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeatures( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMask( - VkCommandBuffer commandBuffer, - uint32_t deviceMask) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroups( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) -{ - return EnumeratePhysicalDeviceGroupsKHR(instance, pPhysicalDeviceGroupCount, pPhysicalDeviceGroupProperties); -} - -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - GetImageMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); -} - -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - GetBufferMemoryRequirements2KHR(device, pInfo, pMemoryRequirements); -} - -static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ - GetImageSparseMemoryRequirements2KHR(device, pInfo, pSparseMemoryRequirementCount, pSparseMemoryRequirements); -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures) -{ - GetPhysicalDeviceFeatures2KHR(physicalDevice, pFeatures); -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties) -{ - GetPhysicalDeviceProperties2KHR(physicalDevice, pProperties); -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties) -{ - GetPhysicalDeviceFormatProperties2KHR(physicalDevice, format, pFormatProperties); -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties) -{ - return GetPhysicalDeviceImageFormatProperties2KHR(physicalDevice, pImageFormatInfo, pImageFormatProperties); -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties) -{ - GetPhysicalDeviceQueueFamilyProperties2KHR(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties) -{ - GetPhysicalDeviceMemoryProperties2KHR(physicalDevice, pMemoryProperties); -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties) -{ - GetPhysicalDeviceSparseImageFormatProperties2KHR(physicalDevice, pFormatInfo, pPropertyCount, pProperties); -} - -static VKAPI_ATTR void VKAPI_CALL TrimCommandPool( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceQueue2( - VkDevice device, - const VkDeviceQueueInfo2* pQueueInfo, - VkQueue* pQueue) -{ - GetDeviceQueue(device, pQueueInfo->queueFamilyIndex, pQueueInfo->queueIndex, pQueue); - // TODO: Add further support for GetDeviceQueue2 features -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversion( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion) -{ - unique_lock_t lock(global_lock); - *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversion( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplate( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) -{ - unique_lock_t lock(global_lock); - *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplate( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplate( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties) -{ - constexpr VkExternalMemoryHandleTypeFlags supported_flags = 0x1FF; - if (pExternalBufferInfo->handleType & supported_flags) { - pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0x7; - pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = supported_flags; - pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = supported_flags; - } else { - pExternalBufferProperties->externalMemoryProperties.externalMemoryFeatures = 0; - pExternalBufferProperties->externalMemoryProperties.exportFromImportedHandleTypes = 0; - // According to spec, handle type is always compatible with itself. Even if export/import - // not supported, it's important to properly implement self-compatibility property since - // application's control flow can rely on this. - pExternalBufferProperties->externalMemoryProperties.compatibleHandleTypes = pExternalBufferInfo->handleType; - } -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFenceProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties) -{ - // Hard-code support for all handle types and features - pExternalFenceProperties->exportFromImportedHandleTypes = 0xF; - pExternalFenceProperties->compatibleHandleTypes = 0xF; - pExternalFenceProperties->externalFenceFeatures = 0x3; -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalSemaphoreProperties( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalSemaphoreInfo* pExternalSemaphoreInfo, - VkExternalSemaphoreProperties* pExternalSemaphoreProperties) -{ - // Hard code support for all handle types and features - pExternalSemaphoreProperties->exportFromImportedHandleTypes = 0x1F; - pExternalSemaphoreProperties->compatibleHandleTypes = 0x1F; - pExternalSemaphoreProperties->externalSemaphoreFeatures = 0x3; -} - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupport( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport) -{ - if (pSupport) { - pSupport->supported = VK_TRUE; - } -} - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCount( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass) -{ - unique_lock_t lock(global_lock); - *pRenderPass = (VkRenderPass)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL ResetQueryPool( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValue( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphores( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphore( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ - VkDeviceAddress address = 0; - auto d_iter = buffer_map.find(device); - if (d_iter != buffer_map.end()) { - auto iter = d_iter->second.find(pInfo->buffer); - if (iter != d_iter->second.end()) { - address = iter->second.address; - } - } - return address; -} - -static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddress( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddress( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolProperties( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolProperties* pToolProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlot( - VkDevice device, - const VkPrivateDataSlotCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlot* pPrivateDataSlot) -{ - unique_lock_t lock(global_lock); - *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlot( - VkDevice device, - VkPrivateDataSlot privateDataSlot, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateData( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t data) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetPrivateData( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t* pData) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2( - VkCommandBuffer commandBuffer, - const VkDependencyInfo* pDependencyInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkQueryPool queryPool, - uint32_t query) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2* pSubmits, - VkFence fence) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2* pCopyBufferInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2* pCopyImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2* pBlitImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2* pResolveImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRendering( - VkCommandBuffer commandBuffer, - const VkRenderingInfo* pRenderingInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndRendering( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCullMode( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFace( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopology( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCount( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCount( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOp( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnable( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOp( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnable( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnable( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnable( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirements( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - // TODO: Just hard-coding reqs for now - pMemoryRequirements->memoryRequirements.alignment = 1; - pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; - - // Return a size based on the buffer size from the create info. - pMemoryRequirements->memoryRequirements.size = ((pInfo->pCreateInfo->size + 4095) / 4096) * 4096; -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - pMemoryRequirements->memoryRequirements.size = GetImageSizeFromCreateInfo(pInfo->pCreateInfo); - pMemoryRequirements->memoryRequirements.alignment = 1; - // Here we hard-code that the memory type at index 3 doesn't support this image. - pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF & ~(0x1 << 3); -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirements( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR void VKAPI_CALL DestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported) -{ - // Currently say that all surface/queue combos are supported - *pSupported = VK_TRUE; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) -{ - // In general just say max supported is available for requested surface - pSurfaceCapabilities->minImageCount = 1; - pSurfaceCapabilities->maxImageCount = 0; - pSurfaceCapabilities->currentExtent.width = 0xFFFFFFFF; - pSurfaceCapabilities->currentExtent.height = 0xFFFFFFFF; - pSurfaceCapabilities->minImageExtent.width = 1; - pSurfaceCapabilities->minImageExtent.height = 1; - pSurfaceCapabilities->maxImageExtent.width = 0xFFFF; - pSurfaceCapabilities->maxImageExtent.height = 0xFFFF; - pSurfaceCapabilities->maxImageArrayLayers = 128; - pSurfaceCapabilities->supportedTransforms = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_90_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_180_BIT_KHR | - VK_SURFACE_TRANSFORM_ROTATE_270_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_90_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_180_BIT_KHR | - VK_SURFACE_TRANSFORM_HORIZONTAL_MIRROR_ROTATE_270_BIT_KHR | - VK_SURFACE_TRANSFORM_INHERIT_BIT_KHR; - pSurfaceCapabilities->currentTransform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; - pSurfaceCapabilities->supportedCompositeAlpha = VK_COMPOSITE_ALPHA_OPAQUE_BIT_KHR | - VK_COMPOSITE_ALPHA_PRE_MULTIPLIED_BIT_KHR | - VK_COMPOSITE_ALPHA_POST_MULTIPLIED_BIT_KHR | - VK_COMPOSITE_ALPHA_INHERIT_BIT_KHR; - pSurfaceCapabilities->supportedUsageFlags = VK_IMAGE_USAGE_TRANSFER_SRC_BIT | - VK_IMAGE_USAGE_TRANSFER_DST_BIT | - VK_IMAGE_USAGE_SAMPLED_BIT | - VK_IMAGE_USAGE_STORAGE_BIT | - VK_IMAGE_USAGE_COLOR_ATTACHMENT_BIT | - VK_IMAGE_USAGE_DEPTH_STENCIL_ATTACHMENT_BIT | - VK_IMAGE_USAGE_TRANSIENT_ATTACHMENT_BIT | - VK_IMAGE_USAGE_INPUT_ATTACHMENT_BIT; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats) -{ - // Currently always say that RGBA8 & BGRA8 are supported - if (!pSurfaceFormats) { - *pSurfaceFormatCount = 2; - } else { - if (*pSurfaceFormatCount >= 2) { - pSurfaceFormats[1].format = VK_FORMAT_R8G8B8A8_UNORM; - pSurfaceFormats[1].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; - } - if (*pSurfaceFormatCount >= 1) { - pSurfaceFormats[0].format = VK_FORMAT_B8G8R8A8_UNORM; - pSurfaceFormats[0].colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; - } - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes) -{ - // Currently always say that all present modes are supported - if (!pPresentModes) { - *pPresentModeCount = 6; - } else { - if (*pPresentModeCount >= 6) pPresentModes[5] = VK_PRESENT_MODE_SHARED_CONTINUOUS_REFRESH_KHR; - if (*pPresentModeCount >= 5) pPresentModes[4] = VK_PRESENT_MODE_SHARED_DEMAND_REFRESH_KHR; - if (*pPresentModeCount >= 4) pPresentModes[3] = VK_PRESENT_MODE_FIFO_RELAXED_KHR; - if (*pPresentModeCount >= 3) pPresentModes[2] = VK_PRESENT_MODE_FIFO_KHR; - if (*pPresentModeCount >= 2) pPresentModes[1] = VK_PRESENT_MODE_MAILBOX_KHR; - if (*pPresentModeCount >= 1) pPresentModes[0] = VK_PRESENT_MODE_IMMEDIATE_KHR; - } - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSwapchainKHR( - VkDevice device, - const VkSwapchainCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchain) -{ - unique_lock_t lock(global_lock); - *pSwapchain = (VkSwapchainKHR)global_unique_handle++; - for(uint32_t i = 0; i < icd_swapchain_image_count; ++i){ - swapchain_image_map[*pSwapchain][i] = (VkImage)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroySwapchainKHR( - VkDevice device, - VkSwapchainKHR swapchain, - const VkAllocationCallbacks* pAllocator) -{ - unique_lock_t lock(global_lock); - swapchain_image_map.clear(); -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainImagesKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pSwapchainImageCount, - VkImage* pSwapchainImages) -{ - if (!pSwapchainImages) { - *pSwapchainImageCount = icd_swapchain_image_count; - } else { - unique_lock_t lock(global_lock); - for (uint32_t img_i = 0; img_i < (std::min)(*pSwapchainImageCount, icd_swapchain_image_count); ++img_i){ - pSwapchainImages[img_i] = swapchain_image_map.at(swapchain)[img_i]; - } - - if (*pSwapchainImageCount < icd_swapchain_image_count) return VK_INCOMPLETE; - else if (*pSwapchainImageCount > icd_swapchain_image_count) *pSwapchainImageCount = icd_swapchain_image_count; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImageKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t timeout, - VkSemaphore semaphore, - VkFence fence, - uint32_t* pImageIndex) -{ - *pImageIndex = 0; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL QueuePresentKHR( - VkQueue queue, - const VkPresentInfoKHR* pPresentInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupPresentCapabilitiesKHR( - VkDevice device, - VkDeviceGroupPresentCapabilitiesKHR* pDeviceGroupPresentCapabilities) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireNextImage2KHR( - VkDevice device, - const VkAcquireNextImageInfoKHR* pAcquireInfo, - uint32_t* pImageIndex) -{ - *pImageIndex = 0; - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPropertiesKHR* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlanePropertiesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlanePropertiesKHR* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneSupportedDisplaysKHR( - VkPhysicalDevice physicalDevice, - uint32_t planeIndex, - uint32_t* pDisplayCount, - VkDisplayKHR* pDisplays) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModePropertiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModePropertiesKHR* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayModeKHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - const VkDisplayModeCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDisplayModeKHR* pMode) -{ - unique_lock_t lock(global_lock); - *pMode = (VkDisplayModeKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkDisplayModeKHR mode, - uint32_t planeIndex, - VkDisplayPlaneCapabilitiesKHR* pCapabilities) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDisplayPlaneSurfaceKHR( - VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSharedSwapchainsKHR( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkSwapchainKHR* pSwapchains) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < swapchainCount; ++i) { - pSwapchains[i] = (VkSwapchainKHR)global_unique_handle++; - } - return VK_SUCCESS; -} - -#ifdef VK_USE_PLATFORM_XLIB_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL CreateXlibSurfaceKHR( - VkInstance instance, - const VkXlibSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXlibPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - Display* dpy, - VisualID visualID) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceXcbPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - xcb_connection_t* connection, - xcb_visualid_t visual_id) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWaylandPresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct wl_display* display) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceWin32PresentationSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - const VkVideoProfileInfoKHR* pVideoProfile, - VkVideoCapabilitiesKHR* pCapabilities) -{ - // arbitrary - auto *decode_caps = lvl_find_mod_in_chain(pCapabilities->pNext); - if (decode_caps) { - decode_caps->flags = VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_COINCIDE_BIT_KHR | VK_VIDEO_DECODE_CAPABILITY_DPB_AND_OUTPUT_DISTINCT_BIT_KHR; - } - pCapabilities->flags = 0; - pCapabilities->minBitstreamBufferOffsetAlignment = 4; - pCapabilities->minBitstreamBufferSizeAlignment = 4; - pCapabilities->pictureAccessGranularity = {1, 1}; - pCapabilities->minCodedExtent = {4, 4}; - pCapabilities->maxCodedExtent = {16, 16}; - pCapabilities->maxDpbSlots = 4; - pCapabilities->maxActiveReferencePictures = 4; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoFormatPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoFormatInfoKHR* pVideoFormatInfo, - uint32_t* pVideoFormatPropertyCount, - VkVideoFormatPropertiesKHR* pVideoFormatProperties) -{ - if (!pVideoFormatProperties) { - *pVideoFormatPropertyCount = 2; - } else { - // arbitrary - pVideoFormatProperties[0].format = VK_FORMAT_R8G8B8A8_UNORM; - pVideoFormatProperties[0].imageCreateFlags = VK_IMAGE_TYPE_2D; - pVideoFormatProperties[0].imageType = VK_IMAGE_TYPE_2D; - pVideoFormatProperties[0].imageTiling = VK_IMAGE_TILING_OPTIMAL; - pVideoFormatProperties[0].imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; - pVideoFormatProperties[1].format = VK_FORMAT_R8G8B8A8_SNORM; - pVideoFormatProperties[1].imageCreateFlags = VK_IMAGE_TYPE_2D; - pVideoFormatProperties[1].imageType = VK_IMAGE_TYPE_2D; - pVideoFormatProperties[1].imageTiling = VK_IMAGE_TILING_OPTIMAL; - pVideoFormatProperties[1].imageUsageFlags = VK_IMAGE_USAGE_VIDEO_DECODE_DST_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_SRC_BIT_KHR | VK_IMAGE_USAGE_VIDEO_DECODE_DPB_BIT_KHR; - - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionKHR( - VkDevice device, - const VkVideoSessionCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkVideoSessionKHR* pVideoSession) -{ - unique_lock_t lock(global_lock); - *pVideoSession = (VkVideoSessionKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetVideoSessionMemoryRequirementsKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t* pMemoryRequirementsCount, - VkVideoSessionMemoryRequirementsKHR* pMemoryRequirements) -{ - if (!pMemoryRequirements) { - *pMemoryRequirementsCount = 1; - } else { - // arbitrary - pMemoryRequirements[0].memoryBindIndex = 0; - pMemoryRequirements[0].memoryRequirements.size = 4096; - pMemoryRequirements[0].memoryRequirements.alignment = 1; - pMemoryRequirements[0].memoryRequirements.memoryTypeBits = 0xFFFF; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL BindVideoSessionMemoryKHR( - VkDevice device, - VkVideoSessionKHR videoSession, - uint32_t bindSessionMemoryInfoCount, - const VkBindVideoSessionMemoryInfoKHR* pBindSessionMemoryInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateVideoSessionParametersKHR( - VkDevice device, - const VkVideoSessionParametersCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkVideoSessionParametersKHR* pVideoSessionParameters) -{ - unique_lock_t lock(global_lock); - *pVideoSessionParameters = (VkVideoSessionParametersKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL UpdateVideoSessionParametersKHR( - VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkVideoSessionParametersUpdateInfoKHR* pUpdateInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyVideoSessionParametersKHR( - VkDevice device, - VkVideoSessionParametersKHR videoSessionParameters, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoBeginCodingInfoKHR* pBeginInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoEndCodingInfoKHR* pEndCodingInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdControlVideoCodingKHR( - VkCommandBuffer commandBuffer, - const VkVideoCodingControlInfoKHR* pCodingControlInfo) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR void VKAPI_CALL CmdDecodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoDecodeInfoKHR* pDecodeInfo) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderingKHR( - VkCommandBuffer commandBuffer, - const VkRenderingInfo* pRenderingInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderingKHR( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFeatures2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceFeatures2* pFeatures) -{ - GetPhysicalDeviceFeatures(physicalDevice, &pFeatures->features); - uint32_t num_bools = 0; // Count number of VkBool32s in extension structs - VkBool32* feat_bools = nullptr; - const auto *desc_idx_features = lvl_find_in_chain(pFeatures->pNext); - if (desc_idx_features) { - const auto bool_size = sizeof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT) - offsetof(VkPhysicalDeviceDescriptorIndexingFeaturesEXT, shaderInputAttachmentArrayDynamicIndexing); - num_bools = bool_size/sizeof(VkBool32); - feat_bools = (VkBool32*)&desc_idx_features->shaderInputAttachmentArrayDynamicIndexing; - SetBoolArrayTrue(feat_bools, num_bools); - } - const auto *blendop_features = lvl_find_in_chain(pFeatures->pNext); - if (blendop_features) { - const auto bool_size = sizeof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT) - offsetof(VkPhysicalDeviceBlendOperationAdvancedFeaturesEXT, advancedBlendCoherentOperations); - num_bools = bool_size/sizeof(VkBool32); - feat_bools = (VkBool32*)&blendop_features->advancedBlendCoherentOperations; - SetBoolArrayTrue(feat_bools, num_bools); - } -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceProperties2* pProperties) -{ - // The only value that need to be set are those the Profile layer can't set - // see https://github.com/KhronosGroup/Vulkan-Profiles/issues/352 - // All values set are arbitrary - GetPhysicalDeviceProperties(physicalDevice, &pProperties->properties); - - auto *props_11 = lvl_find_mod_in_chain(pProperties->pNext); - if (props_11) { - props_11->protectedNoFault = VK_FALSE; - } - - auto *props_12 = lvl_find_mod_in_chain(pProperties->pNext); - if (props_12) { - props_12->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; - props_12->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; - } - - auto *props_13 = lvl_find_mod_in_chain(pProperties->pNext); - if (props_13) { - props_13->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; - props_13->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; - props_13->storageTexelBufferOffsetAlignmentBytes = 16; - props_13->uniformTexelBufferOffsetAlignmentBytes = 16; - } - - auto *protected_memory_props = lvl_find_mod_in_chain(pProperties->pNext); - if (protected_memory_props) { - protected_memory_props->protectedNoFault = VK_FALSE; - } - - auto *float_controls_props = lvl_find_mod_in_chain(pProperties->pNext); - if (float_controls_props) { - float_controls_props->denormBehaviorIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; - float_controls_props->roundingModeIndependence = VK_SHADER_FLOAT_CONTROLS_INDEPENDENCE_ALL; - } - - auto *conservative_raster_props = lvl_find_mod_in_chain(pProperties->pNext); - if (conservative_raster_props) { - conservative_raster_props->primitiveOverestimationSize = 0.00195313f; - conservative_raster_props->conservativePointAndLineRasterization = VK_TRUE; - conservative_raster_props->degenerateTrianglesRasterized = VK_TRUE; - conservative_raster_props->degenerateLinesRasterized = VK_TRUE; - } - - auto *rt_pipeline_props = lvl_find_mod_in_chain(pProperties->pNext); - if (rt_pipeline_props) { - rt_pipeline_props->shaderGroupHandleSize = 32; - rt_pipeline_props->shaderGroupBaseAlignment = 64; - rt_pipeline_props->shaderGroupHandleCaptureReplaySize = 32; - } - - auto *rt_pipeline_nv_props = lvl_find_mod_in_chain(pProperties->pNext); - if (rt_pipeline_nv_props) { - rt_pipeline_nv_props->shaderGroupHandleSize = 32; - rt_pipeline_nv_props->shaderGroupBaseAlignment = 64; - } - - auto *texel_buffer_props = lvl_find_mod_in_chain(pProperties->pNext); - if (texel_buffer_props) { - texel_buffer_props->storageTexelBufferOffsetSingleTexelAlignment = VK_TRUE; - texel_buffer_props->uniformTexelBufferOffsetSingleTexelAlignment = VK_TRUE; - texel_buffer_props->storageTexelBufferOffsetAlignmentBytes = 16; - texel_buffer_props->uniformTexelBufferOffsetAlignmentBytes = 16; - } - - auto *descriptor_buffer_props = lvl_find_mod_in_chain(pProperties->pNext); - if (descriptor_buffer_props) { - descriptor_buffer_props->combinedImageSamplerDescriptorSingleArray = VK_TRUE; - descriptor_buffer_props->bufferlessPushDescriptors = VK_TRUE; - descriptor_buffer_props->allowSamplerImageViewPostSubmitCreation = VK_TRUE; - descriptor_buffer_props->descriptorBufferOffsetAlignment = 4; - } - - auto *mesh_shader_props = lvl_find_mod_in_chain(pProperties->pNext); - if (mesh_shader_props) { - mesh_shader_props->meshOutputPerVertexGranularity = 32; - mesh_shader_props->meshOutputPerPrimitiveGranularity = 32; - mesh_shader_props->prefersLocalInvocationVertexOutput = VK_TRUE; - mesh_shader_props->prefersLocalInvocationPrimitiveOutput = VK_TRUE; - mesh_shader_props->prefersCompactVertexOutput = VK_TRUE; - mesh_shader_props->prefersCompactPrimitiveOutput = VK_TRUE; - } - - auto *fragment_density_map2_props = lvl_find_mod_in_chain(pProperties->pNext); - if (fragment_density_map2_props) { - fragment_density_map2_props->subsampledLoads = VK_FALSE; - fragment_density_map2_props->subsampledCoarseReconstructionEarlyAccess = VK_FALSE; - fragment_density_map2_props->maxSubsampledArrayLayers = 2; - fragment_density_map2_props->maxDescriptorSetSubsampledSamplers = 1; - } -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - VkFormat format, - VkFormatProperties2* pFormatProperties) -{ - GetPhysicalDeviceFormatProperties(physicalDevice, format, &pFormatProperties->formatProperties); - VkFormatProperties3KHR *props_3 = lvl_find_mod_in_chain(pFormatProperties->pNext); - if (props_3) { - props_3->linearTilingFeatures = pFormatProperties->formatProperties.linearTilingFeatures; - props_3->optimalTilingFeatures = pFormatProperties->formatProperties.optimalTilingFeatures; - props_3->bufferFeatures = pFormatProperties->formatProperties.bufferFeatures; - } -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceImageFormatInfo2* pImageFormatInfo, - VkImageFormatProperties2* pImageFormatProperties) -{ - GetPhysicalDeviceImageFormatProperties(physicalDevice, pImageFormatInfo->format, pImageFormatInfo->type, pImageFormatInfo->tiling, pImageFormatInfo->usage, pImageFormatInfo->flags, &pImageFormatProperties->imageFormatProperties); - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pQueueFamilyPropertyCount, - VkQueueFamilyProperties2* pQueueFamilyProperties) -{ - if (pQueueFamilyPropertyCount && pQueueFamilyProperties) { - GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, &pQueueFamilyProperties->queueFamilyProperties); - } else { - GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, nullptr); - } -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMemoryProperties2KHR( - VkPhysicalDevice physicalDevice, - VkPhysicalDeviceMemoryProperties2* pMemoryProperties) -{ - GetPhysicalDeviceMemoryProperties(physicalDevice, &pMemoryProperties->memoryProperties); -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceSparseImageFormatProperties2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSparseImageFormatInfo2* pFormatInfo, - uint32_t* pPropertyCount, - VkSparseImageFormatProperties2* pProperties) -{ - if (pPropertyCount && pProperties) { - GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, &pProperties->properties); - } else { - GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, pFormatInfo->format, pFormatInfo->type, pFormatInfo->samples, pFormatInfo->usage, pFormatInfo->tiling, pPropertyCount, nullptr); - } -} - - -static VKAPI_ATTR void VKAPI_CALL GetDeviceGroupPeerMemoryFeaturesKHR( - VkDevice device, - uint32_t heapIndex, - uint32_t localDeviceIndex, - uint32_t remoteDeviceIndex, - VkPeerMemoryFeatureFlags* pPeerMemoryFeatures) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDeviceMaskKHR( - VkCommandBuffer commandBuffer, - uint32_t deviceMask) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL TrimCommandPoolKHR( - VkDevice device, - VkCommandPool commandPool, - VkCommandPoolTrimFlags flags) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceGroupsKHR( - VkInstance instance, - uint32_t* pPhysicalDeviceGroupCount, - VkPhysicalDeviceGroupProperties* pPhysicalDeviceGroupProperties) -{ - if (!pPhysicalDeviceGroupProperties) { - *pPhysicalDeviceGroupCount = 1; - } else { - // arbitrary - pPhysicalDeviceGroupProperties->physicalDeviceCount = 1; - pPhysicalDeviceGroupProperties->physicalDevices[0] = physical_device_map.at(instance)[0]; - pPhysicalDeviceGroupProperties->subsetAllocation = VK_FALSE; - } - return VK_SUCCESS; -} - - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalBufferPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalBufferInfo* pExternalBufferInfo, - VkExternalBufferProperties* pExternalBufferProperties) -{ - GetPhysicalDeviceExternalBufferProperties(physicalDevice, pExternalBufferInfo, pExternalBufferProperties); -} - - -#ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleKHR( - VkDevice device, - const VkMemoryGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandlePropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - HANDLE handle, - VkMemoryWin32HandlePropertiesKHR* pMemoryWin32HandleProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdKHR( - VkDevice device, - const VkMemoryGetFdInfoKHR* pGetFdInfo, - int* pFd) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryFdPropertiesKHR( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - int fd, - VkMemoryFdPropertiesKHR* pMemoryFdProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -#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) -{ - GetPhysicalDeviceExternalSemaphoreProperties(physicalDevice, pExternalSemaphoreInfo, pExternalSemaphoreProperties); -} - - -#ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreWin32HandleKHR( - VkDevice device, - const VkImportSemaphoreWin32HandleInfoKHR* pImportSemaphoreWin32HandleInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreWin32HandleKHR( - VkDevice device, - const VkSemaphoreGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - - -static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreFdKHR( - VkDevice device, - const VkImportSemaphoreFdInfoKHR* pImportSemaphoreFdInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreFdKHR( - VkDevice device, - const VkSemaphoreGetFdInfoKHR* pGetFdInfo, - int* pFd) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetKHR( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set, - uint32_t descriptorWriteCount, - const VkWriteDescriptorSet* pDescriptorWrites) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdPushDescriptorSetWithTemplateKHR( - VkCommandBuffer commandBuffer, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - VkPipelineLayout layout, - uint32_t set, - const void* pData) -{ -//Not a CREATE or DESTROY function -} - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDescriptorUpdateTemplateKHR( - VkDevice device, - const VkDescriptorUpdateTemplateCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDescriptorUpdateTemplate* pDescriptorUpdateTemplate) -{ - unique_lock_t lock(global_lock); - *pDescriptorUpdateTemplate = (VkDescriptorUpdateTemplate)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDescriptorUpdateTemplateKHR( - VkDevice device, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL UpdateDescriptorSetWithTemplateKHR( - VkDevice device, - VkDescriptorSet descriptorSet, - VkDescriptorUpdateTemplate descriptorUpdateTemplate, - const void* pData) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRenderPass2KHR( - VkDevice device, - const VkRenderPassCreateInfo2* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkRenderPass* pRenderPass) -{ - unique_lock_t lock(global_lock); - *pRenderPass = (VkRenderPass)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkRenderPassBeginInfo* pRenderPassBegin, - const VkSubpassBeginInfo* pSubpassBeginInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassBeginInfo* pSubpassBeginInfo, - const VkSubpassEndInfo* pSubpassEndInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR( - VkCommandBuffer commandBuffer, - const VkSubpassEndInfo* pSubpassEndInfo) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainStatusKHR( - VkDevice device, - VkSwapchainKHR swapchain) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceExternalFencePropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceExternalFenceInfo* pExternalFenceInfo, - VkExternalFenceProperties* pExternalFenceProperties) -{ - GetPhysicalDeviceExternalFenceProperties(physicalDevice, pExternalFenceInfo, pExternalFenceProperties); -} - - -#ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceWin32HandleKHR( - VkDevice device, - const VkImportFenceWin32HandleInfoKHR* pImportFenceWin32HandleInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceWin32HandleKHR( - VkDevice device, - const VkFenceGetWin32HandleInfoKHR* pGetWin32HandleInfo, - HANDLE* pHandle) -{ - *pHandle = (HANDLE)0x12345678; - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - - -static VKAPI_ATTR VkResult VKAPI_CALL ImportFenceFdKHR( - VkDevice device, - const VkImportFenceFdInfoKHR* pImportFenceFdInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetFenceFdKHR( - VkDevice device, - const VkFenceGetFdInfoKHR* pGetFdInfo, - int* pFd) -{ - *pFd = 0x42; - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL EnumeratePhysicalDeviceQueueFamilyPerformanceQueryCountersKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - uint32_t* pCounterCount, - VkPerformanceCounterKHR* pCounters, - VkPerformanceCounterDescriptionKHR* pCounterDescriptions) -{ - if (!pCounters) { - *pCounterCount = 3; - } else { - if (*pCounterCount == 0){ - return VK_INCOMPLETE; - } - // arbitrary - pCounters[0].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; - pCounters[0].scope = VK_QUERY_SCOPE_COMMAND_BUFFER_KHR; - pCounters[0].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; - pCounters[0].uuid[0] = 0x01; - if (*pCounterCount == 1){ - return VK_INCOMPLETE; - } - pCounters[1].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; - pCounters[1].scope = VK_QUERY_SCOPE_RENDER_PASS_KHR; - pCounters[1].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; - pCounters[1].uuid[0] = 0x02; - if (*pCounterCount == 2){ - return VK_INCOMPLETE; - } - pCounters[2].unit = VK_PERFORMANCE_COUNTER_UNIT_GENERIC_KHR; - pCounters[2].scope = VK_QUERY_SCOPE_COMMAND_KHR; - pCounters[2].storage = VK_PERFORMANCE_COUNTER_STORAGE_INT32_KHR; - pCounters[2].uuid[0] = 0x03; - *pCounterCount = 3; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceQueueFamilyPerformanceQueryPassesKHR( - VkPhysicalDevice physicalDevice, - const VkQueryPoolPerformanceCreateInfoKHR* pPerformanceQueryCreateInfo, - uint32_t* pNumPasses) -{ - if (pNumPasses) { - // arbitrary - *pNumPasses = 1; - } -} - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireProfilingLockKHR( - VkDevice device, - const VkAcquireProfilingLockInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL ReleaseProfilingLockKHR( - VkDevice device) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkSurfaceCapabilities2KHR* pSurfaceCapabilities) -{ - GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, pSurfaceInfo->surface, &pSurfaceCapabilities->surfaceCapabilities); - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceFormats2KHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormat2KHR* pSurfaceFormats) -{ - // Currently always say that RGBA8 & BGRA8 are supported - if (!pSurfaceFormats) { - *pSurfaceFormatCount = 2; - } else { - if (*pSurfaceFormatCount >= 2) { - pSurfaceFormats[1].pNext = nullptr; - pSurfaceFormats[1].surfaceFormat.format = VK_FORMAT_R8G8B8A8_UNORM; - pSurfaceFormats[1].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; - } - if (*pSurfaceFormatCount >= 1) { - pSurfaceFormats[1].pNext = nullptr; - pSurfaceFormats[0].surfaceFormat.format = VK_FORMAT_B8G8R8A8_UNORM; - pSurfaceFormats[0].surfaceFormat.colorSpace = VK_COLOR_SPACE_SRGB_NONLINEAR_KHR; - } - } - return VK_SUCCESS; -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayProperties2KHR* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceDisplayPlaneProperties2KHR( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkDisplayPlaneProperties2KHR* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayModeProperties2KHR( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display, - uint32_t* pPropertyCount, - VkDisplayModeProperties2KHR* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDisplayPlaneCapabilities2KHR( - VkPhysicalDevice physicalDevice, - const VkDisplayPlaneInfo2KHR* pDisplayPlaneInfo, - VkDisplayPlaneCapabilities2KHR* pCapabilities) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - - -static VKAPI_ATTR void VKAPI_CALL GetImageMemoryRequirements2KHR( - VkDevice device, - const VkImageMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - GetImageMemoryRequirements(device, pInfo->image, &pMemoryRequirements->memoryRequirements); -} - -static VKAPI_ATTR void VKAPI_CALL GetBufferMemoryRequirements2KHR( - VkDevice device, - const VkBufferMemoryRequirementsInfo2* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - GetBufferMemoryRequirements(device, pInfo->buffer, &pMemoryRequirements->memoryRequirements); -} - -static VKAPI_ATTR void VKAPI_CALL GetImageSparseMemoryRequirements2KHR( - VkDevice device, - const VkImageSparseMemoryRequirementsInfo2* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ - if (pSparseMemoryRequirementCount && pSparseMemoryRequirements) { - GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, &pSparseMemoryRequirements->memoryRequirements); - } else { - GetImageSparseMemoryRequirements(device, pInfo->image, pSparseMemoryRequirementCount, nullptr); - } -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateSamplerYcbcrConversionKHR( - VkDevice device, - const VkSamplerYcbcrConversionCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSamplerYcbcrConversion* pYcbcrConversion) -{ - unique_lock_t lock(global_lock); - *pYcbcrConversion = (VkSamplerYcbcrConversion)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroySamplerYcbcrConversionKHR( - VkDevice device, - VkSamplerYcbcrConversion ycbcrConversion, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - - -static VKAPI_ATTR VkResult VKAPI_CALL BindBufferMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindBufferMemoryInfo* pBindInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL BindImageMemory2KHR( - VkDevice device, - uint32_t bindInfoCount, - const VkBindImageMemoryInfo* pBindInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -#ifdef VK_ENABLE_BETA_EXTENSIONS -#endif /* VK_ENABLE_BETA_EXTENSIONS */ - - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSupportKHR( - VkDevice device, - const VkDescriptorSetLayoutCreateInfo* pCreateInfo, - VkDescriptorSetLayoutSupport* pSupport) -{ - GetDescriptorSetLayoutSupport(device, pCreateInfo, pSupport); -} - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountKHR( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - - - - - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreCounterValueKHR( - VkDevice device, - VkSemaphore semaphore, - uint64_t* pValue) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL WaitSemaphoresKHR( - VkDevice device, - const VkSemaphoreWaitInfo* pWaitInfo, - uint64_t timeout) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR( - VkDevice device, - const VkSemaphoreSignalInfo* pSignalInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceFragmentShadingRatesKHR( - VkPhysicalDevice physicalDevice, - uint32_t* pFragmentShadingRateCount, - VkPhysicalDeviceFragmentShadingRateKHR* pFragmentShadingRates) -{ - if (!pFragmentShadingRates) { - *pFragmentShadingRateCount = 1; - } else { - // arbitrary - pFragmentShadingRates->sampleCounts = VK_SAMPLE_COUNT_1_BIT | VK_SAMPLE_COUNT_4_BIT; - pFragmentShadingRates->fragmentSize = {8, 8}; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateKHR( - VkCommandBuffer commandBuffer, - const VkExtent2D* pFragmentSize, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) -{ -//Not a CREATE or DESTROY function -} - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL WaitForPresentKHR( - VkDevice device, - VkSwapchainKHR swapchain, - uint64_t presentId, - uint64_t timeout) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ - return GetBufferDeviceAddress(device, pInfo); -} - -static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR( - VkDevice device, - const VkDeviceMemoryOpaqueCaptureAddressInfo* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDeferredOperationKHR( - VkDevice device, - const VkAllocationCallbacks* pAllocator, - VkDeferredOperationKHR* pDeferredOperation) -{ - unique_lock_t lock(global_lock); - *pDeferredOperation = (VkDeferredOperationKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDeferredOperationKHR( - VkDevice device, - VkDeferredOperationKHR operation, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR uint32_t VKAPI_CALL GetDeferredOperationMaxConcurrencyKHR( - VkDevice device, - VkDeferredOperationKHR operation) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeferredOperationResultKHR( - VkDevice device, - VkDeferredOperationKHR operation) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL DeferredOperationJoinKHR( - VkDevice device, - VkDeferredOperationKHR operation) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutablePropertiesKHR( - VkDevice device, - const VkPipelineInfoKHR* pPipelineInfo, - uint32_t* pExecutableCount, - VkPipelineExecutablePropertiesKHR* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableStatisticsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pStatisticCount, - VkPipelineExecutableStatisticKHR* pStatistics) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelineExecutableInternalRepresentationsKHR( - VkDevice device, - const VkPipelineExecutableInfoKHR* pExecutableInfo, - uint32_t* pInternalRepresentationCount, - VkPipelineExecutableInternalRepresentationKHR* pInternalRepresentations) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL MapMemory2KHR( - VkDevice device, - const VkMemoryMapInfoKHR* pMemoryMapInfo, - void** ppData) -{ - return MapMemory(device, pMemoryMapInfo->memory, pMemoryMapInfo->offset, pMemoryMapInfo->size, pMemoryMapInfo->flags, ppData); -} - -static VKAPI_ATTR VkResult VKAPI_CALL UnmapMemory2KHR( - VkDevice device, - const VkMemoryUnmapInfoKHR* pMemoryUnmapInfo) -{ - UnmapMemory(device, pMemoryUnmapInfo->memory); - return VK_SUCCESS; -} - - - - - -#ifdef VK_ENABLE_BETA_EXTENSIONS - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceVideoEncodeQualityLevelPropertiesKHR( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceVideoEncodeQualityLevelInfoKHR* pQualityLevelInfo, - VkVideoEncodeQualityLevelPropertiesKHR* pQualityLevelProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetEncodedVideoSessionParametersKHR( - VkDevice device, - const VkVideoEncodeSessionParametersGetInfoKHR* pVideoSessionParametersInfo, - VkVideoEncodeSessionParametersFeedbackInfoKHR* pFeedbackInfo, - size_t* pDataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdEncodeVideoKHR( - VkCommandBuffer commandBuffer, - const VkVideoEncodeInfoKHR* pEncodeInfo) -{ -//Not a CREATE or DESTROY function -} -#endif /* VK_ENABLE_BETA_EXTENSIONS */ - - -static VKAPI_ATTR void VKAPI_CALL CmdSetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - const VkDependencyInfo* pDependencyInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdResetEvent2KHR( - VkCommandBuffer commandBuffer, - VkEvent event, - VkPipelineStageFlags2 stageMask) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdWaitEvents2KHR( - VkCommandBuffer commandBuffer, - uint32_t eventCount, - const VkEvent* pEvents, - const VkDependencyInfo* pDependencyInfos) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdPipelineBarrier2KHR( - VkCommandBuffer commandBuffer, - const VkDependencyInfo* pDependencyInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteTimestamp2KHR( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkQueryPool queryPool, - uint32_t query) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSubmit2KHR( - VkQueue queue, - uint32_t submitCount, - const VkSubmitInfo2* pSubmits, - VkFence fence) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarker2AMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlags2 stage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointData2NV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointData2NV* pCheckpointData) -{ -//Not a CREATE or DESTROY function -} - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferInfo2* pCopyBufferInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageInfo2* pCopyImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyBufferToImage2KHR( - VkCommandBuffer commandBuffer, - const VkCopyBufferToImageInfo2* pCopyBufferToImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyImageToBuffer2KHR( - VkCommandBuffer commandBuffer, - const VkCopyImageToBufferInfo2* pCopyImageToBufferInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBlitImage2KHR( - VkCommandBuffer commandBuffer, - const VkBlitImageInfo2* pBlitImageInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdResolveImage2KHR( - VkCommandBuffer commandBuffer, - const VkResolveImageInfo2* pResolveImageInfo) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirect2KHR( - VkCommandBuffer commandBuffer, - VkDeviceAddress indirectDeviceAddress) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL GetDeviceBufferMemoryRequirementsKHR( - VkDevice device, - const VkDeviceBufferMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - GetDeviceBufferMemoryRequirements(device, pInfo, pMemoryRequirements); -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ - GetDeviceImageMemoryRequirements(device, pInfo, pMemoryRequirements); -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceImageSparseMemoryRequirementsKHR( - VkDevice device, - const VkDeviceImageMemoryRequirements* pInfo, - uint32_t* pSparseMemoryRequirementCount, - VkSparseImageMemoryRequirements2* pSparseMemoryRequirements) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugReportCallbackEXT( - VkInstance instance, - const VkDebugReportCallbackCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugReportCallbackEXT* pCallback) -{ - unique_lock_t lock(global_lock); - *pCallback = (VkDebugReportCallbackEXT)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDebugReportCallbackEXT( - VkInstance instance, - VkDebugReportCallbackEXT callback, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -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) -{ -//Not a CREATE or DESTROY function -} - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectTagEXT( - VkDevice device, - const VkDebugMarkerObjectTagInfoEXT* pTagInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL DebugMarkerSetObjectNameEXT( - VkDevice device, - const VkDebugMarkerObjectNameInfoEXT* pNameInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerBeginEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerEndEXT( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDebugMarkerInsertEXT( - VkCommandBuffer commandBuffer, - const VkDebugMarkerMarkerInfoEXT* pMarkerInfo) -{ -//Not a CREATE or DESTROY function -} - - - - -static VKAPI_ATTR void VKAPI_CALL CmdBindTransformFeedbackBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t firstBinding, - uint32_t bindingCount, - const VkBuffer* pBuffers, - const VkDeviceSize* pOffsets, - const VkDeviceSize* pSizes) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndTransformFeedbackEXT( - VkCommandBuffer commandBuffer, - uint32_t firstCounterBuffer, - uint32_t counterBufferCount, - const VkBuffer* pCounterBuffers, - const VkDeviceSize* pCounterBufferOffsets) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - VkQueryControlFlags flags, - uint32_t index) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndQueryIndexedEXT( - VkCommandBuffer commandBuffer, - VkQueryPool queryPool, - uint32_t query, - uint32_t index) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateCuModuleNVX( - VkDevice device, - const VkCuModuleCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuModuleNVX* pModule) -{ - unique_lock_t lock(global_lock); - *pModule = (VkCuModuleNVX)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateCuFunctionNVX( - VkDevice device, - const VkCuFunctionCreateInfoNVX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkCuFunctionNVX* pFunction) -{ - unique_lock_t lock(global_lock); - *pFunction = (VkCuFunctionNVX)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyCuModuleNVX( - VkDevice device, - VkCuModuleNVX module, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL DestroyCuFunctionNVX( - VkDevice device, - VkCuFunctionNVX function, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL CmdCuLaunchKernelNVX( - VkCommandBuffer commandBuffer, - const VkCuLaunchInfoNVX* pLaunchInfo) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR uint32_t VKAPI_CALL GetImageViewHandleNVX( - VkDevice device, - const VkImageViewHandleInfoNVX* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewAddressNVX( - VkDevice device, - VkImageView imageView, - VkImageViewAddressPropertiesNVX* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawIndexedIndirectCountAMD( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - - - - -#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) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -#ifdef VK_USE_PLATFORM_GGP - -static VKAPI_ATTR VkResult VKAPI_CALL CreateStreamDescriptorSurfaceGGP( - VkInstance instance, - const VkStreamDescriptorSurfaceCreateInfoGGP* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} -#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) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -#ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryWin32HandleNV( - VkDevice device, - VkDeviceMemory memory, - VkExternalMemoryHandleTypeFlagsNV handleType, - HANDLE* pHandle) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_VI_NN */ - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdBeginConditionalRenderingEXT( - VkCommandBuffer commandBuffer, - const VkConditionalRenderingBeginInfoEXT* pConditionalRenderingBegin) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndConditionalRenderingEXT( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportWScalingNV* pViewportWScalings) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseDisplayEXT( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -#ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireXlibDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - VkDisplayKHR display) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetRandROutputDisplayEXT( - VkPhysicalDevice physicalDevice, - Display* dpy, - RROutput rrOutput, - VkDisplayKHR* pDisplay) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL DisplayPowerControlEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayPowerInfoEXT* pDisplayPowerInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL RegisterDeviceEventEXT( - VkDevice device, - const VkDeviceEventInfoEXT* pDeviceEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL RegisterDisplayEventEXT( - VkDevice device, - VkDisplayKHR display, - const VkDisplayEventInfoEXT* pDisplayEventInfo, - const VkAllocationCallbacks* pAllocator, - VkFence* pFence) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetSwapchainCounterEXT( - VkDevice device, - VkSwapchainKHR swapchain, - VkSurfaceCounterFlagBitsEXT counter, - uint64_t* pCounterValue) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetRefreshCycleDurationGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - VkRefreshCycleDurationGOOGLE* pDisplayTimingProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPastPresentationTimingGOOGLE( - VkDevice device, - VkSwapchainKHR swapchain, - uint32_t* pPresentationTimingCount, - VkPastPresentationTimingGOOGLE* pPresentationTimings) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEXT( - VkCommandBuffer commandBuffer, - uint32_t firstDiscardRectangle, - uint32_t discardRectangleCount, - const VkRect2D* pDiscardRectangles) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 discardRectangleEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDiscardRectangleModeEXT( - VkCommandBuffer commandBuffer, - VkDiscardRectangleModeEXT discardRectangleMode) -{ -//Not a CREATE or DESTROY function -} - - - - - -static VKAPI_ATTR void VKAPI_CALL SetHdrMetadataEXT( - VkDevice device, - uint32_t swapchainCount, - const VkSwapchainKHR* pSwapchains, - const VkHdrMetadataEXT* pMetadata) -{ -//Not a CREATE or DESTROY function -} - -#ifdef VK_USE_PLATFORM_IOS_MVK - -static VKAPI_ATTR VkResult VKAPI_CALL CreateIOSSurfaceMVK( - VkInstance instance, - const VkIOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_MACOS_MVK */ - - - - -static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectNameEXT( - VkDevice device, - const VkDebugUtilsObjectNameInfoEXT* pNameInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL SetDebugUtilsObjectTagEXT( - VkDevice device, - const VkDebugUtilsObjectTagInfoEXT* pTagInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL QueueBeginDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL QueueEndDebugUtilsLabelEXT( - VkQueue queue) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL QueueInsertDebugUtilsLabelEXT( - VkQueue queue, - const VkDebugUtilsLabelEXT* pLabelInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBeginDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdEndDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdInsertDebugUtilsLabelEXT( - VkCommandBuffer commandBuffer, - const VkDebugUtilsLabelEXT* pLabelInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateDebugUtilsMessengerEXT( - VkInstance instance, - const VkDebugUtilsMessengerCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkDebugUtilsMessengerEXT* pMessenger) -{ - unique_lock_t lock(global_lock); - *pMessenger = (VkDebugUtilsMessengerEXT)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyDebugUtilsMessengerEXT( - VkInstance instance, - VkDebugUtilsMessengerEXT messenger, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL SubmitDebugUtilsMessageEXT( - VkInstance instance, - VkDebugUtilsMessageSeverityFlagBitsEXT messageSeverity, - VkDebugUtilsMessageTypeFlagsEXT messageTypes, - const VkDebugUtilsMessengerCallbackDataEXT* pCallbackData) -{ -//Not a CREATE or DESTROY function -} - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL GetAndroidHardwareBufferPropertiesANDROID( - VkDevice device, - const struct AHardwareBuffer* buffer, - VkAndroidHardwareBufferPropertiesANDROID* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryAndroidHardwareBufferANDROID( - VkDevice device, - const VkMemoryGetAndroidHardwareBufferInfoANDROID* pInfo, - struct AHardwareBuffer** pBuffer) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_ANDROID_KHR */ - - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEXT( - VkCommandBuffer commandBuffer, - const VkSampleLocationsInfoEXT* pSampleLocationsInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceMultisamplePropertiesEXT( - VkPhysicalDevice physicalDevice, - VkSampleCountFlagBits samples, - VkMultisamplePropertiesEXT* pMultisampleProperties) -{ - if (pMultisampleProperties) { - // arbitrary - pMultisampleProperties->maxSampleLocationGridSize = {32, 32}; - } -} - - - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageDrmFormatModifierPropertiesEXT( - VkDevice device, - VkImage image, - VkImageDrmFormatModifierPropertiesEXT* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateValidationCacheEXT( - VkDevice device, - const VkValidationCacheCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkValidationCacheEXT* pValidationCache) -{ - unique_lock_t lock(global_lock); - *pValidationCache = (VkValidationCacheEXT)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyValidationCacheEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL MergeValidationCachesEXT( - VkDevice device, - VkValidationCacheEXT dstCache, - uint32_t srcCacheCount, - const VkValidationCacheEXT* pSrcCaches) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetValidationCacheDataEXT( - VkDevice device, - VkValidationCacheEXT validationCache, - size_t* pDataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - -static VKAPI_ATTR void VKAPI_CALL CmdBindShadingRateImageNV( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportShadingRatePaletteNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkShadingRatePaletteNV* pShadingRatePalettes) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoarseSampleOrderNV( - VkCommandBuffer commandBuffer, - VkCoarseSampleOrderTypeNV sampleOrderType, - uint32_t customSampleOrderCount, - const VkCoarseSampleOrderCustomNV* pCustomSampleOrders) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureNV( - VkDevice device, - const VkAccelerationStructureCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureNV* pAccelerationStructure) -{ - unique_lock_t lock(global_lock); - *pAccelerationStructure = (VkAccelerationStructureNV)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureMemoryRequirementsNV( - VkDevice device, - const VkAccelerationStructureMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2KHR* pMemoryRequirements) -{ - // arbitrary - pMemoryRequirements->memoryRequirements.size = 4096; - pMemoryRequirements->memoryRequirements.alignment = 1; - pMemoryRequirements->memoryRequirements.memoryTypeBits = 0xFFFF; -} - -static VKAPI_ATTR VkResult VKAPI_CALL BindAccelerationStructureMemoryNV( - VkDevice device, - uint32_t bindInfoCount, - const VkBindAccelerationStructureMemoryInfoNV* pBindInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureNV( - VkCommandBuffer commandBuffer, - VkAccelerationStructureNV dst, - VkAccelerationStructureNV src, - VkCopyAccelerationStructureModeKHR mode) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesNV( - VkDevice device, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoNV* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - pPipelines[i] = (VkPipeline)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingShaderGroupHandlesNV( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureHandleNV( - VkDevice device, - VkAccelerationStructureNV accelerationStructure, - size_t dataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesNV( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureNV* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CompileDeferredNV( - VkDevice device, - VkPipeline pipeline, - uint32_t shader) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryHostPointerPropertiesEXT( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - const void* pHostPointer, - VkMemoryHostPointerPropertiesEXT* pMemoryHostPointerProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR void VKAPI_CALL CmdWriteBufferMarkerAMD( - VkCommandBuffer commandBuffer, - VkPipelineStageFlagBits pipelineStage, - VkBuffer dstBuffer, - VkDeviceSize dstOffset, - uint32_t marker) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCalibrateableTimeDomainsEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pTimeDomainCount, - VkTimeDomainEXT* pTimeDomains) -{ - if (!pTimeDomains) { - *pTimeDomainCount = 1; - } else { - // arbitrary - *pTimeDomains = VK_TIME_DOMAIN_DEVICE_EXT; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetCalibratedTimestampsEXT( - VkDevice device, - uint32_t timestampCount, - const VkCalibratedTimestampInfoEXT* pTimestampInfos, - uint64_t* pTimestamps, - uint64_t* pMaxDeviation) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - -#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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountNV( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorEnableNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkBool32* pExclusiveScissorEnables) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetExclusiveScissorNV( - VkCommandBuffer commandBuffer, - uint32_t firstExclusiveScissor, - uint32_t exclusiveScissorCount, - const VkRect2D* pExclusiveScissors) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR void VKAPI_CALL CmdSetCheckpointNV( - VkCommandBuffer commandBuffer, - const void* pCheckpointMarker) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetQueueCheckpointDataNV( - VkQueue queue, - uint32_t* pCheckpointDataCount, - VkCheckpointDataNV* pCheckpointData) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL InitializePerformanceApiINTEL( - VkDevice device, - const VkInitializePerformanceApiInfoINTEL* pInitializeInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL UninitializePerformanceApiINTEL( - VkDevice device) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceMarkerInfoINTEL* pMarkerInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceStreamMarkerINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceStreamMarkerInfoINTEL* pMarkerInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CmdSetPerformanceOverrideINTEL( - VkCommandBuffer commandBuffer, - const VkPerformanceOverrideInfoINTEL* pOverrideInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL AcquirePerformanceConfigurationINTEL( - VkDevice device, - const VkPerformanceConfigurationAcquireInfoINTEL* pAcquireInfo, - VkPerformanceConfigurationINTEL* pConfiguration) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL ReleasePerformanceConfigurationINTEL( - VkDevice device, - VkPerformanceConfigurationINTEL configuration) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL QueueSetPerformanceConfigurationINTEL( - VkQueue queue, - VkPerformanceConfigurationINTEL configuration) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetPerformanceParameterINTEL( - VkDevice device, - VkPerformanceParameterTypeINTEL parameter, - VkPerformanceValueINTEL* pValue) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - -static VKAPI_ATTR void VKAPI_CALL SetLocalDimmingAMD( - VkDevice device, - VkSwapchainKHR swapChain, - VkBool32 localDimmingEnable) -{ -//Not a CREATE or DESTROY function -} - -#ifdef VK_USE_PLATFORM_FUCHSIA - -static VKAPI_ATTR VkResult VKAPI_CALL CreateImagePipeSurfaceFUCHSIA( - VkInstance instance, - const VkImagePipeSurfaceCreateInfoFUCHSIA* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_METAL_EXT */ - - - - - - - - - - - - - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressEXT( - VkDevice device, - const VkBufferDeviceAddressInfo* pInfo) -{ - return GetBufferDeviceAddress(device, pInfo); -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT( - VkPhysicalDevice physicalDevice, - uint32_t* pToolCount, - VkPhysicalDeviceToolProperties* pToolProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceCooperativeMatrixPropertiesNV( - VkPhysicalDevice physicalDevice, - uint32_t* pPropertyCount, - VkCooperativeMatrixPropertiesNV* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSupportedFramebufferMixedSamplesCombinationsNV( - VkPhysicalDevice physicalDevice, - uint32_t* pCombinationCount, - VkFramebufferMixedSamplesCombinationNV* pCombinations) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - -#ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceSurfacePresentModes2EXT( - VkPhysicalDevice physicalDevice, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireFullScreenExclusiveModeEXT( - VkDevice device, - VkSwapchainKHR swapchain) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseFullScreenExclusiveModeEXT( - VkDevice device, - VkSwapchainKHR swapchain) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceGroupSurfacePresentModes2EXT( - VkDevice device, - const VkPhysicalDeviceSurfaceInfo2KHR* pSurfaceInfo, - VkDeviceGroupPresentModeFlagsKHR* pModes) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateHeadlessSurfaceEXT( - VkInstance instance, - const VkHeadlessSurfaceCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} - - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEXT( - VkCommandBuffer commandBuffer, - uint32_t lineStippleFactor, - uint16_t lineStipplePattern) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL ResetQueryPoolEXT( - VkDevice device, - VkQueryPool queryPool, - uint32_t firstQuery, - uint32_t queryCount) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetCullModeEXT( - VkCommandBuffer commandBuffer, - VkCullModeFlags cullMode) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetFrontFaceEXT( - VkCommandBuffer commandBuffer, - VkFrontFace frontFace) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveTopologyEXT( - VkCommandBuffer commandBuffer, - VkPrimitiveTopology primitiveTopology) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t viewportCount, - const VkViewport* pViewports) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetScissorWithCountEXT( - VkCommandBuffer commandBuffer, - uint32_t scissorCount, - const VkRect2D* pScissors) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthWriteEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthWriteEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthCompareOpEXT( - VkCommandBuffer commandBuffer, - VkCompareOp depthCompareOp) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBoundsTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBoundsTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilTestEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stencilTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetStencilOpEXT( - VkCommandBuffer commandBuffer, - VkStencilFaceFlags faceMask, - VkStencilOp failOp, - VkStencilOp passOp, - VkStencilOp depthFailOp, - VkCompareOp compareOp) -{ -//Not a CREATE or DESTROY function -} - - - - -static VKAPI_ATTR VkResult VKAPI_CALL ReleaseSwapchainImagesEXT( - VkDevice device, - const VkReleaseSwapchainImagesInfoEXT* pReleaseInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - -static VKAPI_ATTR void VKAPI_CALL GetGeneratedCommandsMemoryRequirementsNV( - VkDevice device, - const VkGeneratedCommandsMemoryRequirementsInfoNV* pInfo, - VkMemoryRequirements2* pMemoryRequirements) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdPreprocessGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdExecuteGeneratedCommandsNV( - VkCommandBuffer commandBuffer, - VkBool32 isPreprocessed, - const VkGeneratedCommandsInfoNV* pGeneratedCommandsInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBindPipelineShaderGroupNV( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipeline pipeline, - uint32_t groupIndex) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNV( - VkDevice device, - const VkIndirectCommandsLayoutCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkIndirectCommandsLayoutNV* pIndirectCommandsLayout) -{ - unique_lock_t lock(global_lock); - *pIndirectCommandsLayout = (VkIndirectCommandsLayoutNV)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNV( - VkDevice device, - VkIndirectCommandsLayoutNV indirectCommandsLayout, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBias2EXT( - VkCommandBuffer commandBuffer, - const VkDepthBiasInfoEXT* pDepthBiasInfo) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - VkDisplayKHR display) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDrmDisplayEXT( - VkPhysicalDevice physicalDevice, - int32_t drmFd, - uint32_t connectorId, - VkDisplayKHR* display) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreatePrivateDataSlotEXT( - VkDevice device, - const VkPrivateDataSlotCreateInfo* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkPrivateDataSlot* pPrivateDataSlot) -{ - unique_lock_t lock(global_lock); - *pPrivateDataSlot = (VkPrivateDataSlot)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyPrivateDataSlotEXT( - VkDevice device, - VkPrivateDataSlot privateDataSlot, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL SetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t data) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL GetPrivateDataEXT( - VkDevice device, - VkObjectType objectType, - uint64_t objectHandle, - VkPrivateDataSlot privateDataSlot, - uint64_t* pData) -{ -//Not a CREATE or DESTROY function -} - - - - - -#ifdef VK_USE_PLATFORM_METAL_EXT - -static VKAPI_ATTR void VKAPI_CALL ExportMetalObjectsEXT( - VkDevice device, - VkExportMetalObjectsInfoEXT* pMetalObjectsInfo) -{ -//Not a CREATE or DESTROY function -} -#endif /* VK_USE_PLATFORM_METAL_EXT */ - - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutSizeEXT( - VkDevice device, - VkDescriptorSetLayout layout, - VkDeviceSize* pLayoutSizeInBytes) -{ - // Need to give something non-zero - *pLayoutSizeInBytes = 4; -} - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutBindingOffsetEXT( - VkDevice device, - VkDescriptorSetLayout layout, - uint32_t binding, - VkDeviceSize* pOffset) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorEXT( - VkDevice device, - const VkDescriptorGetInfoEXT* pDescriptorInfo, - size_t dataSize, - void* pDescriptor) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBuffersEXT( - VkCommandBuffer commandBuffer, - uint32_t bufferCount, - const VkDescriptorBufferBindingInfoEXT* pBindingInfos) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdBindDescriptorBufferEmbeddedSamplersEXT( - VkCommandBuffer commandBuffer, - VkPipelineBindPoint pipelineBindPoint, - VkPipelineLayout layout, - uint32_t set) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetBufferOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkBufferCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkImageCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetImageViewOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkImageViewCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetSamplerOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkSamplerCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetAccelerationStructureOpaqueCaptureDescriptorDataEXT( - VkDevice device, - const VkAccelerationStructureCaptureDescriptorDataInfoEXT* pInfo, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetFragmentShadingRateEnumNV( - VkCommandBuffer commandBuffer, - VkFragmentShadingRateNV shadingRate, - const VkFragmentShadingRateCombinerOpKHR combinerOps[2]) -{ -//Not a CREATE or DESTROY function -} - - - - - - - -static VKAPI_ATTR void VKAPI_CALL GetImageSubresourceLayout2EXT( - VkDevice device, - VkImage image, - const VkImageSubresource2EXT* pSubresource, - VkSubresourceLayout2EXT* pLayout) -{ -//Not a CREATE or DESTROY function -} - - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceFaultInfoEXT( - VkDevice device, - VkDeviceFaultCountsEXT* pFaultCounts, - VkDeviceFaultInfoEXT* pFaultInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - -#ifdef VK_USE_PLATFORM_WIN32_KHR - -static VKAPI_ATTR VkResult VKAPI_CALL AcquireWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - VkDisplayKHR display) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetWinrtDisplayNV( - VkPhysicalDevice physicalDevice, - uint32_t deviceRelativeId, - VkDisplayKHR* pDisplay) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceDirectFBPresentationSupportEXT( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - IDirectFB* dfb) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#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) -{ -//Not a CREATE or DESTROY function -} - - - - - -#ifdef VK_USE_PLATFORM_FUCHSIA - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandleFUCHSIA( - VkDevice device, - const VkMemoryGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, - zx_handle_t* pZirconHandle) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryZirconHandlePropertiesFUCHSIA( - VkDevice device, - VkExternalMemoryHandleTypeFlagBits handleType, - zx_handle_t zirconHandle, - VkMemoryZirconHandlePropertiesFUCHSIA* pMemoryZirconHandleProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_FUCHSIA */ - -#ifdef VK_USE_PLATFORM_FUCHSIA - -static VKAPI_ATTR VkResult VKAPI_CALL ImportSemaphoreZirconHandleFUCHSIA( - VkDevice device, - const VkImportSemaphoreZirconHandleInfoFUCHSIA* pImportSemaphoreZirconHandleInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetSemaphoreZirconHandleFUCHSIA( - VkDevice device, - const VkSemaphoreGetZirconHandleInfoFUCHSIA* pGetZirconHandleInfo, - zx_handle_t* pZirconHandle) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#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) -{ - unique_lock_t lock(global_lock); - *pCollection = (VkBufferCollectionFUCHSIA)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionImageConstraintsFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkImageConstraintsInfoFUCHSIA* pImageConstraintsInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL SetBufferCollectionBufferConstraintsFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkBufferConstraintsInfoFUCHSIA* pBufferConstraintsInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyBufferCollectionFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetBufferCollectionPropertiesFUCHSIA( - VkDevice device, - VkBufferCollectionFUCHSIA collection, - VkBufferCollectionPropertiesFUCHSIA* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_FUCHSIA */ - - -static VKAPI_ATTR VkResult VKAPI_CALL GetDeviceSubpassShadingMaxWorkgroupSizeHUAWEI( - VkDevice device, - VkRenderPass renderpass, - VkExtent2D* pMaxWorkgroupSize) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdSubpassShadingHUAWEI( - VkCommandBuffer commandBuffer) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR void VKAPI_CALL CmdBindInvocationMaskHUAWEI( - VkCommandBuffer commandBuffer, - VkImageView imageView, - VkImageLayout imageLayout) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetMemoryRemoteAddressNV( - VkDevice device, - const VkMemoryGetRemoteAddressInfoNV* pMemoryGetRemoteAddressInfo, - VkRemoteAddressNV* pAddress) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPipelinePropertiesEXT( - VkDevice device, - const VkPipelineInfoEXT* pPipelineInfo, - VkBaseOutStructure* pPipelineProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetPatchControlPointsEXT( - VkCommandBuffer commandBuffer, - uint32_t patchControlPoints) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizerDiscardEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 rasterizerDiscardEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthBiasEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthBiasEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEXT( - VkCommandBuffer commandBuffer, - VkLogicOp logicOp) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetPrimitiveRestartEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 primitiveRestartEnable) -{ -//Not a CREATE or DESTROY function -} - -#ifdef VK_USE_PLATFORM_SCREEN_QNX - -static VKAPI_ATTR VkResult VKAPI_CALL CreateScreenSurfaceQNX( - VkInstance instance, - const VkScreenSurfaceCreateInfoQNX* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - unique_lock_t lock(global_lock); - *pSurface = (VkSurfaceKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR VkBool32 VKAPI_CALL GetPhysicalDeviceScreenPresentationSupportQNX( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - struct _screen_window* window) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_SCREEN_QNX */ - - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t attachmentCount, - const VkBool32* pColorWriteEnables) -{ -//Not a CREATE or DESTROY function -} - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMultiEXT( - VkCommandBuffer commandBuffer, - uint32_t drawCount, - const VkMultiDrawInfoEXT* pVertexInfo, - uint32_t instanceCount, - uint32_t firstInstance, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateMicromapEXT( - VkDevice device, - const VkMicromapCreateInfoEXT* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkMicromapEXT* pMicromap) -{ - unique_lock_t lock(global_lock); - *pMicromap = (VkMicromapEXT)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyMicromapEXT( - VkDevice device, - VkMicromapEXT micromap, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL CmdBuildMicromapsEXT( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkMicromapBuildInfoEXT* pInfos) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL BuildMicromapsEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkMicromapBuildInfoEXT* pInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMicromapToMemoryEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMicromapToMemoryInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToMicromapEXT( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToMicromapInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -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) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapEXT( - VkCommandBuffer commandBuffer, - const VkCopyMicromapInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMicromapToMemoryEXT( - VkCommandBuffer commandBuffer, - const VkCopyMicromapToMemoryInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToMicromapEXT( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToMicromapInfoEXT* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteMicromapsPropertiesEXT( - VkCommandBuffer commandBuffer, - uint32_t micromapCount, - const VkMicromapEXT* pMicromaps, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceMicromapCompatibilityEXT( - VkDevice device, - const VkMicromapVersionInfoEXT* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetMicromapBuildSizesEXT( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkMicromapBuildInfoEXT* pBuildInfo, - VkMicromapBuildSizesInfoEXT* pSizeInfo) -{ -//Not a CREATE or DESTROY function -} - -#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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawClusterIndirectHUAWEI( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL SetDeviceMemoryPriorityEXT( - VkDevice device, - VkDeviceMemory memory, - float priority) -{ -//Not a CREATE or DESTROY function -} - - - - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetLayoutHostMappingInfoVALVE( - VkDevice device, - const VkDescriptorSetBindingReferenceVALVE* pBindingReference, - VkDescriptorSetLayoutHostMappingInfoVALVE* pHostMapping) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetDescriptorSetHostMappingVALVE( - VkDevice device, - VkDescriptorSet descriptorSet, - void** ppData) -{ -//Not a CREATE or DESTROY function -} - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryIndirectNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToImageIndirectNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress copyBufferAddress, - uint32_t copyCount, - uint32_t stride, - VkImage dstImage, - VkImageLayout dstImageLayout, - const VkImageSubresourceLayers* pImageSubresources) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryNV( - VkCommandBuffer commandBuffer, - uint32_t decompressRegionCount, - const VkDecompressMemoryRegionNV* pDecompressMemoryRegions) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDecompressMemoryIndirectCountNV( - VkCommandBuffer commandBuffer, - VkDeviceAddress indirectCommandsAddress, - VkDeviceAddress indirectCommandsCountAddress, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetTessellationDomainOriginEXT( - VkCommandBuffer commandBuffer, - VkTessellationDomainOrigin domainOrigin) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClampEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthClampEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetPolygonModeEXT( - VkCommandBuffer commandBuffer, - VkPolygonMode polygonMode) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationSamplesEXT( - VkCommandBuffer commandBuffer, - VkSampleCountFlagBits rasterizationSamples) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleMaskEXT( - VkCommandBuffer commandBuffer, - VkSampleCountFlagBits samples, - const VkSampleMask* pSampleMask) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToCoverageEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 alphaToCoverageEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetAlphaToOneEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 alphaToOneEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetLogicOpEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 logicOpEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEnableEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkBool32* pColorBlendEnables) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendEquationEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendEquationEXT* pColorBlendEquations) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorWriteMaskEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorComponentFlags* pColorWriteMasks) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetRasterizationStreamEXT( - VkCommandBuffer commandBuffer, - uint32_t rasterizationStream) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetConservativeRasterizationModeEXT( - VkCommandBuffer commandBuffer, - VkConservativeRasterizationModeEXT conservativeRasterizationMode) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetExtraPrimitiveOverestimationSizeEXT( - VkCommandBuffer commandBuffer, - float extraPrimitiveOverestimationSize) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 depthClipEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetSampleLocationsEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 sampleLocationsEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetColorBlendAdvancedEXT( - VkCommandBuffer commandBuffer, - uint32_t firstAttachment, - uint32_t attachmentCount, - const VkColorBlendAdvancedEXT* pColorBlendAdvanced) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetProvokingVertexModeEXT( - VkCommandBuffer commandBuffer, - VkProvokingVertexModeEXT provokingVertexMode) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineRasterizationModeEXT( - VkCommandBuffer commandBuffer, - VkLineRasterizationModeEXT lineRasterizationMode) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetLineStippleEnableEXT( - VkCommandBuffer commandBuffer, - VkBool32 stippledLineEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetDepthClipNegativeOneToOneEXT( - VkCommandBuffer commandBuffer, - VkBool32 negativeOneToOne) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportWScalingEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 viewportWScalingEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetViewportSwizzleNV( - VkCommandBuffer commandBuffer, - uint32_t firstViewport, - uint32_t viewportCount, - const VkViewportSwizzleNV* pViewportSwizzles) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 coverageToColorEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageToColorLocationNV( - VkCommandBuffer commandBuffer, - uint32_t coverageToColorLocation) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationModeNV( - VkCommandBuffer commandBuffer, - VkCoverageModulationModeNV coverageModulationMode) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 coverageModulationTableEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageModulationTableNV( - VkCommandBuffer commandBuffer, - uint32_t coverageModulationTableCount, - const float* pCoverageModulationTable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetShadingRateImageEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 shadingRateImageEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetRepresentativeFragmentTestEnableNV( - VkCommandBuffer commandBuffer, - VkBool32 representativeFragmentTestEnable) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetCoverageReductionModeNV( - VkCommandBuffer commandBuffer, - VkCoverageReductionModeNV coverageReductionMode) -{ -//Not a CREATE or DESTROY function -} - - - - -static VKAPI_ATTR void VKAPI_CALL GetShaderModuleIdentifierEXT( - VkDevice device, - VkShaderModule shaderModule, - VkShaderModuleIdentifierEXT* pIdentifier) -{ - if (pIdentifier) { - // arbitrary - pIdentifier->identifierSize = 1; - pIdentifier->identifier[0] = 0x01; - } -} - -static VKAPI_ATTR void VKAPI_CALL GetShaderModuleCreateInfoIdentifierEXT( - VkDevice device, - const VkShaderModuleCreateInfo* pCreateInfo, - VkShaderModuleIdentifierEXT* pIdentifier) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceOpticalFlowImageFormatsNV( - VkPhysicalDevice physicalDevice, - const VkOpticalFlowImageFormatInfoNV* pOpticalFlowImageFormatInfo, - uint32_t* pFormatCount, - VkOpticalFlowImageFormatPropertiesNV* pImageFormatProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateOpticalFlowSessionNV( - VkDevice device, - const VkOpticalFlowSessionCreateInfoNV* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkOpticalFlowSessionNV* pSession) -{ - unique_lock_t lock(global_lock); - *pSession = (VkOpticalFlowSessionNV)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyOpticalFlowSessionNV( - VkDevice device, - VkOpticalFlowSessionNV session, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL BindOpticalFlowSessionImageNV( - VkDevice device, - VkOpticalFlowSessionNV session, - VkOpticalFlowSessionBindingPointNV bindingPoint, - VkImageView view, - VkImageLayout layout) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdOpticalFlowExecuteNV( - VkCommandBuffer commandBuffer, - VkOpticalFlowSessionNV session, - const VkOpticalFlowExecuteInfoNV* pExecuteInfo) -{ -//Not a CREATE or DESTROY function -} - - - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateShadersEXT( - VkDevice device, - uint32_t createInfoCount, - const VkShaderCreateInfoEXT* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkShaderEXT* pShaders) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - pShaders[i] = (VkShaderEXT)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyShaderEXT( - VkDevice device, - VkShaderEXT shader, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetShaderBinaryDataEXT( - VkDevice device, - VkShaderEXT shader, - size_t* pDataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdBindShadersEXT( - VkCommandBuffer commandBuffer, - uint32_t stageCount, - const VkShaderStageFlagBits* pStages, - const VkShaderEXT* pShaders) -{ -//Not a CREATE or DESTROY function -} - - -static VKAPI_ATTR VkResult VKAPI_CALL GetFramebufferTilePropertiesQCOM( - VkDevice device, - VkFramebuffer framebuffer, - uint32_t* pPropertiesCount, - VkTilePropertiesQCOM* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetDynamicRenderingTilePropertiesQCOM( - VkDevice device, - const VkRenderingInfo* pRenderingInfo, - VkTilePropertiesQCOM* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - - - - - - - - - - -static VKAPI_ATTR void VKAPI_CALL CmdSetAttachmentFeedbackLoopEnableEXT( - VkCommandBuffer commandBuffer, - VkImageAspectFlags aspectMask) -{ -//Not a CREATE or DESTROY function -} - -#ifdef VK_USE_PLATFORM_SCREEN_QNX - -static VKAPI_ATTR VkResult VKAPI_CALL GetScreenBufferPropertiesQNX( - VkDevice device, - const struct _screen_buffer* buffer, - VkScreenBufferPropertiesQNX* pProperties) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} -#endif /* VK_USE_PLATFORM_SCREEN_QNX */ - - -static VKAPI_ATTR VkResult VKAPI_CALL CreateAccelerationStructureKHR( - VkDevice device, - const VkAccelerationStructureCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkAccelerationStructureKHR* pAccelerationStructure) -{ - unique_lock_t lock(global_lock); - *pAccelerationStructure = (VkAccelerationStructureKHR)global_unique_handle++; - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL DestroyAccelerationStructureKHR( - VkDevice device, - VkAccelerationStructureKHR accelerationStructure, - const VkAllocationCallbacks* pAllocator) -{ -//Destroy object -} - -static VKAPI_ATTR void VKAPI_CALL CmdBuildAccelerationStructuresKHR( - VkCommandBuffer commandBuffer, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) -{ -//Not a CREATE or DESTROY function -} - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL BuildAccelerationStructuresKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - uint32_t infoCount, - const VkAccelerationStructureBuildGeometryInfoKHR* pInfos, - const VkAccelerationStructureBuildRangeInfoKHR* const* ppBuildRangeInfos) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyAccelerationStructureToMemoryKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL CopyMemoryToAccelerationStructureKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -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) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyAccelerationStructureToMemoryKHR( - VkCommandBuffer commandBuffer, - const VkCopyAccelerationStructureToMemoryInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdCopyMemoryToAccelerationStructureKHR( - VkCommandBuffer commandBuffer, - const VkCopyMemoryToAccelerationStructureInfoKHR* pInfo) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetAccelerationStructureDeviceAddressKHR( - VkDevice device, - const VkAccelerationStructureDeviceAddressInfoKHR* pInfo) -{ - // arbitrary - need to be aligned to 256 bytes - return 0x262144; -} - -static VKAPI_ATTR void VKAPI_CALL CmdWriteAccelerationStructuresPropertiesKHR( - VkCommandBuffer commandBuffer, - uint32_t accelerationStructureCount, - const VkAccelerationStructureKHR* pAccelerationStructures, - VkQueryType queryType, - VkQueryPool queryPool, - uint32_t firstQuery) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetDeviceAccelerationStructureCompatibilityKHR( - VkDevice device, - const VkAccelerationStructureVersionInfoKHR* pVersionInfo, - VkAccelerationStructureCompatibilityKHR* pCompatibility) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL GetAccelerationStructureBuildSizesKHR( - VkDevice device, - VkAccelerationStructureBuildTypeKHR buildType, - const VkAccelerationStructureBuildGeometryInfoKHR* pBuildInfo, - const uint32_t* pMaxPrimitiveCounts, - VkAccelerationStructureBuildSizesInfoKHR* pSizeInfo) -{ - // arbitrary - pSizeInfo->accelerationStructureSize = 4; - pSizeInfo->updateScratchSize = 4; - pSizeInfo->buildScratchSize = 4; -} - - -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) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkResult VKAPI_CALL CreateRayTracingPipelinesKHR( - VkDevice device, - VkDeferredOperationKHR deferredOperation, - VkPipelineCache pipelineCache, - uint32_t createInfoCount, - const VkRayTracingPipelineCreateInfoKHR* pCreateInfos, - const VkAllocationCallbacks* pAllocator, - VkPipeline* pPipelines) -{ - unique_lock_t lock(global_lock); - for (uint32_t i = 0; i < createInfoCount; ++i) { - pPipelines[i] = (VkPipeline)global_unique_handle++; - } - return VK_SUCCESS; -} - -static VKAPI_ATTR VkResult VKAPI_CALL GetRayTracingCaptureReplayShaderGroupHandlesKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t firstGroup, - uint32_t groupCount, - size_t dataSize, - void* pData) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdTraceRaysIndirectKHR( - VkCommandBuffer commandBuffer, - const VkStridedDeviceAddressRegionKHR* pRaygenShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pMissShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pHitShaderBindingTable, - const VkStridedDeviceAddressRegionKHR* pCallableShaderBindingTable, - VkDeviceAddress indirectDeviceAddress) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR VkDeviceSize VKAPI_CALL GetRayTracingShaderGroupStackSizeKHR( - VkDevice device, - VkPipeline pipeline, - uint32_t group, - VkShaderGroupShaderKHR groupShader) -{ -//Not a CREATE or DESTROY function - return VK_SUCCESS; -} - -static VKAPI_ATTR void VKAPI_CALL CmdSetRayTracingPipelineStackSizeKHR( - VkCommandBuffer commandBuffer, - uint32_t pipelineStackSize) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksEXT( - VkCommandBuffer commandBuffer, - uint32_t groupCountX, - uint32_t groupCountY, - uint32_t groupCountZ) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectEXT( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - uint32_t drawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - -static VKAPI_ATTR void VKAPI_CALL CmdDrawMeshTasksIndirectCountEXT( - VkCommandBuffer commandBuffer, - VkBuffer buffer, - VkDeviceSize offset, - VkBuffer countBuffer, - VkDeviceSize countBufferOffset, - uint32_t maxDrawCount, - uint32_t stride) -{ -//Not a CREATE or DESTROY function -} - - - -static VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL GetPhysicalDeviceProcAddr(VkInstance instance, const char *funcName) { - // TODO: This function should only care about physical device functions and return nullptr for other functions - const auto &item = name_to_funcptr_map.find(funcName); - if (item != name_to_funcptr_map.end()) { - return reinterpret_cast(item->second); - } - // Mock should intercept all functions so if we get here just return null - return nullptr; -} - -} // namespace vkmock - -#if defined(__GNUC__) && __GNUC__ >= 4 -#define EXPORT __attribute__((visibility("default"))) -#elif defined(__SUNPRO_C) && (__SUNPRO_C >= 0x590) -#define EXPORT __attribute__((visibility("default"))) -#else -#define EXPORT -#endif - -extern "C" { - -EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetInstanceProcAddr(VkInstance instance, const char* pName) { - if (!vkmock::negotiate_loader_icd_interface_called) { - vkmock::loader_interface_version = 1; - } - return vkmock::GetInstanceProcAddr(instance, pName); -} - -EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL vk_icdGetPhysicalDeviceProcAddr(VkInstance instance, const char* pName) { - return vkmock::GetPhysicalDeviceProcAddr(instance, pName); -} - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vk_icdNegotiateLoaderICDInterfaceVersion(uint32_t* pSupportedVersion) { - vkmock::negotiate_loader_icd_interface_called = true; - vkmock::loader_interface_version = *pSupportedVersion; - if (*pSupportedVersion > vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION) { - *pSupportedVersion = vkmock::SUPPORTED_LOADER_ICD_INTERFACE_VERSION; - } - return VK_SUCCESS; -} - - -EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySurfaceKHR( - VkInstance instance, - VkSurfaceKHR surface, - const VkAllocationCallbacks* pAllocator) -{ - vkmock::DestroySurfaceKHR(instance, surface, pAllocator); -} - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceSupportKHR( - VkPhysicalDevice physicalDevice, - uint32_t queueFamilyIndex, - VkSurfaceKHR surface, - VkBool32* pSupported) -{ - return vkmock::GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); -} - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilitiesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) -{ - return vkmock::GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); -} - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceFormatsKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pSurfaceFormatCount, - VkSurfaceFormatKHR* pSurfaceFormats) -{ - return vkmock::GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); -} - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfacePresentModesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pPresentModeCount, - VkPresentModeKHR* pPresentModes) -{ - return vkmock::GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); -} - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDisplayPlaneSurfaceKHR( - VkInstance instance, - const VkDisplaySurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateDisplayPlaneSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); -} - -#ifdef VK_USE_PLATFORM_XLIB_KHR - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXlibSurfaceKHR( - VkInstance instance, - const VkXlibSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateXlibSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); -} -#endif /* VK_USE_PLATFORM_XLIB_KHR */ - -#ifdef VK_USE_PLATFORM_XCB_KHR - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateXcbSurfaceKHR( - VkInstance instance, - const VkXcbSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateXcbSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); -} -#endif /* VK_USE_PLATFORM_XCB_KHR */ - -#ifdef VK_USE_PLATFORM_WAYLAND_KHR - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWaylandSurfaceKHR( - VkInstance instance, - const VkWaylandSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateWaylandSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); -} -#endif /* VK_USE_PLATFORM_WAYLAND_KHR */ - -#ifdef VK_USE_PLATFORM_ANDROID_KHR - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateAndroidSurfaceKHR( - VkInstance instance, - const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); -} -#endif /* VK_USE_PLATFORM_ANDROID_KHR */ - -#ifdef VK_USE_PLATFORM_WIN32_KHR - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateWin32SurfaceKHR( - VkInstance instance, - const VkWin32SurfaceCreateInfoKHR* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateWin32SurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); -} -#endif /* VK_USE_PLATFORM_WIN32_KHR */ - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetDeviceGroupSurfacePresentModesKHR( - VkDevice device, - VkSurfaceKHR surface, - VkDeviceGroupPresentModeFlagsKHR* pModes) -{ - return vkmock::GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); -} - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDevicePresentRectanglesKHR( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - uint32_t* pRectCount, - VkRect2D* pRects) -{ - return vkmock::GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); -} - -#ifdef VK_USE_PLATFORM_VI_NN - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateViSurfaceNN( - VkInstance instance, - const VkViSurfaceCreateInfoNN* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateViSurfaceNN(instance, pCreateInfo, pAllocator, pSurface); -} -#endif /* VK_USE_PLATFORM_VI_NN */ - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT( - VkPhysicalDevice physicalDevice, - VkSurfaceKHR surface, - VkSurfaceCapabilities2EXT* pSurfaceCapabilities) -{ - return vkmock::GetPhysicalDeviceSurfaceCapabilities2EXT(physicalDevice, surface, pSurfaceCapabilities); -} - -#ifdef VK_USE_PLATFORM_IOS_MVK - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateIOSSurfaceMVK( - VkInstance instance, - const VkIOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateIOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); -} -#endif /* VK_USE_PLATFORM_IOS_MVK */ - -#ifdef VK_USE_PLATFORM_MACOS_MVK - -EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateMacOSSurfaceMVK( - VkInstance instance, - const VkMacOSSurfaceCreateInfoMVK* pCreateInfo, - const VkAllocationCallbacks* pAllocator, - VkSurfaceKHR* pSurface) -{ - return vkmock::CreateMacOSSurfaceMVK(instance, pCreateInfo, pAllocator, pSurface); -} -#endif /* VK_USE_PLATFORM_MACOS_MVK */ - -} // end extern "C" - - diff --git a/icd/generated/mock_icd.h b/icd/generated/mock_icd.h deleted file mode 100644 index f641c27d..00000000 --- a/icd/generated/mock_icd.h +++ /dev/null @@ -1,5001 +0,0 @@ -#pragma once - -/* -** 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. -** -*/ - -#include -#include -#include -#include -#include "vulkan/vk_icd.h" -namespace vkmock { - - -using mutex_t = std::mutex; -using lock_guard_t = std::lock_guard; -using unique_lock_t = std::unique_lock; - -static mutex_t global_lock; -static uint64_t global_unique_handle = 1; -static const uint32_t SUPPORTED_LOADER_ICD_INTERFACE_VERSION = 5; -static uint32_t loader_interface_version = 0; -static bool negotiate_loader_icd_interface_called = false; -static void* CreateDispObjHandle() { - auto handle = new VK_LOADER_DATA; - set_loader_magic_value(handle); - return handle; -} -static void DestroyDispObjHandle(void* handle) { - delete reinterpret_cast(handle); -} - -// Map of instance extension name to version -static const std::unordered_map 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 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 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 - -- cgit v1.2.3