1/* 2 * Copyright 2016 The Android Open Source Project 3 * 4 * Licensed under the Apache License, Version 2.0 (the "License"); 5 * you may not use this file except in compliance with the License. 6 * You may obtain a copy of the License at 7 * 8 * http://www.apache.org/licenses/LICENSE-2.0 9 * 10 * Unless required by applicable law or agreed to in writing, software 11 * distributed under the License is distributed on an "AS IS" BASIS, 12 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 13 * See the License for the specific language governing permissions and 14 * limitations under the License. 15 */ 16 17// WARNING: This file is generated. See ../README.md for instructions. 18 19#include <string.h> 20#include <algorithm> 21#include <log/log.h> 22 23// to catch mismatches between vulkan.h and this file 24#undef VK_NO_PROTOTYPES 25#include "api.h" 26 27namespace vulkan { 28namespace api { 29 30#define UNLIKELY(expr) __builtin_expect((expr), 0) 31 32#define INIT_PROC(obj, proc) \ 33 do { \ 34 data.dispatch.proc = \ 35 reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \ 36 if (UNLIKELY(!data.dispatch.proc)) { \ 37 ALOGE("missing " #obj " proc: vk" #proc); \ 38 success = false; \ 39 } \ 40 } while (0) 41 42// Exported extension functions may be invoked even when their extensions 43// are disabled. Dispatch to stubs when that happens. 44#define INIT_PROC_EXT(ext, obj, proc) \ 45 do { \ 46 if (extensions[driver::ProcHook::ext]) \ 47 INIT_PROC(obj, proc); \ 48 else \ 49 data.dispatch.proc = disabled##proc; \ 50 } while (0) 51 52namespace { 53 54// clang-format off 55 56VKAPI_ATTR void disabledDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR, const VkAllocationCallbacks*) { 57 driver::Logger(instance).Err(instance, "VK_KHR_surface not enabled. Exported vkDestroySurfaceKHR not executed."); 58} 59 60VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t, VkSurfaceKHR, VkBool32*) { 61 driver::Logger(physicalDevice).Err(physicalDevice, "VK_KHR_surface not enabled. Exported vkGetPhysicalDeviceSurfaceSupportKHR not executed."); 62 return VK_SUCCESS; 63} 64 65VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR*) { 66 driver::Logger(physicalDevice).Err(physicalDevice, "VK_KHR_surface not enabled. Exported vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed."); 67 return VK_SUCCESS; 68} 69 70VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR, uint32_t*, VkSurfaceFormatKHR*) { 71 driver::Logger(physicalDevice).Err(physicalDevice, "VK_KHR_surface not enabled. Exported vkGetPhysicalDeviceSurfaceFormatsKHR not executed."); 72 return VK_SUCCESS; 73} 74 75VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR, uint32_t*, VkPresentModeKHR*) { 76 driver::Logger(physicalDevice).Err(physicalDevice, "VK_KHR_surface not enabled. Exported vkGetPhysicalDeviceSurfacePresentModesKHR not executed."); 77 return VK_SUCCESS; 78} 79 80VKAPI_ATTR VkResult disabledCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR*, const VkAllocationCallbacks*, VkSwapchainKHR*) { 81 driver::Logger(device).Err(device, "VK_KHR_swapchain not enabled. Exported vkCreateSwapchainKHR not executed."); 82 return VK_SUCCESS; 83} 84 85VKAPI_ATTR void disabledDestroySwapchainKHR(VkDevice device, VkSwapchainKHR, const VkAllocationCallbacks*) { 86 driver::Logger(device).Err(device, "VK_KHR_swapchain not enabled. Exported vkDestroySwapchainKHR not executed."); 87} 88 89VKAPI_ATTR VkResult disabledGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR, uint32_t*, VkImage*) { 90 driver::Logger(device).Err(device, "VK_KHR_swapchain not enabled. Exported vkGetSwapchainImagesKHR not executed."); 91 return VK_SUCCESS; 92} 93 94VKAPI_ATTR VkResult disabledAcquireNextImageKHR(VkDevice device, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, uint32_t*) { 95 driver::Logger(device).Err(device, "VK_KHR_swapchain not enabled. Exported vkAcquireNextImageKHR not executed."); 96 return VK_SUCCESS; 97} 98 99VKAPI_ATTR VkResult disabledQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR*) { 100 driver::Logger(queue).Err(queue, "VK_KHR_swapchain not enabled. Exported vkQueuePresentKHR not executed."); 101 return VK_SUCCESS; 102} 103 104VKAPI_ATTR VkResult disabledCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR*, const VkAllocationCallbacks*, VkSurfaceKHR*) { 105 driver::Logger(instance).Err(instance, "VK_KHR_android_surface not enabled. Exported vkCreateAndroidSurfaceKHR not executed."); 106 return VK_SUCCESS; 107} 108 109// clang-format on 110 111} // anonymous 112 113bool InitDispatchTable( 114 VkInstance instance, 115 PFN_vkGetInstanceProcAddr get_proc, 116 const std::bitset<driver::ProcHook::EXTENSION_COUNT>& extensions) { 117 auto& data = GetData(instance); 118 bool success = true; 119 120 // clang-format off 121 INIT_PROC(instance, DestroyInstance); 122 INIT_PROC(instance, EnumeratePhysicalDevices); 123 INIT_PROC(instance, GetInstanceProcAddr); 124 INIT_PROC(instance, GetPhysicalDeviceProperties); 125 INIT_PROC(instance, GetPhysicalDeviceQueueFamilyProperties); 126 INIT_PROC(instance, GetPhysicalDeviceMemoryProperties); 127 INIT_PROC(instance, GetPhysicalDeviceFeatures); 128 INIT_PROC(instance, GetPhysicalDeviceFormatProperties); 129 INIT_PROC(instance, GetPhysicalDeviceImageFormatProperties); 130 INIT_PROC(instance, CreateDevice); 131 INIT_PROC(instance, EnumerateDeviceExtensionProperties); 132 INIT_PROC(instance, GetPhysicalDeviceSparseImageFormatProperties); 133 INIT_PROC_EXT(KHR_surface, instance, DestroySurfaceKHR); 134 INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceSupportKHR); 135 INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceCapabilitiesKHR); 136 INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceFormatsKHR); 137 INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfacePresentModesKHR); 138 INIT_PROC_EXT(KHR_android_surface, instance, CreateAndroidSurfaceKHR); 139 // clang-format on 140 141 return success; 142} 143 144bool InitDispatchTable( 145 VkDevice dev, 146 PFN_vkGetDeviceProcAddr get_proc, 147 const std::bitset<driver::ProcHook::EXTENSION_COUNT>& extensions) { 148 auto& data = GetData(dev); 149 bool success = true; 150 151 // clang-format off 152 INIT_PROC(dev, GetDeviceProcAddr); 153 INIT_PROC(dev, DestroyDevice); 154 INIT_PROC(dev, GetDeviceQueue); 155 INIT_PROC(dev, QueueSubmit); 156 INIT_PROC(dev, QueueWaitIdle); 157 INIT_PROC(dev, DeviceWaitIdle); 158 INIT_PROC(dev, AllocateMemory); 159 INIT_PROC(dev, FreeMemory); 160 INIT_PROC(dev, MapMemory); 161 INIT_PROC(dev, UnmapMemory); 162 INIT_PROC(dev, FlushMappedMemoryRanges); 163 INIT_PROC(dev, InvalidateMappedMemoryRanges); 164 INIT_PROC(dev, GetDeviceMemoryCommitment); 165 INIT_PROC(dev, GetBufferMemoryRequirements); 166 INIT_PROC(dev, BindBufferMemory); 167 INIT_PROC(dev, GetImageMemoryRequirements); 168 INIT_PROC(dev, BindImageMemory); 169 INIT_PROC(dev, GetImageSparseMemoryRequirements); 170 INIT_PROC(dev, QueueBindSparse); 171 INIT_PROC(dev, CreateFence); 172 INIT_PROC(dev, DestroyFence); 173 INIT_PROC(dev, ResetFences); 174 INIT_PROC(dev, GetFenceStatus); 175 INIT_PROC(dev, WaitForFences); 176 INIT_PROC(dev, CreateSemaphore); 177 INIT_PROC(dev, DestroySemaphore); 178 INIT_PROC(dev, CreateEvent); 179 INIT_PROC(dev, DestroyEvent); 180 INIT_PROC(dev, GetEventStatus); 181 INIT_PROC(dev, SetEvent); 182 INIT_PROC(dev, ResetEvent); 183 INIT_PROC(dev, CreateQueryPool); 184 INIT_PROC(dev, DestroyQueryPool); 185 INIT_PROC(dev, GetQueryPoolResults); 186 INIT_PROC(dev, CreateBuffer); 187 INIT_PROC(dev, DestroyBuffer); 188 INIT_PROC(dev, CreateBufferView); 189 INIT_PROC(dev, DestroyBufferView); 190 INIT_PROC(dev, CreateImage); 191 INIT_PROC(dev, DestroyImage); 192 INIT_PROC(dev, GetImageSubresourceLayout); 193 INIT_PROC(dev, CreateImageView); 194 INIT_PROC(dev, DestroyImageView); 195 INIT_PROC(dev, CreateShaderModule); 196 INIT_PROC(dev, DestroyShaderModule); 197 INIT_PROC(dev, CreatePipelineCache); 198 INIT_PROC(dev, DestroyPipelineCache); 199 INIT_PROC(dev, GetPipelineCacheData); 200 INIT_PROC(dev, MergePipelineCaches); 201 INIT_PROC(dev, CreateGraphicsPipelines); 202 INIT_PROC(dev, CreateComputePipelines); 203 INIT_PROC(dev, DestroyPipeline); 204 INIT_PROC(dev, CreatePipelineLayout); 205 INIT_PROC(dev, DestroyPipelineLayout); 206 INIT_PROC(dev, CreateSampler); 207 INIT_PROC(dev, DestroySampler); 208 INIT_PROC(dev, CreateDescriptorSetLayout); 209 INIT_PROC(dev, DestroyDescriptorSetLayout); 210 INIT_PROC(dev, CreateDescriptorPool); 211 INIT_PROC(dev, DestroyDescriptorPool); 212 INIT_PROC(dev, ResetDescriptorPool); 213 INIT_PROC(dev, AllocateDescriptorSets); 214 INIT_PROC(dev, FreeDescriptorSets); 215 INIT_PROC(dev, UpdateDescriptorSets); 216 INIT_PROC(dev, CreateFramebuffer); 217 INIT_PROC(dev, DestroyFramebuffer); 218 INIT_PROC(dev, CreateRenderPass); 219 INIT_PROC(dev, DestroyRenderPass); 220 INIT_PROC(dev, GetRenderAreaGranularity); 221 INIT_PROC(dev, CreateCommandPool); 222 INIT_PROC(dev, DestroyCommandPool); 223 INIT_PROC(dev, ResetCommandPool); 224 INIT_PROC(dev, AllocateCommandBuffers); 225 INIT_PROC(dev, FreeCommandBuffers); 226 INIT_PROC(dev, BeginCommandBuffer); 227 INIT_PROC(dev, EndCommandBuffer); 228 INIT_PROC(dev, ResetCommandBuffer); 229 INIT_PROC(dev, CmdBindPipeline); 230 INIT_PROC(dev, CmdSetViewport); 231 INIT_PROC(dev, CmdSetScissor); 232 INIT_PROC(dev, CmdSetLineWidth); 233 INIT_PROC(dev, CmdSetDepthBias); 234 INIT_PROC(dev, CmdSetBlendConstants); 235 INIT_PROC(dev, CmdSetDepthBounds); 236 INIT_PROC(dev, CmdSetStencilCompareMask); 237 INIT_PROC(dev, CmdSetStencilWriteMask); 238 INIT_PROC(dev, CmdSetStencilReference); 239 INIT_PROC(dev, CmdBindDescriptorSets); 240 INIT_PROC(dev, CmdBindIndexBuffer); 241 INIT_PROC(dev, CmdBindVertexBuffers); 242 INIT_PROC(dev, CmdDraw); 243 INIT_PROC(dev, CmdDrawIndexed); 244 INIT_PROC(dev, CmdDrawIndirect); 245 INIT_PROC(dev, CmdDrawIndexedIndirect); 246 INIT_PROC(dev, CmdDispatch); 247 INIT_PROC(dev, CmdDispatchIndirect); 248 INIT_PROC(dev, CmdCopyBuffer); 249 INIT_PROC(dev, CmdCopyImage); 250 INIT_PROC(dev, CmdBlitImage); 251 INIT_PROC(dev, CmdCopyBufferToImage); 252 INIT_PROC(dev, CmdCopyImageToBuffer); 253 INIT_PROC(dev, CmdUpdateBuffer); 254 INIT_PROC(dev, CmdFillBuffer); 255 INIT_PROC(dev, CmdClearColorImage); 256 INIT_PROC(dev, CmdClearDepthStencilImage); 257 INIT_PROC(dev, CmdClearAttachments); 258 INIT_PROC(dev, CmdResolveImage); 259 INIT_PROC(dev, CmdSetEvent); 260 INIT_PROC(dev, CmdResetEvent); 261 INIT_PROC(dev, CmdWaitEvents); 262 INIT_PROC(dev, CmdPipelineBarrier); 263 INIT_PROC(dev, CmdBeginQuery); 264 INIT_PROC(dev, CmdEndQuery); 265 INIT_PROC(dev, CmdResetQueryPool); 266 INIT_PROC(dev, CmdWriteTimestamp); 267 INIT_PROC(dev, CmdCopyQueryPoolResults); 268 INIT_PROC(dev, CmdPushConstants); 269 INIT_PROC(dev, CmdBeginRenderPass); 270 INIT_PROC(dev, CmdNextSubpass); 271 INIT_PROC(dev, CmdEndRenderPass); 272 INIT_PROC(dev, CmdExecuteCommands); 273 INIT_PROC_EXT(KHR_swapchain, dev, CreateSwapchainKHR); 274 INIT_PROC_EXT(KHR_swapchain, dev, DestroySwapchainKHR); 275 INIT_PROC_EXT(KHR_swapchain, dev, GetSwapchainImagesKHR); 276 INIT_PROC_EXT(KHR_swapchain, dev, AcquireNextImageKHR); 277 INIT_PROC_EXT(KHR_swapchain, dev, QueuePresentKHR); 278 // clang-format on 279 280 return success; 281} 282 283// clang-format off 284 285namespace { 286 287// forward declarations needed by GetInstanceProcAddr and GetDeviceProcAddr 288VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices); 289VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName); 290VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName); 291VKAPI_ATTR void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties); 292VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties); 293VKAPI_ATTR void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties); 294VKAPI_ATTR void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures); 295VKAPI_ATTR void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties); 296VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties); 297VKAPI_ATTR void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue); 298VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence); 299VKAPI_ATTR VkResult QueueWaitIdle(VkQueue queue); 300VKAPI_ATTR VkResult DeviceWaitIdle(VkDevice device); 301VKAPI_ATTR VkResult AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory); 302VKAPI_ATTR void FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator); 303VKAPI_ATTR VkResult MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData); 304VKAPI_ATTR void UnmapMemory(VkDevice device, VkDeviceMemory memory); 305VKAPI_ATTR VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 306VKAPI_ATTR VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges); 307VKAPI_ATTR void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes); 308VKAPI_ATTR void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements); 309VKAPI_ATTR VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset); 310VKAPI_ATTR void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements); 311VKAPI_ATTR VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset); 312VKAPI_ATTR void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements); 313VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties); 314VKAPI_ATTR VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence); 315VKAPI_ATTR VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence); 316VKAPI_ATTR void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator); 317VKAPI_ATTR VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences); 318VKAPI_ATTR VkResult GetFenceStatus(VkDevice device, VkFence fence); 319VKAPI_ATTR VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout); 320VKAPI_ATTR VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore); 321VKAPI_ATTR void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator); 322VKAPI_ATTR VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent); 323VKAPI_ATTR void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator); 324VKAPI_ATTR VkResult GetEventStatus(VkDevice device, VkEvent event); 325VKAPI_ATTR VkResult SetEvent(VkDevice device, VkEvent event); 326VKAPI_ATTR VkResult ResetEvent(VkDevice device, VkEvent event); 327VKAPI_ATTR VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool); 328VKAPI_ATTR void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator); 329VKAPI_ATTR VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags); 330VKAPI_ATTR VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer); 331VKAPI_ATTR void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator); 332VKAPI_ATTR VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView); 333VKAPI_ATTR void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator); 334VKAPI_ATTR VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage); 335VKAPI_ATTR void DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator); 336VKAPI_ATTR void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout); 337VKAPI_ATTR VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView); 338VKAPI_ATTR void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator); 339VKAPI_ATTR VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule); 340VKAPI_ATTR void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator); 341VKAPI_ATTR VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache); 342VKAPI_ATTR void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator); 343VKAPI_ATTR VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData); 344VKAPI_ATTR VkResult MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches); 345VKAPI_ATTR VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 346VKAPI_ATTR VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines); 347VKAPI_ATTR void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator); 348VKAPI_ATTR VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout); 349VKAPI_ATTR void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator); 350VKAPI_ATTR VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler); 351VKAPI_ATTR void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator); 352VKAPI_ATTR VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout); 353VKAPI_ATTR void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator); 354VKAPI_ATTR VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool); 355VKAPI_ATTR void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator); 356VKAPI_ATTR VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags); 357VKAPI_ATTR VkResult AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets); 358VKAPI_ATTR VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets); 359VKAPI_ATTR void UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies); 360VKAPI_ATTR VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer); 361VKAPI_ATTR void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator); 362VKAPI_ATTR VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass); 363VKAPI_ATTR void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator); 364VKAPI_ATTR void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity); 365VKAPI_ATTR VkResult CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool); 366VKAPI_ATTR void DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator); 367VKAPI_ATTR VkResult ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags); 368VKAPI_ATTR VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers); 369VKAPI_ATTR void FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 370VKAPI_ATTR VkResult BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo); 371VKAPI_ATTR VkResult EndCommandBuffer(VkCommandBuffer commandBuffer); 372VKAPI_ATTR VkResult ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags); 373VKAPI_ATTR void CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline); 374VKAPI_ATTR void CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports); 375VKAPI_ATTR void CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors); 376VKAPI_ATTR void CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth); 377VKAPI_ATTR void CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor); 378VKAPI_ATTR void CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]); 379VKAPI_ATTR void CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds); 380VKAPI_ATTR void CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask); 381VKAPI_ATTR void CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask); 382VKAPI_ATTR void CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference); 383VKAPI_ATTR void CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets); 384VKAPI_ATTR void CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType); 385VKAPI_ATTR void CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets); 386VKAPI_ATTR void CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance); 387VKAPI_ATTR void CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance); 388VKAPI_ATTR void CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 389VKAPI_ATTR void CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride); 390VKAPI_ATTR void CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z); 391VKAPI_ATTR void CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset); 392VKAPI_ATTR void CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions); 393VKAPI_ATTR void CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions); 394VKAPI_ATTR void CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter); 395VKAPI_ATTR void CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions); 396VKAPI_ATTR void CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions); 397VKAPI_ATTR void CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData); 398VKAPI_ATTR void CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data); 399VKAPI_ATTR void CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 400VKAPI_ATTR void CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges); 401VKAPI_ATTR void CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects); 402VKAPI_ATTR void CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions); 403VKAPI_ATTR void CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 404VKAPI_ATTR void CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask); 405VKAPI_ATTR void 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); 406VKAPI_ATTR void 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); 407VKAPI_ATTR void CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags); 408VKAPI_ATTR void CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query); 409VKAPI_ATTR void CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount); 410VKAPI_ATTR void CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query); 411VKAPI_ATTR void CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags); 412VKAPI_ATTR void CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues); 413VKAPI_ATTR void CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents); 414VKAPI_ATTR void CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents); 415VKAPI_ATTR void CmdEndRenderPass(VkCommandBuffer commandBuffer); 416VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers); 417VKAPI_ATTR void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator); 418VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported); 419VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities); 420VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats); 421VKAPI_ATTR VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes); 422VKAPI_ATTR VkResult CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain); 423VKAPI_ATTR void DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator); 424VKAPI_ATTR VkResult GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages); 425VKAPI_ATTR VkResult AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex); 426VKAPI_ATTR VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo); 427VKAPI_ATTR VkResult CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface); 428 429VKAPI_ATTR VkResult EnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { 430 return GetData(instance).dispatch.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); 431} 432 433VKAPI_ATTR PFN_vkVoidFunction GetDeviceProcAddr(VkDevice device, const char* pName) { 434 if (device == VK_NULL_HANDLE) { 435 ALOGE("invalid vkGetDeviceProcAddr(VK_NULL_HANDLE, ...) call"); 436 return nullptr; 437 } 438 439 static const char* const known_non_device_names[] = { 440 "vkCreateAndroidSurfaceKHR", 441 "vkCreateDebugReportCallbackEXT", 442 "vkCreateDevice", 443 "vkCreateInstance", 444 "vkDebugReportMessageEXT", 445 "vkDestroyDebugReportCallbackEXT", 446 "vkDestroyInstance", 447 "vkDestroySurfaceKHR", 448 "vkEnumerateDeviceExtensionProperties", 449 "vkEnumerateDeviceLayerProperties", 450 "vkEnumerateInstanceExtensionProperties", 451 "vkEnumerateInstanceLayerProperties", 452 "vkEnumeratePhysicalDevices", 453 "vkGetInstanceProcAddr", 454 "vkGetPhysicalDeviceFeatures", 455 "vkGetPhysicalDeviceFormatProperties", 456 "vkGetPhysicalDeviceImageFormatProperties", 457 "vkGetPhysicalDeviceMemoryProperties", 458 "vkGetPhysicalDeviceProperties", 459 "vkGetPhysicalDeviceQueueFamilyProperties", 460 "vkGetPhysicalDeviceSparseImageFormatProperties", 461 "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", 462 "vkGetPhysicalDeviceSurfaceFormatsKHR", 463 "vkGetPhysicalDeviceSurfacePresentModesKHR", 464 "vkGetPhysicalDeviceSurfaceSupportKHR", 465 }; 466 // clang-format on 467 constexpr size_t count = 468 sizeof(known_non_device_names) / sizeof(known_non_device_names[0]); 469 if (!pName || 470 std::binary_search( 471 known_non_device_names, known_non_device_names + count, pName, 472 [](const char* a, const char* b) { return (strcmp(a, b) < 0); })) { 473 vulkan::driver::Logger(device).Err( 474 device, "invalid vkGetDeviceProcAddr(%p, \"%s\") call", device, 475 (pName) ? pName : "(null)"); 476 return nullptr; 477 } 478 // clang-format off 479 480 if (strcmp(pName, "vkGetDeviceProcAddr") == 0) return reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr); 481 if (strcmp(pName, "vkDestroyDevice") == 0) return reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice); 482 483 return GetData(device).dispatch.GetDeviceProcAddr(device, pName); 484} 485 486VKAPI_ATTR PFN_vkVoidFunction GetInstanceProcAddr(VkInstance instance, const char* pName) { 487 // global functions 488 if (instance == VK_NULL_HANDLE) { 489 if (strcmp(pName, "vkCreateInstance") == 0) return reinterpret_cast<PFN_vkVoidFunction>(CreateInstance); 490 if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceLayerProperties); 491 if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(EnumerateInstanceExtensionProperties); 492 493 ALOGE("invalid vkGetInstanceProcAddr(VK_NULL_HANDLE, \"%s\") call", pName); 494 return nullptr; 495 } 496 497 static const struct Hook { 498 const char* name; 499 PFN_vkVoidFunction proc; 500 } hooks[] = { 501 { "vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(AcquireNextImageKHR) }, 502 { "vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(AllocateCommandBuffers) }, 503 { "vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(AllocateDescriptorSets) }, 504 { "vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(AllocateMemory) }, 505 { "vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(BeginCommandBuffer) }, 506 { "vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(BindBufferMemory) }, 507 { "vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(BindImageMemory) }, 508 { "vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(CmdBeginQuery) }, 509 { "vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(CmdBeginRenderPass) }, 510 { "vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(CmdBindDescriptorSets) }, 511 { "vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdBindIndexBuffer) }, 512 { "vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(CmdBindPipeline) }, 513 { "vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(CmdBindVertexBuffers) }, 514 { "vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(CmdBlitImage) }, 515 { "vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(CmdClearAttachments) }, 516 { "vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(CmdClearColorImage) }, 517 { "vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(CmdClearDepthStencilImage) }, 518 { "vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyBuffer) }, 519 { "vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyBufferToImage) }, 520 { "vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyImage) }, 521 { "vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyImageToBuffer) }, 522 { "vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(CmdCopyQueryPoolResults) }, 523 { "vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(CmdDispatch) }, 524 { "vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(CmdDispatchIndirect) }, 525 { "vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(CmdDraw) }, 526 { "vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(CmdDrawIndexed) }, 527 { "vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(CmdDrawIndexedIndirect) }, 528 { "vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(CmdDrawIndirect) }, 529 { "vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(CmdEndQuery) }, 530 { "vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(CmdEndRenderPass) }, 531 { "vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(CmdExecuteCommands) }, 532 { "vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdFillBuffer) }, 533 { "vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(CmdNextSubpass) }, 534 { "vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(CmdPipelineBarrier) }, 535 { "vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(CmdPushConstants) }, 536 { "vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(CmdResetEvent) }, 537 { "vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(CmdResetQueryPool) }, 538 { "vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(CmdResolveImage) }, 539 { "vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(CmdSetBlendConstants) }, 540 { "vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(CmdSetDepthBias) }, 541 { "vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(CmdSetDepthBounds) }, 542 { "vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(CmdSetEvent) }, 543 { "vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(CmdSetLineWidth) }, 544 { "vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(CmdSetScissor) }, 545 { "vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(CmdSetStencilCompareMask) }, 546 { "vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(CmdSetStencilReference) }, 547 { "vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(CmdSetStencilWriteMask) }, 548 { "vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(CmdSetViewport) }, 549 { "vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(CmdUpdateBuffer) }, 550 { "vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(CmdWaitEvents) }, 551 { "vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(CmdWriteTimestamp) }, 552 { "vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(CreateBuffer) }, 553 { "vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(CreateBufferView) }, 554 { "vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(CreateCommandPool) }, 555 { "vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(CreateComputePipelines) }, 556 { "vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(CreateDescriptorPool) }, 557 { "vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(CreateDescriptorSetLayout) }, 558 { "vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(CreateDevice) }, 559 { "vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(CreateEvent) }, 560 { "vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(CreateFence) }, 561 { "vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(CreateFramebuffer) }, 562 { "vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(CreateGraphicsPipelines) }, 563 { "vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(CreateImage) }, 564 { "vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(CreateImageView) }, 565 { "vkCreateInstance", nullptr }, 566 { "vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(CreatePipelineCache) }, 567 { "vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(CreatePipelineLayout) }, 568 { "vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(CreateQueryPool) }, 569 { "vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(CreateRenderPass) }, 570 { "vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(CreateSampler) }, 571 { "vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(CreateSemaphore) }, 572 { "vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(CreateShaderModule) }, 573 { "vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(CreateSwapchainKHR) }, 574 { "vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(DestroyBuffer) }, 575 { "vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(DestroyBufferView) }, 576 { "vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(DestroyCommandPool) }, 577 { "vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(DestroyDescriptorPool) }, 578 { "vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(DestroyDescriptorSetLayout) }, 579 { "vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(DestroyDevice) }, 580 { "vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(DestroyEvent) }, 581 { "vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(DestroyFence) }, 582 { "vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(DestroyFramebuffer) }, 583 { "vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(DestroyImage) }, 584 { "vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(DestroyImageView) }, 585 { "vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(DestroyInstance) }, 586 { "vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(DestroyPipeline) }, 587 { "vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(DestroyPipelineCache) }, 588 { "vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(DestroyPipelineLayout) }, 589 { "vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(DestroyQueryPool) }, 590 { "vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(DestroyRenderPass) }, 591 { "vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(DestroySampler) }, 592 { "vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(DestroySemaphore) }, 593 { "vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(DestroyShaderModule) }, 594 { "vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(DestroySwapchainKHR) }, 595 { "vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(DeviceWaitIdle) }, 596 { "vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(EndCommandBuffer) }, 597 { "vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceExtensionProperties) }, 598 { "vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(EnumerateDeviceLayerProperties) }, 599 { "vkEnumerateInstanceExtensionProperties", nullptr }, 600 { "vkEnumerateInstanceLayerProperties", nullptr }, 601 { "vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(FlushMappedMemoryRanges) }, 602 { "vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(FreeCommandBuffers) }, 603 { "vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(FreeDescriptorSets) }, 604 { "vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(FreeMemory) }, 605 { "vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(GetBufferMemoryRequirements) }, 606 { "vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceMemoryCommitment) }, 607 { "vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceProcAddr) }, 608 { "vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(GetDeviceQueue) }, 609 { "vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(GetEventStatus) }, 610 { "vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(GetFenceStatus) }, 611 { "vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(GetImageMemoryRequirements) }, 612 { "vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(GetImageSparseMemoryRequirements) }, 613 { "vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(GetImageSubresourceLayout) }, 614 { "vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(GetInstanceProcAddr) }, 615 { "vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(GetPipelineCacheData) }, 616 { "vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(GetQueryPoolResults) }, 617 { "vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(GetRenderAreaGranularity) }, 618 { "vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(GetSwapchainImagesKHR) }, 619 { "vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(InvalidateMappedMemoryRanges) }, 620 { "vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(MapMemory) }, 621 { "vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(MergePipelineCaches) }, 622 { "vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(QueueBindSparse) }, 623 { "vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(QueuePresentKHR) }, 624 { "vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(QueueSubmit) }, 625 { "vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(QueueWaitIdle) }, 626 { "vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(ResetCommandBuffer) }, 627 { "vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(ResetCommandPool) }, 628 { "vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(ResetDescriptorPool) }, 629 { "vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(ResetEvent) }, 630 { "vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(ResetFences) }, 631 { "vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(SetEvent) }, 632 { "vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(UnmapMemory) }, 633 { "vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(UpdateDescriptorSets) }, 634 { "vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(WaitForFences) }, 635 }; 636 // clang-format on 637 constexpr size_t count = sizeof(hooks) / sizeof(hooks[0]); 638 auto hook = std::lower_bound( 639 hooks, hooks + count, pName, 640 [](const Hook& h, const char* n) { return strcmp(h.name, n) < 0; }); 641 if (hook < hooks + count && strcmp(hook->name, pName) == 0) { 642 if (!hook->proc) { 643 vulkan::driver::Logger(instance).Err( 644 instance, "invalid vkGetInstanceProcAddr(%p, \"%s\") call", 645 instance, pName); 646 } 647 return hook->proc; 648 } 649 // clang-format off 650 651 return GetData(instance).dispatch.GetInstanceProcAddr(instance, pName); 652} 653 654VKAPI_ATTR void GetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { 655 GetData(physicalDevice).dispatch.GetPhysicalDeviceProperties(physicalDevice, pProperties); 656} 657 658VKAPI_ATTR void GetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { 659 GetData(physicalDevice).dispatch.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); 660} 661 662VKAPI_ATTR void GetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { 663 GetData(physicalDevice).dispatch.GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); 664} 665 666VKAPI_ATTR void GetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { 667 GetData(physicalDevice).dispatch.GetPhysicalDeviceFeatures(physicalDevice, pFeatures); 668} 669 670VKAPI_ATTR void GetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { 671 GetData(physicalDevice).dispatch.GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); 672} 673 674VKAPI_ATTR VkResult GetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { 675 return GetData(physicalDevice).dispatch.GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); 676} 677 678VKAPI_ATTR void GetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { 679 GetData(device).dispatch.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); 680} 681 682VKAPI_ATTR VkResult QueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { 683 return GetData(queue).dispatch.QueueSubmit(queue, submitCount, pSubmits, fence); 684} 685 686VKAPI_ATTR VkResult QueueWaitIdle(VkQueue queue) { 687 return GetData(queue).dispatch.QueueWaitIdle(queue); 688} 689 690VKAPI_ATTR VkResult DeviceWaitIdle(VkDevice device) { 691 return GetData(device).dispatch.DeviceWaitIdle(device); 692} 693 694VKAPI_ATTR VkResult AllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { 695 return GetData(device).dispatch.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); 696} 697 698VKAPI_ATTR void FreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { 699 GetData(device).dispatch.FreeMemory(device, memory, pAllocator); 700} 701 702VKAPI_ATTR VkResult MapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { 703 return GetData(device).dispatch.MapMemory(device, memory, offset, size, flags, ppData); 704} 705 706VKAPI_ATTR void UnmapMemory(VkDevice device, VkDeviceMemory memory) { 707 GetData(device).dispatch.UnmapMemory(device, memory); 708} 709 710VKAPI_ATTR VkResult FlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { 711 return GetData(device).dispatch.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 712} 713 714VKAPI_ATTR VkResult InvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { 715 return GetData(device).dispatch.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 716} 717 718VKAPI_ATTR void GetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { 719 GetData(device).dispatch.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 720} 721 722VKAPI_ATTR void GetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { 723 GetData(device).dispatch.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); 724} 725 726VKAPI_ATTR VkResult BindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { 727 return GetData(device).dispatch.BindBufferMemory(device, buffer, memory, memoryOffset); 728} 729 730VKAPI_ATTR void GetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { 731 GetData(device).dispatch.GetImageMemoryRequirements(device, image, pMemoryRequirements); 732} 733 734VKAPI_ATTR VkResult BindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { 735 return GetData(device).dispatch.BindImageMemory(device, image, memory, memoryOffset); 736} 737 738VKAPI_ATTR void GetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { 739 GetData(device).dispatch.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 740} 741 742VKAPI_ATTR void GetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { 743 GetData(physicalDevice).dispatch.GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); 744} 745 746VKAPI_ATTR VkResult QueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { 747 return GetData(queue).dispatch.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); 748} 749 750VKAPI_ATTR VkResult CreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { 751 return GetData(device).dispatch.CreateFence(device, pCreateInfo, pAllocator, pFence); 752} 753 754VKAPI_ATTR void DestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { 755 GetData(device).dispatch.DestroyFence(device, fence, pAllocator); 756} 757 758VKAPI_ATTR VkResult ResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { 759 return GetData(device).dispatch.ResetFences(device, fenceCount, pFences); 760} 761 762VKAPI_ATTR VkResult GetFenceStatus(VkDevice device, VkFence fence) { 763 return GetData(device).dispatch.GetFenceStatus(device, fence); 764} 765 766VKAPI_ATTR VkResult WaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { 767 return GetData(device).dispatch.WaitForFences(device, fenceCount, pFences, waitAll, timeout); 768} 769 770VKAPI_ATTR VkResult CreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { 771 return GetData(device).dispatch.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); 772} 773 774VKAPI_ATTR void DestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { 775 GetData(device).dispatch.DestroySemaphore(device, semaphore, pAllocator); 776} 777 778VKAPI_ATTR VkResult CreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { 779 return GetData(device).dispatch.CreateEvent(device, pCreateInfo, pAllocator, pEvent); 780} 781 782VKAPI_ATTR void DestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { 783 GetData(device).dispatch.DestroyEvent(device, event, pAllocator); 784} 785 786VKAPI_ATTR VkResult GetEventStatus(VkDevice device, VkEvent event) { 787 return GetData(device).dispatch.GetEventStatus(device, event); 788} 789 790VKAPI_ATTR VkResult SetEvent(VkDevice device, VkEvent event) { 791 return GetData(device).dispatch.SetEvent(device, event); 792} 793 794VKAPI_ATTR VkResult ResetEvent(VkDevice device, VkEvent event) { 795 return GetData(device).dispatch.ResetEvent(device, event); 796} 797 798VKAPI_ATTR VkResult CreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { 799 return GetData(device).dispatch.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 800} 801 802VKAPI_ATTR void DestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { 803 GetData(device).dispatch.DestroyQueryPool(device, queryPool, pAllocator); 804} 805 806VKAPI_ATTR VkResult GetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { 807 return GetData(device).dispatch.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); 808} 809 810VKAPI_ATTR VkResult CreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { 811 return GetData(device).dispatch.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); 812} 813 814VKAPI_ATTR void DestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { 815 GetData(device).dispatch.DestroyBuffer(device, buffer, pAllocator); 816} 817 818VKAPI_ATTR VkResult CreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { 819 return GetData(device).dispatch.CreateBufferView(device, pCreateInfo, pAllocator, pView); 820} 821 822VKAPI_ATTR void DestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { 823 GetData(device).dispatch.DestroyBufferView(device, bufferView, pAllocator); 824} 825 826VKAPI_ATTR VkResult CreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { 827 return GetData(device).dispatch.CreateImage(device, pCreateInfo, pAllocator, pImage); 828} 829 830VKAPI_ATTR void DestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { 831 GetData(device).dispatch.DestroyImage(device, image, pAllocator); 832} 833 834VKAPI_ATTR void GetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { 835 GetData(device).dispatch.GetImageSubresourceLayout(device, image, pSubresource, pLayout); 836} 837 838VKAPI_ATTR VkResult CreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { 839 return GetData(device).dispatch.CreateImageView(device, pCreateInfo, pAllocator, pView); 840} 841 842VKAPI_ATTR void DestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { 843 GetData(device).dispatch.DestroyImageView(device, imageView, pAllocator); 844} 845 846VKAPI_ATTR VkResult CreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { 847 return GetData(device).dispatch.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); 848} 849 850VKAPI_ATTR void DestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { 851 GetData(device).dispatch.DestroyShaderModule(device, shaderModule, pAllocator); 852} 853 854VKAPI_ATTR VkResult CreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { 855 return GetData(device).dispatch.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); 856} 857 858VKAPI_ATTR void DestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { 859 GetData(device).dispatch.DestroyPipelineCache(device, pipelineCache, pAllocator); 860} 861 862VKAPI_ATTR VkResult GetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { 863 return GetData(device).dispatch.GetPipelineCacheData(device, pipelineCache, pDataSize, pData); 864} 865 866VKAPI_ATTR VkResult MergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { 867 return GetData(device).dispatch.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); 868} 869 870VKAPI_ATTR VkResult CreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { 871 return GetData(device).dispatch.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 872} 873 874VKAPI_ATTR VkResult CreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { 875 return GetData(device).dispatch.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 876} 877 878VKAPI_ATTR void DestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { 879 GetData(device).dispatch.DestroyPipeline(device, pipeline, pAllocator); 880} 881 882VKAPI_ATTR VkResult CreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { 883 return GetData(device).dispatch.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); 884} 885 886VKAPI_ATTR void DestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { 887 GetData(device).dispatch.DestroyPipelineLayout(device, pipelineLayout, pAllocator); 888} 889 890VKAPI_ATTR VkResult CreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { 891 return GetData(device).dispatch.CreateSampler(device, pCreateInfo, pAllocator, pSampler); 892} 893 894VKAPI_ATTR void DestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { 895 GetData(device).dispatch.DestroySampler(device, sampler, pAllocator); 896} 897 898VKAPI_ATTR VkResult CreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { 899 return GetData(device).dispatch.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); 900} 901 902VKAPI_ATTR void DestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { 903 GetData(device).dispatch.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); 904} 905 906VKAPI_ATTR VkResult CreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { 907 return GetData(device).dispatch.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); 908} 909 910VKAPI_ATTR void DestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { 911 GetData(device).dispatch.DestroyDescriptorPool(device, descriptorPool, pAllocator); 912} 913 914VKAPI_ATTR VkResult ResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { 915 return GetData(device).dispatch.ResetDescriptorPool(device, descriptorPool, flags); 916} 917 918VKAPI_ATTR VkResult AllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { 919 return GetData(device).dispatch.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); 920} 921 922VKAPI_ATTR VkResult FreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { 923 return GetData(device).dispatch.FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); 924} 925 926VKAPI_ATTR void UpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { 927 GetData(device).dispatch.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); 928} 929 930VKAPI_ATTR VkResult CreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { 931 return GetData(device).dispatch.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); 932} 933 934VKAPI_ATTR void DestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { 935 GetData(device).dispatch.DestroyFramebuffer(device, framebuffer, pAllocator); 936} 937 938VKAPI_ATTR VkResult CreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { 939 return GetData(device).dispatch.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); 940} 941 942VKAPI_ATTR void DestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { 943 GetData(device).dispatch.DestroyRenderPass(device, renderPass, pAllocator); 944} 945 946VKAPI_ATTR void GetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { 947 GetData(device).dispatch.GetRenderAreaGranularity(device, renderPass, pGranularity); 948} 949 950VKAPI_ATTR VkResult CreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { 951 return GetData(device).dispatch.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); 952} 953 954VKAPI_ATTR void DestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { 955 GetData(device).dispatch.DestroyCommandPool(device, commandPool, pAllocator); 956} 957 958VKAPI_ATTR VkResult ResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { 959 return GetData(device).dispatch.ResetCommandPool(device, commandPool, flags); 960} 961 962VKAPI_ATTR VkResult AllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { 963 return GetData(device).dispatch.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); 964} 965 966VKAPI_ATTR void FreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { 967 GetData(device).dispatch.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); 968} 969 970VKAPI_ATTR VkResult BeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { 971 return GetData(commandBuffer).dispatch.BeginCommandBuffer(commandBuffer, pBeginInfo); 972} 973 974VKAPI_ATTR VkResult EndCommandBuffer(VkCommandBuffer commandBuffer) { 975 return GetData(commandBuffer).dispatch.EndCommandBuffer(commandBuffer); 976} 977 978VKAPI_ATTR VkResult ResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { 979 return GetData(commandBuffer).dispatch.ResetCommandBuffer(commandBuffer, flags); 980} 981 982VKAPI_ATTR void CmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { 983 GetData(commandBuffer).dispatch.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); 984} 985 986VKAPI_ATTR void CmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { 987 GetData(commandBuffer).dispatch.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); 988} 989 990VKAPI_ATTR void CmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { 991 GetData(commandBuffer).dispatch.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); 992} 993 994VKAPI_ATTR void CmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { 995 GetData(commandBuffer).dispatch.CmdSetLineWidth(commandBuffer, lineWidth); 996} 997 998VKAPI_ATTR void CmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { 999 GetData(commandBuffer).dispatch.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); 1000} 1001 1002VKAPI_ATTR void CmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { 1003 GetData(commandBuffer).dispatch.CmdSetBlendConstants(commandBuffer, blendConstants); 1004} 1005 1006VKAPI_ATTR void CmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { 1007 GetData(commandBuffer).dispatch.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); 1008} 1009 1010VKAPI_ATTR void CmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { 1011 GetData(commandBuffer).dispatch.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); 1012} 1013 1014VKAPI_ATTR void CmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { 1015 GetData(commandBuffer).dispatch.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); 1016} 1017 1018VKAPI_ATTR void CmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { 1019 GetData(commandBuffer).dispatch.CmdSetStencilReference(commandBuffer, faceMask, reference); 1020} 1021 1022VKAPI_ATTR void CmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { 1023 GetData(commandBuffer).dispatch.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 1024} 1025 1026VKAPI_ATTR void CmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { 1027 GetData(commandBuffer).dispatch.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); 1028} 1029 1030VKAPI_ATTR void CmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { 1031 GetData(commandBuffer).dispatch.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); 1032} 1033 1034VKAPI_ATTR void CmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { 1035 GetData(commandBuffer).dispatch.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); 1036} 1037 1038VKAPI_ATTR void CmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { 1039 GetData(commandBuffer).dispatch.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); 1040} 1041 1042VKAPI_ATTR void CmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { 1043 GetData(commandBuffer).dispatch.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); 1044} 1045 1046VKAPI_ATTR void CmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { 1047 GetData(commandBuffer).dispatch.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); 1048} 1049 1050VKAPI_ATTR void CmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { 1051 GetData(commandBuffer).dispatch.CmdDispatch(commandBuffer, x, y, z); 1052} 1053 1054VKAPI_ATTR void CmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { 1055 GetData(commandBuffer).dispatch.CmdDispatchIndirect(commandBuffer, buffer, offset); 1056} 1057 1058VKAPI_ATTR void CmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { 1059 GetData(commandBuffer).dispatch.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); 1060} 1061 1062VKAPI_ATTR void CmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { 1063 GetData(commandBuffer).dispatch.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1064} 1065 1066VKAPI_ATTR void CmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { 1067 GetData(commandBuffer).dispatch.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); 1068} 1069 1070VKAPI_ATTR void CmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { 1071 GetData(commandBuffer).dispatch.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); 1072} 1073 1074VKAPI_ATTR void CmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { 1075 GetData(commandBuffer).dispatch.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); 1076} 1077 1078VKAPI_ATTR void CmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) { 1079 GetData(commandBuffer).dispatch.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); 1080} 1081 1082VKAPI_ATTR void CmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { 1083 GetData(commandBuffer).dispatch.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); 1084} 1085 1086VKAPI_ATTR void CmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { 1087 GetData(commandBuffer).dispatch.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); 1088} 1089 1090VKAPI_ATTR void CmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { 1091 GetData(commandBuffer).dispatch.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); 1092} 1093 1094VKAPI_ATTR void CmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { 1095 GetData(commandBuffer).dispatch.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); 1096} 1097 1098VKAPI_ATTR void CmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { 1099 GetData(commandBuffer).dispatch.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1100} 1101 1102VKAPI_ATTR void CmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { 1103 GetData(commandBuffer).dispatch.CmdSetEvent(commandBuffer, event, stageMask); 1104} 1105 1106VKAPI_ATTR void CmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { 1107 GetData(commandBuffer).dispatch.CmdResetEvent(commandBuffer, event, stageMask); 1108} 1109 1110VKAPI_ATTR void 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) { 1111 GetData(commandBuffer).dispatch.CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 1112} 1113 1114VKAPI_ATTR void 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) { 1115 GetData(commandBuffer).dispatch.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 1116} 1117 1118VKAPI_ATTR void CmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { 1119 GetData(commandBuffer).dispatch.CmdBeginQuery(commandBuffer, queryPool, query, flags); 1120} 1121 1122VKAPI_ATTR void CmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { 1123 GetData(commandBuffer).dispatch.CmdEndQuery(commandBuffer, queryPool, query); 1124} 1125 1126VKAPI_ATTR void CmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { 1127 GetData(commandBuffer).dispatch.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); 1128} 1129 1130VKAPI_ATTR void CmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { 1131 GetData(commandBuffer).dispatch.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); 1132} 1133 1134VKAPI_ATTR void CmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { 1135 GetData(commandBuffer).dispatch.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); 1136} 1137 1138VKAPI_ATTR void CmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { 1139 GetData(commandBuffer).dispatch.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); 1140} 1141 1142VKAPI_ATTR void CmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { 1143 GetData(commandBuffer).dispatch.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); 1144} 1145 1146VKAPI_ATTR void CmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { 1147 GetData(commandBuffer).dispatch.CmdNextSubpass(commandBuffer, contents); 1148} 1149 1150VKAPI_ATTR void CmdEndRenderPass(VkCommandBuffer commandBuffer) { 1151 GetData(commandBuffer).dispatch.CmdEndRenderPass(commandBuffer); 1152} 1153 1154VKAPI_ATTR void CmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { 1155 GetData(commandBuffer).dispatch.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); 1156} 1157 1158VKAPI_ATTR void DestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { 1159 GetData(instance).dispatch.DestroySurfaceKHR(instance, surface, pAllocator); 1160} 1161 1162VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { 1163 return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); 1164} 1165 1166VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { 1167 return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); 1168} 1169 1170VKAPI_ATTR VkResult GetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { 1171 return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); 1172} 1173 1174VKAPI_ATTR VkResult GetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { 1175 return GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); 1176} 1177 1178VKAPI_ATTR VkResult CreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { 1179 return GetData(device).dispatch.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); 1180} 1181 1182VKAPI_ATTR void DestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { 1183 GetData(device).dispatch.DestroySwapchainKHR(device, swapchain, pAllocator); 1184} 1185 1186VKAPI_ATTR VkResult GetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { 1187 return GetData(device).dispatch.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); 1188} 1189 1190VKAPI_ATTR VkResult AcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { 1191 return GetData(device).dispatch.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); 1192} 1193 1194VKAPI_ATTR VkResult QueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { 1195 return GetData(queue).dispatch.QueuePresentKHR(queue, pPresentInfo); 1196} 1197 1198VKAPI_ATTR VkResult CreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { 1199 return GetData(instance).dispatch.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 1200} 1201 1202 1203} // anonymous namespace 1204 1205// clang-format on 1206 1207} // namespace api 1208} // namespace vulkan 1209 1210// clang-format off 1211 1212__attribute__((visibility("default"))) 1213VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { 1214 return vulkan::api::CreateInstance(pCreateInfo, pAllocator, pInstance); 1215} 1216 1217__attribute__((visibility("default"))) 1218VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { 1219 vulkan::api::DestroyInstance(instance, pAllocator); 1220} 1221 1222__attribute__((visibility("default"))) 1223VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { 1224 return vulkan::api::EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); 1225} 1226 1227__attribute__((visibility("default"))) 1228VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) { 1229 return vulkan::api::GetDeviceProcAddr(device, pName); 1230} 1231 1232__attribute__((visibility("default"))) 1233VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) { 1234 return vulkan::api::GetInstanceProcAddr(instance, pName); 1235} 1236 1237__attribute__((visibility("default"))) 1238VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { 1239 vulkan::api::GetPhysicalDeviceProperties(physicalDevice, pProperties); 1240} 1241 1242__attribute__((visibility("default"))) 1243VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { 1244 vulkan::api::GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); 1245} 1246 1247__attribute__((visibility("default"))) 1248VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { 1249 vulkan::api::GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); 1250} 1251 1252__attribute__((visibility("default"))) 1253VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { 1254 vulkan::api::GetPhysicalDeviceFeatures(physicalDevice, pFeatures); 1255} 1256 1257__attribute__((visibility("default"))) 1258VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { 1259 vulkan::api::GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); 1260} 1261 1262__attribute__((visibility("default"))) 1263VKAPI_ATTR VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { 1264 return vulkan::api::GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); 1265} 1266 1267__attribute__((visibility("default"))) 1268VKAPI_ATTR VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { 1269 return vulkan::api::CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); 1270} 1271 1272__attribute__((visibility("default"))) 1273VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { 1274 vulkan::api::DestroyDevice(device, pAllocator); 1275} 1276 1277__attribute__((visibility("default"))) 1278VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) { 1279 return vulkan::api::EnumerateInstanceLayerProperties(pPropertyCount, pProperties); 1280} 1281 1282__attribute__((visibility("default"))) 1283VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { 1284 return vulkan::api::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties); 1285} 1286 1287__attribute__((visibility("default"))) 1288VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) { 1289 return vulkan::api::EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); 1290} 1291 1292__attribute__((visibility("default"))) 1293VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { 1294 return vulkan::api::EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); 1295} 1296 1297__attribute__((visibility("default"))) 1298VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { 1299 vulkan::api::GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); 1300} 1301 1302__attribute__((visibility("default"))) 1303VKAPI_ATTR VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { 1304 return vulkan::api::QueueSubmit(queue, submitCount, pSubmits, fence); 1305} 1306 1307__attribute__((visibility("default"))) 1308VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) { 1309 return vulkan::api::QueueWaitIdle(queue); 1310} 1311 1312__attribute__((visibility("default"))) 1313VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) { 1314 return vulkan::api::DeviceWaitIdle(device); 1315} 1316 1317__attribute__((visibility("default"))) 1318VKAPI_ATTR VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { 1319 return vulkan::api::AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); 1320} 1321 1322__attribute__((visibility("default"))) 1323VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { 1324 vulkan::api::FreeMemory(device, memory, pAllocator); 1325} 1326 1327__attribute__((visibility("default"))) 1328VKAPI_ATTR VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { 1329 return vulkan::api::MapMemory(device, memory, offset, size, flags, ppData); 1330} 1331 1332__attribute__((visibility("default"))) 1333VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) { 1334 vulkan::api::UnmapMemory(device, memory); 1335} 1336 1337__attribute__((visibility("default"))) 1338VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { 1339 return vulkan::api::FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 1340} 1341 1342__attribute__((visibility("default"))) 1343VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { 1344 return vulkan::api::InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 1345} 1346 1347__attribute__((visibility("default"))) 1348VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { 1349 vulkan::api::GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 1350} 1351 1352__attribute__((visibility("default"))) 1353VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { 1354 vulkan::api::GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); 1355} 1356 1357__attribute__((visibility("default"))) 1358VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { 1359 return vulkan::api::BindBufferMemory(device, buffer, memory, memoryOffset); 1360} 1361 1362__attribute__((visibility("default"))) 1363VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { 1364 vulkan::api::GetImageMemoryRequirements(device, image, pMemoryRequirements); 1365} 1366 1367__attribute__((visibility("default"))) 1368VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { 1369 return vulkan::api::BindImageMemory(device, image, memory, memoryOffset); 1370} 1371 1372__attribute__((visibility("default"))) 1373VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { 1374 vulkan::api::GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 1375} 1376 1377__attribute__((visibility("default"))) 1378VKAPI_ATTR void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { 1379 vulkan::api::GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); 1380} 1381 1382__attribute__((visibility("default"))) 1383VKAPI_ATTR VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { 1384 return vulkan::api::QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); 1385} 1386 1387__attribute__((visibility("default"))) 1388VKAPI_ATTR VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { 1389 return vulkan::api::CreateFence(device, pCreateInfo, pAllocator, pFence); 1390} 1391 1392__attribute__((visibility("default"))) 1393VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { 1394 vulkan::api::DestroyFence(device, fence, pAllocator); 1395} 1396 1397__attribute__((visibility("default"))) 1398VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { 1399 return vulkan::api::ResetFences(device, fenceCount, pFences); 1400} 1401 1402__attribute__((visibility("default"))) 1403VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) { 1404 return vulkan::api::GetFenceStatus(device, fence); 1405} 1406 1407__attribute__((visibility("default"))) 1408VKAPI_ATTR VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { 1409 return vulkan::api::WaitForFences(device, fenceCount, pFences, waitAll, timeout); 1410} 1411 1412__attribute__((visibility("default"))) 1413VKAPI_ATTR VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { 1414 return vulkan::api::CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); 1415} 1416 1417__attribute__((visibility("default"))) 1418VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { 1419 vulkan::api::DestroySemaphore(device, semaphore, pAllocator); 1420} 1421 1422__attribute__((visibility("default"))) 1423VKAPI_ATTR VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { 1424 return vulkan::api::CreateEvent(device, pCreateInfo, pAllocator, pEvent); 1425} 1426 1427__attribute__((visibility("default"))) 1428VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { 1429 vulkan::api::DestroyEvent(device, event, pAllocator); 1430} 1431 1432__attribute__((visibility("default"))) 1433VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) { 1434 return vulkan::api::GetEventStatus(device, event); 1435} 1436 1437__attribute__((visibility("default"))) 1438VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) { 1439 return vulkan::api::SetEvent(device, event); 1440} 1441 1442__attribute__((visibility("default"))) 1443VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) { 1444 return vulkan::api::ResetEvent(device, event); 1445} 1446 1447__attribute__((visibility("default"))) 1448VKAPI_ATTR VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { 1449 return vulkan::api::CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 1450} 1451 1452__attribute__((visibility("default"))) 1453VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { 1454 vulkan::api::DestroyQueryPool(device, queryPool, pAllocator); 1455} 1456 1457__attribute__((visibility("default"))) 1458VKAPI_ATTR VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { 1459 return vulkan::api::GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); 1460} 1461 1462__attribute__((visibility("default"))) 1463VKAPI_ATTR VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { 1464 return vulkan::api::CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); 1465} 1466 1467__attribute__((visibility("default"))) 1468VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { 1469 vulkan::api::DestroyBuffer(device, buffer, pAllocator); 1470} 1471 1472__attribute__((visibility("default"))) 1473VKAPI_ATTR VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { 1474 return vulkan::api::CreateBufferView(device, pCreateInfo, pAllocator, pView); 1475} 1476 1477__attribute__((visibility("default"))) 1478VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { 1479 vulkan::api::DestroyBufferView(device, bufferView, pAllocator); 1480} 1481 1482__attribute__((visibility("default"))) 1483VKAPI_ATTR VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { 1484 return vulkan::api::CreateImage(device, pCreateInfo, pAllocator, pImage); 1485} 1486 1487__attribute__((visibility("default"))) 1488VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { 1489 vulkan::api::DestroyImage(device, image, pAllocator); 1490} 1491 1492__attribute__((visibility("default"))) 1493VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { 1494 vulkan::api::GetImageSubresourceLayout(device, image, pSubresource, pLayout); 1495} 1496 1497__attribute__((visibility("default"))) 1498VKAPI_ATTR VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { 1499 return vulkan::api::CreateImageView(device, pCreateInfo, pAllocator, pView); 1500} 1501 1502__attribute__((visibility("default"))) 1503VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { 1504 vulkan::api::DestroyImageView(device, imageView, pAllocator); 1505} 1506 1507__attribute__((visibility("default"))) 1508VKAPI_ATTR VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { 1509 return vulkan::api::CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); 1510} 1511 1512__attribute__((visibility("default"))) 1513VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { 1514 vulkan::api::DestroyShaderModule(device, shaderModule, pAllocator); 1515} 1516 1517__attribute__((visibility("default"))) 1518VKAPI_ATTR VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { 1519 return vulkan::api::CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); 1520} 1521 1522__attribute__((visibility("default"))) 1523VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { 1524 vulkan::api::DestroyPipelineCache(device, pipelineCache, pAllocator); 1525} 1526 1527__attribute__((visibility("default"))) 1528VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { 1529 return vulkan::api::GetPipelineCacheData(device, pipelineCache, pDataSize, pData); 1530} 1531 1532__attribute__((visibility("default"))) 1533VKAPI_ATTR VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { 1534 return vulkan::api::MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); 1535} 1536 1537__attribute__((visibility("default"))) 1538VKAPI_ATTR VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { 1539 return vulkan::api::CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 1540} 1541 1542__attribute__((visibility("default"))) 1543VKAPI_ATTR VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { 1544 return vulkan::api::CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 1545} 1546 1547__attribute__((visibility("default"))) 1548VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { 1549 vulkan::api::DestroyPipeline(device, pipeline, pAllocator); 1550} 1551 1552__attribute__((visibility("default"))) 1553VKAPI_ATTR VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { 1554 return vulkan::api::CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); 1555} 1556 1557__attribute__((visibility("default"))) 1558VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { 1559 vulkan::api::DestroyPipelineLayout(device, pipelineLayout, pAllocator); 1560} 1561 1562__attribute__((visibility("default"))) 1563VKAPI_ATTR VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { 1564 return vulkan::api::CreateSampler(device, pCreateInfo, pAllocator, pSampler); 1565} 1566 1567__attribute__((visibility("default"))) 1568VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { 1569 vulkan::api::DestroySampler(device, sampler, pAllocator); 1570} 1571 1572__attribute__((visibility("default"))) 1573VKAPI_ATTR VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { 1574 return vulkan::api::CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); 1575} 1576 1577__attribute__((visibility("default"))) 1578VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { 1579 vulkan::api::DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); 1580} 1581 1582__attribute__((visibility("default"))) 1583VKAPI_ATTR VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { 1584 return vulkan::api::CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); 1585} 1586 1587__attribute__((visibility("default"))) 1588VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { 1589 vulkan::api::DestroyDescriptorPool(device, descriptorPool, pAllocator); 1590} 1591 1592__attribute__((visibility("default"))) 1593VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { 1594 return vulkan::api::ResetDescriptorPool(device, descriptorPool, flags); 1595} 1596 1597__attribute__((visibility("default"))) 1598VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { 1599 return vulkan::api::AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); 1600} 1601 1602__attribute__((visibility("default"))) 1603VKAPI_ATTR VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { 1604 return vulkan::api::FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); 1605} 1606 1607__attribute__((visibility("default"))) 1608VKAPI_ATTR void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { 1609 vulkan::api::UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); 1610} 1611 1612__attribute__((visibility("default"))) 1613VKAPI_ATTR VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { 1614 return vulkan::api::CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); 1615} 1616 1617__attribute__((visibility("default"))) 1618VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { 1619 vulkan::api::DestroyFramebuffer(device, framebuffer, pAllocator); 1620} 1621 1622__attribute__((visibility("default"))) 1623VKAPI_ATTR VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { 1624 return vulkan::api::CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); 1625} 1626 1627__attribute__((visibility("default"))) 1628VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { 1629 vulkan::api::DestroyRenderPass(device, renderPass, pAllocator); 1630} 1631 1632__attribute__((visibility("default"))) 1633VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { 1634 vulkan::api::GetRenderAreaGranularity(device, renderPass, pGranularity); 1635} 1636 1637__attribute__((visibility("default"))) 1638VKAPI_ATTR VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { 1639 return vulkan::api::CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); 1640} 1641 1642__attribute__((visibility("default"))) 1643VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { 1644 vulkan::api::DestroyCommandPool(device, commandPool, pAllocator); 1645} 1646 1647__attribute__((visibility("default"))) 1648VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { 1649 return vulkan::api::ResetCommandPool(device, commandPool, flags); 1650} 1651 1652__attribute__((visibility("default"))) 1653VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { 1654 return vulkan::api::AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); 1655} 1656 1657__attribute__((visibility("default"))) 1658VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { 1659 vulkan::api::FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); 1660} 1661 1662__attribute__((visibility("default"))) 1663VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { 1664 return vulkan::api::BeginCommandBuffer(commandBuffer, pBeginInfo); 1665} 1666 1667__attribute__((visibility("default"))) 1668VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) { 1669 return vulkan::api::EndCommandBuffer(commandBuffer); 1670} 1671 1672__attribute__((visibility("default"))) 1673VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { 1674 return vulkan::api::ResetCommandBuffer(commandBuffer, flags); 1675} 1676 1677__attribute__((visibility("default"))) 1678VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { 1679 vulkan::api::CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); 1680} 1681 1682__attribute__((visibility("default"))) 1683VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { 1684 vulkan::api::CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); 1685} 1686 1687__attribute__((visibility("default"))) 1688VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { 1689 vulkan::api::CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); 1690} 1691 1692__attribute__((visibility("default"))) 1693VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { 1694 vulkan::api::CmdSetLineWidth(commandBuffer, lineWidth); 1695} 1696 1697__attribute__((visibility("default"))) 1698VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { 1699 vulkan::api::CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); 1700} 1701 1702__attribute__((visibility("default"))) 1703VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { 1704 vulkan::api::CmdSetBlendConstants(commandBuffer, blendConstants); 1705} 1706 1707__attribute__((visibility("default"))) 1708VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { 1709 vulkan::api::CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); 1710} 1711 1712__attribute__((visibility("default"))) 1713VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { 1714 vulkan::api::CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); 1715} 1716 1717__attribute__((visibility("default"))) 1718VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { 1719 vulkan::api::CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); 1720} 1721 1722__attribute__((visibility("default"))) 1723VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { 1724 vulkan::api::CmdSetStencilReference(commandBuffer, faceMask, reference); 1725} 1726 1727__attribute__((visibility("default"))) 1728VKAPI_ATTR void vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) { 1729 vulkan::api::CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 1730} 1731 1732__attribute__((visibility("default"))) 1733VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { 1734 vulkan::api::CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); 1735} 1736 1737__attribute__((visibility("default"))) 1738VKAPI_ATTR void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { 1739 vulkan::api::CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); 1740} 1741 1742__attribute__((visibility("default"))) 1743VKAPI_ATTR void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { 1744 vulkan::api::CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); 1745} 1746 1747__attribute__((visibility("default"))) 1748VKAPI_ATTR void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { 1749 vulkan::api::CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); 1750} 1751 1752__attribute__((visibility("default"))) 1753VKAPI_ATTR void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { 1754 vulkan::api::CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); 1755} 1756 1757__attribute__((visibility("default"))) 1758VKAPI_ATTR void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { 1759 vulkan::api::CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); 1760} 1761 1762__attribute__((visibility("default"))) 1763VKAPI_ATTR void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { 1764 vulkan::api::CmdDispatch(commandBuffer, x, y, z); 1765} 1766 1767__attribute__((visibility("default"))) 1768VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { 1769 vulkan::api::CmdDispatchIndirect(commandBuffer, buffer, offset); 1770} 1771 1772__attribute__((visibility("default"))) 1773VKAPI_ATTR void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { 1774 vulkan::api::CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); 1775} 1776 1777__attribute__((visibility("default"))) 1778VKAPI_ATTR void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { 1779 vulkan::api::CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1780} 1781 1782__attribute__((visibility("default"))) 1783VKAPI_ATTR void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { 1784 vulkan::api::CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); 1785} 1786 1787__attribute__((visibility("default"))) 1788VKAPI_ATTR void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { 1789 vulkan::api::CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); 1790} 1791 1792__attribute__((visibility("default"))) 1793VKAPI_ATTR void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { 1794 vulkan::api::CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); 1795} 1796 1797__attribute__((visibility("default"))) 1798VKAPI_ATTR void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) { 1799 vulkan::api::CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); 1800} 1801 1802__attribute__((visibility("default"))) 1803VKAPI_ATTR void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { 1804 vulkan::api::CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); 1805} 1806 1807__attribute__((visibility("default"))) 1808VKAPI_ATTR void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { 1809 vulkan::api::CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); 1810} 1811 1812__attribute__((visibility("default"))) 1813VKAPI_ATTR void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { 1814 vulkan::api::CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); 1815} 1816 1817__attribute__((visibility("default"))) 1818VKAPI_ATTR void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { 1819 vulkan::api::CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); 1820} 1821 1822__attribute__((visibility("default"))) 1823VKAPI_ATTR void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { 1824 vulkan::api::CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1825} 1826 1827__attribute__((visibility("default"))) 1828VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { 1829 vulkan::api::CmdSetEvent(commandBuffer, event, stageMask); 1830} 1831 1832__attribute__((visibility("default"))) 1833VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { 1834 vulkan::api::CmdResetEvent(commandBuffer, event, stageMask); 1835} 1836 1837__attribute__((visibility("default"))) 1838VKAPI_ATTR void vkCmdWaitEvents(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) { 1839 vulkan::api::CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 1840} 1841 1842__attribute__((visibility("default"))) 1843VKAPI_ATTR void vkCmdPipelineBarrier(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) { 1844 vulkan::api::CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 1845} 1846 1847__attribute__((visibility("default"))) 1848VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { 1849 vulkan::api::CmdBeginQuery(commandBuffer, queryPool, query, flags); 1850} 1851 1852__attribute__((visibility("default"))) 1853VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { 1854 vulkan::api::CmdEndQuery(commandBuffer, queryPool, query); 1855} 1856 1857__attribute__((visibility("default"))) 1858VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { 1859 vulkan::api::CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); 1860} 1861 1862__attribute__((visibility("default"))) 1863VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { 1864 vulkan::api::CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); 1865} 1866 1867__attribute__((visibility("default"))) 1868VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { 1869 vulkan::api::CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); 1870} 1871 1872__attribute__((visibility("default"))) 1873VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { 1874 vulkan::api::CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); 1875} 1876 1877__attribute__((visibility("default"))) 1878VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { 1879 vulkan::api::CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); 1880} 1881 1882__attribute__((visibility("default"))) 1883VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { 1884 vulkan::api::CmdNextSubpass(commandBuffer, contents); 1885} 1886 1887__attribute__((visibility("default"))) 1888VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { 1889 vulkan::api::CmdEndRenderPass(commandBuffer); 1890} 1891 1892__attribute__((visibility("default"))) 1893VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { 1894 vulkan::api::CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); 1895} 1896 1897__attribute__((visibility("default"))) 1898VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { 1899 vulkan::api::DestroySurfaceKHR(instance, surface, pAllocator); 1900} 1901 1902__attribute__((visibility("default"))) 1903VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { 1904 return vulkan::api::GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); 1905} 1906 1907__attribute__((visibility("default"))) 1908VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { 1909 return vulkan::api::GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); 1910} 1911 1912__attribute__((visibility("default"))) 1913VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { 1914 return vulkan::api::GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); 1915} 1916 1917__attribute__((visibility("default"))) 1918VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { 1919 return vulkan::api::GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); 1920} 1921 1922__attribute__((visibility("default"))) 1923VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { 1924 return vulkan::api::CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); 1925} 1926 1927__attribute__((visibility("default"))) 1928VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { 1929 vulkan::api::DestroySwapchainKHR(device, swapchain, pAllocator); 1930} 1931 1932__attribute__((visibility("default"))) 1933VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { 1934 return vulkan::api::GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); 1935} 1936 1937__attribute__((visibility("default"))) 1938VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { 1939 return vulkan::api::AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); 1940} 1941 1942__attribute__((visibility("default"))) 1943VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { 1944 return vulkan::api::QueuePresentKHR(queue, pPresentInfo); 1945} 1946 1947__attribute__((visibility("default"))) 1948VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { 1949 return vulkan::api::CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 1950} 1951 1952// clang-format on 1953