blob: e5100026ac7db42a0555ace5c63a6f1004e6ed92 [file] [log] [blame]
#ifndef __mock_icd_h_
#define __mock_icd_h_ 1
/*
** Copyright (c) 2015-2018 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 <unordered_map>
#include <mutex>
#include <string>
#include <cstring>
#include "vulkan/vk_icd.h"
namespace vkmock {
using mutex_t = std::mutex;
using lock_guard_t = std::lock_guard<mutex_t>;
using unique_lock_t = std::unique_lock<mutex_t>;
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<VK_LOADER_DATA*>(handle);
}
// Map of instance extension name to version
static const std::unordered_map<std::string, uint32_t> instance_extension_map = {
{"VK_KHR_surface", 25},
{"VK_KHR_display", 23},
{"VK_KHR_xlib_surface", 6},
{"VK_KHR_xcb_surface", 6},
{"VK_KHR_wayland_surface", 6},
{"VK_KHR_android_surface", 6},
{"VK_KHR_win32_surface", 6},
{"VK_EXT_debug_report", 9},
{"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", 2},
{"VK_MVK_macos_surface", 2},
{"VK_EXT_debug_utils", 1},
{"VK_FUCHSIA_imagepipe_surface", 1},
{"VK_EXT_metal_surface", 1},
{"VK_KHR_surface_protected_capabilities", 1},
{"VK_EXT_validation_features", 2},
{"VK_EXT_headless_surface", 1},
};
// Map of device extension name to version
static const std::unordered_map<std::string, uint32_t> device_extension_map = {
{"VK_KHR_swapchain", 70},
{"VK_KHR_display_swapchain", 10},
{"VK_NV_glsl_shader", 1},
{"VK_EXT_depth_range_unrestricted", 1},
{"VK_KHR_sampler_mirror_clamp_to_edge", 3},
{"VK_IMG_filter_cubic", 1},
{"VK_AMD_rasterization_order", 1},
{"VK_AMD_shader_trinary_minmax", 1},
{"VK_AMD_shader_explicit_vertex_parameter", 1},
{"VK_EXT_debug_marker", 4},
{"VK_AMD_gcn_shader", 1},
{"VK_NV_dedicated_allocation", 1},
{"VK_EXT_transform_feedback", 1},
{"VK_NVX_image_view_handle", 1},
{"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_AMD_texture_gather_bias_lod", 1},
{"VK_AMD_shader_info", 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_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", 1},
{"VK_KHR_descriptor_update_template", 1},
{"VK_NVX_device_generated_commands", 3},
{"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", 1},
{"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", 3},
{"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_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", 1},
{"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", 2},
{"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", 1},
{"VK_AMD_shader_core_properties", 2},
{"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", 1},
{"VK_NV_device_diagnostic_checkpoints", 2},
{"VK_KHR_timeline_semaphore", 2},
{"VK_INTEL_shader_integer_functions2", 1},
{"VK_INTEL_performance_query", 1},
{"VK_KHR_vulkan_memory_model", 3},
{"VK_EXT_pci_bus_info", 2},
{"VK_AMD_display_native_hdr", 1},
{"VK_EXT_fragment_density_map", 1},
{"VK_EXT_scalar_block_layout", 1},
{"VK_GOOGLE_hlsl_functionality1", 1},
{"VK_GOOGLE_decorate_string", 1},
{"VK_EXT_subgroup_size_control", 2},
{"VK_AMD_shader_core_properties2", 1},
{"VK_AMD_device_coherent_memory", 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_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_full_screen_exclusive", 4},
{"VK_KHR_buffer_device_address", 1},
{"VK_EXT_line_rasterization", 1},
{"VK_EXT_host_query_reset", 1},
{"VK_EXT_index_type_uint8", 1},
{"VK_KHR_pipeline_executable_properties", 1},
{"VK_EXT_shader_demote_to_helper_invocation", 1},
{"VK_EXT_texel_buffer_alignment", 1},
{"VK_GOOGLE_user_type", 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 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 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 VkRenderPassCreateInfo2KHR* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkRenderPass* pRenderPass);
static VKAPI_ATTR void VKAPI_CALL CmdBeginRenderPass2KHR(
VkCommandBuffer commandBuffer,
const VkRenderPassBeginInfo* pRenderPassBegin,
const VkSubpassBeginInfoKHR* pSubpassBeginInfo);
static VKAPI_ATTR void VKAPI_CALL CmdNextSubpass2KHR(
VkCommandBuffer commandBuffer,
const VkSubpassBeginInfoKHR* pSubpassBeginInfo,
const VkSubpassEndInfoKHR* pSubpassEndInfo);
static VKAPI_ATTR void VKAPI_CALL CmdEndRenderPass2KHR(
VkCommandBuffer commandBuffer,
const VkSubpassEndInfoKHR* 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);
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 VkSemaphoreWaitInfoKHR* pWaitInfo,
uint64_t timeout);
static VKAPI_ATTR VkResult VKAPI_CALL SignalSemaphoreKHR(
VkDevice device,
const VkSemaphoreSignalInfoKHR* pSignalInfo);
static VKAPI_ATTR VkDeviceAddress VKAPI_CALL GetBufferDeviceAddressKHR(
VkDevice device,
const VkBufferDeviceAddressInfoKHR* pInfo);
static VKAPI_ATTR uint64_t VKAPI_CALL GetBufferOpaqueCaptureAddressKHR(
VkDevice device,
const VkBufferDeviceAddressInfoKHR* pInfo);
static VKAPI_ATTR uint64_t VKAPI_CALL GetDeviceMemoryOpaqueCaptureAddressKHR(
VkDevice device,
const VkDeviceMemoryOpaqueCaptureAddressInfoKHR* pInfo);
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 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 uint32_t VKAPI_CALL GetImageViewHandleNVX(
VkDevice device,
const VkImageViewHandleInfoNVX* pInfo);
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);
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 CmdProcessCommandsNVX(
VkCommandBuffer commandBuffer,
const VkCmdProcessCommandsInfoNVX* pProcessCommandsInfo);
static VKAPI_ATTR void VKAPI_CALL CmdReserveSpaceForCommandsNVX(
VkCommandBuffer commandBuffer,
const VkCmdReserveSpaceForCommandsInfoNVX* pReserveSpaceInfo);
static VKAPI_ATTR VkResult VKAPI_CALL CreateIndirectCommandsLayoutNVX(
VkDevice device,
const VkIndirectCommandsLayoutCreateInfoNVX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkIndirectCommandsLayoutNVX* pIndirectCommandsLayout);
static VKAPI_ATTR void VKAPI_CALL DestroyIndirectCommandsLayoutNVX(
VkDevice device,
VkIndirectCommandsLayoutNVX indirectCommandsLayout,
const VkAllocationCallbacks* pAllocator);
static VKAPI_ATTR VkResult VKAPI_CALL CreateObjectTableNVX(
VkDevice device,
const VkObjectTableCreateInfoNVX* pCreateInfo,
const VkAllocationCallbacks* pAllocator,
VkObjectTableNVX* pObjectTable);
static VKAPI_ATTR void VKAPI_CALL DestroyObjectTableNVX(
VkDevice device,
VkObjectTableNVX objectTable,
const VkAllocationCallbacks* pAllocator);
static VKAPI_ATTR VkResult VKAPI_CALL RegisterObjectsNVX(
VkDevice device,
VkObjectTableNVX objectTable,
uint32_t objectCount,
const VkObjectTableEntryNVX* const* ppObjectTableEntries,
const uint32_t* pObjectIndices);
static VKAPI_ATTR VkResult VKAPI_CALL UnregisterObjectsNVX(
VkDevice device,
VkObjectTableNVX objectTable,
uint32_t objectCount,
const VkObjectEntryTypeNVX* pObjectEntryTypes,
const uint32_t* pObjectIndices);
static VKAPI_ATTR void VKAPI_CALL GetPhysicalDeviceGeneratedCommandsPropertiesNVX(
VkPhysicalDevice physicalDevice,
VkDeviceGeneratedCommandsFeaturesNVX* pFeatures,
VkDeviceGeneratedCommandsLimitsNVX* pLimits);
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 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,
VkCopyAccelerationStructureModeNV 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 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 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 VkBufferDeviceAddressInfoKHR* pInfo);
static VKAPI_ATTR VkResult VKAPI_CALL GetPhysicalDeviceToolPropertiesEXT(
VkPhysicalDevice physicalDevice,
uint32_t* pToolCount,
VkPhysicalDeviceToolPropertiesEXT* 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);
// Map of all APIs to be intercepted by this layer
static const std::unordered_map<std::string, void*> name_to_funcptr_map = {
{"vkCreateInstance", (void*)CreateInstance},
{"vkDestroyInstance", (void*)DestroyInstance},
{"vkEnumeratePhysicalDevices", (void*)EnumeratePhysicalDevices},
{"vkGetPhysicalDeviceFeatures", (void*)GetPhysicalDeviceFeatures},
{"vkGetPhysicalDeviceFormatProperties", (void*)GetPhysicalDeviceFormatProperties},
{"vkGetPhysicalDeviceImageFormatProperties", (void*)GetPhysicalDeviceImageFormatProperties},
{"vkGetPhysicalDeviceProperties", (void*)GetPhysicalDeviceProperties},
{"vkGetPhysicalDeviceQueueFamilyProperties", (void*)GetPhysicalDeviceQueueFamilyProperties},
{"vkGetPhysicalDeviceMemoryProperties", (void*)GetPhysicalDeviceMemoryProperties},
{"vkGetInstanceProcAddr", (void*)GetInstanceProcAddr},
{"vkGetDeviceProcAddr", (void*)GetDeviceProcAddr},
{"vkCreateDevice", (void*)CreateDevice},
{"vkDestroyDevice", (void*)DestroyDevice},
{"vkEnumerateInstanceExtensionProperties", (void*)EnumerateInstanceExtensionProperties},
{"vkEnumerateDeviceExtensionProperties", (void*)EnumerateDeviceExtensionProperties},
{"vkEnumerateInstanceLayerProperties", (void*)EnumerateInstanceLayerProperties},
{"vkEnumerateDeviceLayerProperties", (void*)EnumerateDeviceLayerProperties},
{"vkGetDeviceQueue", (void*)GetDeviceQueue},
{"vkQueueSubmit", (void*)QueueSubmit},
{"vkQueueWaitIdle", (void*)QueueWaitIdle},
{"vkDeviceWaitIdle", (void*)DeviceWaitIdle},
{"vkAllocateMemory", (void*)AllocateMemory},
{"vkFreeMemory", (void*)FreeMemory},
{"vkMapMemory", (void*)MapMemory},
{"vkUnmapMemory", (void*)UnmapMemory},
{"vkFlushMappedMemoryRanges", (void*)FlushMappedMemoryRanges},
{"vkInvalidateMappedMemoryRanges", (void*)InvalidateMappedMemoryRanges},
{"vkGetDeviceMemoryCommitment", (void*)GetDeviceMemoryCommitment},
{"vkBindBufferMemory", (void*)BindBufferMemory},
{"vkBindImageMemory", (void*)BindImageMemory},
{"vkGetBufferMemoryRequirements", (void*)GetBufferMemoryRequirements},
{"vkGetImageMemoryRequirements", (void*)GetImageMemoryRequirements},
{"vkGetImageSparseMemoryRequirements", (void*)GetImageSparseMemoryRequirements},
{"vkGetPhysicalDeviceSparseImageFormatProperties", (void*)GetPhysicalDeviceSparseImageFormatProperties},
{"vkQueueBindSparse", (void*)QueueBindSparse},
{"vkCreateFence", (void*)CreateFence},
{"vkDestroyFence", (void*)DestroyFence},
{"vkResetFences", (void*)ResetFences},
{"vkGetFenceStatus", (void*)GetFenceStatus},
{"vkWaitForFences", (void*)WaitForFences},
{"vkCreateSemaphore", (void*)CreateSemaphore},
{"vkDestroySemaphore", (void*)DestroySemaphore},
{"vkCreateEvent", (void*)CreateEvent},
{"vkDestroyEvent", (void*)DestroyEvent},
{"vkGetEventStatus", (void*)GetEventStatus},
{"vkSetEvent", (void*)SetEvent},
{"vkResetEvent", (void*)ResetEvent},
{"vkCreateQueryPool", (void*)CreateQueryPool},
{"vkDestroyQueryPool", (void*)DestroyQueryPool},
{"vkGetQueryPoolResults", (void*)GetQueryPoolResults},
{"vkCreateBuffer", (void*)CreateBuffer},
{"vkDestroyBuffer", (void*)DestroyBuffer},
{"vkCreateBufferView", (void*)CreateBufferView},
{"vkDestroyBufferView", (void*)DestroyBufferView},
{"vkCreateImage", (void*)CreateImage},
{"vkDestroyImage", (void*)DestroyImage},
{"vkGetImageSubresourceLayout", (void*)GetImageSubresourceLayout},
{"vkCreateImageView", (void*)CreateImageView},
{"vkDestroyImageView", (void*)DestroyImageView},
{"vkCreateShaderModule", (void*)CreateShaderModule},
{"vkDestroyShaderModule", (void*)DestroyShaderModule},
{"vkCreatePipelineCache", (void*)CreatePipelineCache},
{"vkDestroyPipelineCache", (void*)DestroyPipelineCache},
{"vkGetPipelineCacheData", (void*)GetPipelineCacheData},
{"vkMergePipelineCaches", (void*)MergePipelineCaches},
{"vkCreateGraphicsPipelines", (void*)CreateGraphicsPipelines},
{"vkCreateComputePipelines", (void*)CreateComputePipelines},
{"vkDestroyPipeline", (void*)DestroyPipeline},
{"vkCreatePipelineLayout", (void*)CreatePipelineLayout},
{"vkDestroyPipelineLayout", (void*)DestroyPipelineLayout},
{"vkCreateSampler", (void*)CreateSampler},
{"vkDestroySampler", (void*)DestroySampler},
{"vkCreateDescriptorSetLayout", (void*)CreateDescriptorSetLayout},
{"vkDestroyDescriptorSetLayout", (void*)DestroyDescriptorSetLayout},
{"vkCreateDescriptorPool", (void*)CreateDescriptorPool},
{"vkDestroyDescriptorPool", (void*)DestroyDescriptorPool},
{"vkResetDescriptorPool", (void*)ResetDescriptorPool},
{"vkAllocateDescriptorSets", (void*)AllocateDescriptorSets},
{"vkFreeDescriptorSets", (void*)FreeDescriptorSets},
{"vkUpdateDescriptorSets", (void*)UpdateDescriptorSets},
{"vkCreateFramebuffer", (void*)CreateFramebuffer},
{"vkDestroyFramebuffer", (void*)DestroyFramebuffer},
{"vkCreateRenderPass", (void*)CreateRenderPass},
{"vkDestroyRenderPass", (void*)DestroyRenderPass},
{"vkGetRenderAreaGranularity", (void*)GetRenderAreaGranularity},
{"vkCreateCommandPool", (void*)CreateCommandPool},
{"vkDestroyCommandPool", (void*)DestroyCommandPool},
{"vkResetCommandPool", (void*)ResetCommandPool},
{"vkAllocateCommandBuffers", (void*)AllocateCommandBuffers},
{"vkFreeCommandBuffers", (void*)FreeCommandBuffers},
{"vkBeginCommandBuffer", (void*)BeginCommandBuffer},
{"vkEndCommandBuffer", (void*)EndCommandBuffer},
{"vkResetCommandBuffer", (void*)ResetCommandBuffer},
{"vkCmdBindPipeline", (void*)CmdBindPipeline},
{"vkCmdSetViewport", (void*)CmdSetViewport},
{"vkCmdSetScissor", (void*)CmdSetScissor},
{"vkCmdSetLineWidth", (void*)CmdSetLineWidth},
{"vkCmdSetDepthBias", (void*)CmdSetDepthBias},
{"vkCmdSetBlendConstants", (void*)CmdSetBlendConstants},
{"vkCmdSetDepthBounds", (void*)CmdSetDepthBounds},
{"vkCmdSetStencilCompareMask", (void*)CmdSetStencilCompareMask},
{"vkCmdSetStencilWriteMask", (void*)CmdSetStencilWriteMask},
{"vkCmdSetStencilReference", (void*)CmdSetStencilReference},
{"vkCmdBindDescriptorSets", (void*)CmdBindDescriptorSets},
{"vkCmdBindIndexBuffer", (void*)CmdBindIndexBuffer},
{"vkCmdBindVertexBuffers", (void*)CmdBindVertexBuffers},
{"vkCmdDraw", (void*)CmdDraw},
{"vkCmdDrawIndexed", (void*)CmdDrawIndexed},
{"vkCmdDrawIndirect", (void*)CmdDrawIndirect},
{"vkCmdDrawIndexedIndirect", (void*)CmdDrawIndexedIndirect},
{"vkCmdDispatch", (void*)CmdDispatch},
{"vkCmdDispatchIndirect", (void*)CmdDispatchIndirect},
{"vkCmdCopyBuffer", (void*)CmdCopyBuffer},
{"vkCmdCopyImage", (void*)CmdCopyImage},
{"vkCmdBlitImage", (void*)CmdBlitImage},
{"vkCmdCopyBufferToImage", (void*)CmdCopyBufferToImage},
{"vkCmdCopyImageToBuffer", (void*)CmdCopyImageToBuffer},
{"vkCmdUpdateBuffer", (void*)CmdUpdateBuffer},
{"vkCmdFillBuffer", (void*)CmdFillBuffer},
{"vkCmdClearColorImage", (void*)CmdClearColorImage},
{"vkCmdClearDepthStencilImage", (void*)CmdClearDepthStencilImage},
{"vkCmdClearAttachments", (void*)CmdClearAttachments},
{"vkCmdResolveImage", (void*)CmdResolveImage},
{"vkCmdSetEvent", (void*)CmdSetEvent},
{"vkCmdResetEvent", (void*)CmdResetEvent},
{"vkCmdWaitEvents", (void*)CmdWaitEvents},
{"vkCmdPipelineBarrier", (void*)CmdPipelineBarrier},
{"vkCmdBeginQuery", (void*)CmdBeginQuery},
{"vkCmdEndQuery", (void*)CmdEndQuery},
{"vkCmdResetQueryPool", (void*)CmdResetQueryPool},
{"vkCmdWriteTimestamp", (void*)CmdWriteTimestamp},
{"vkCmdCopyQueryPoolResults", (void*)CmdCopyQueryPoolResults},
{"vkCmdPushConstants", (void*)CmdPushConstants},
{"vkCmdBeginRenderPass", (void*)CmdBeginRenderPass},
{"vkCmdNextSubpass", (void*)CmdNextSubpass},