api_gen.cpp revision 8925efd0a87d96885834a00f3bdef220edf6d8ea
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#include "api.h" 24 25namespace vulkan { 26namespace api { 27 28#define UNLIKELY(expr) __builtin_expect((expr), 0) 29 30#define INIT_PROC(obj, proc) \ 31 do { \ 32 data.dispatch.proc = \ 33 reinterpret_cast<PFN_vk##proc>(get_proc(obj, "vk" #proc)); \ 34 if (UNLIKELY(!data.dispatch.proc)) { \ 35 ALOGE("missing " #obj " proc: vk" #proc); \ 36 success = false; \ 37 } \ 38 } while (0) 39 40// Exported extension functions may be invoked even when their extensions 41// are disabled. Dispatch to stubs when that happens. 42#define INIT_PROC_EXT(ext, obj, proc) \ 43 do { \ 44 if (extensions[driver::ProcHook::ext]) \ 45 INIT_PROC(obj, proc); \ 46 else \ 47 data.dispatch.proc = disabled##proc; \ 48 } while (0) 49 50namespace { 51 52// clang-format off 53 54VKAPI_ATTR void disabledDestroySurfaceKHR(VkInstance, VkSurfaceKHR, const VkAllocationCallbacks*) { 55 ALOGE("VK_KHR_surface not enabled. vkDestroySurfaceKHR not executed."); 56} 57 58VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice, uint32_t, VkSurfaceKHR, VkBool32*) { 59 ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceSupportKHR not executed."); 60 return VK_SUCCESS; 61} 62 63VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice, VkSurfaceKHR, VkSurfaceCapabilitiesKHR*) { 64 ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceCapabilitiesKHR not executed."); 65 return VK_SUCCESS; 66} 67 68VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice, VkSurfaceKHR, uint32_t*, VkSurfaceFormatKHR*) { 69 ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfaceFormatsKHR not executed."); 70 return VK_SUCCESS; 71} 72 73VKAPI_ATTR VkResult disabledGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice, VkSurfaceKHR, uint32_t*, VkPresentModeKHR*) { 74 ALOGE("VK_KHR_surface not enabled. vkGetPhysicalDeviceSurfacePresentModesKHR not executed."); 75 return VK_SUCCESS; 76} 77 78VKAPI_ATTR VkResult disabledCreateSwapchainKHR(VkDevice, const VkSwapchainCreateInfoKHR*, const VkAllocationCallbacks*, VkSwapchainKHR*) { 79 ALOGE("VK_KHR_swapchain not enabled. vkCreateSwapchainKHR not executed."); 80 return VK_SUCCESS; 81} 82 83VKAPI_ATTR void disabledDestroySwapchainKHR(VkDevice, VkSwapchainKHR, const VkAllocationCallbacks*) { 84 ALOGE("VK_KHR_swapchain not enabled. vkDestroySwapchainKHR not executed."); 85} 86 87VKAPI_ATTR VkResult disabledGetSwapchainImagesKHR(VkDevice, VkSwapchainKHR, uint32_t*, VkImage*) { 88 ALOGE("VK_KHR_swapchain not enabled. vkGetSwapchainImagesKHR not executed."); 89 return VK_SUCCESS; 90} 91 92VKAPI_ATTR VkResult disabledAcquireNextImageKHR(VkDevice, VkSwapchainKHR, uint64_t, VkSemaphore, VkFence, uint32_t*) { 93 ALOGE("VK_KHR_swapchain not enabled. vkAcquireNextImageKHR not executed."); 94 return VK_SUCCESS; 95} 96 97VKAPI_ATTR VkResult disabledQueuePresentKHR(VkQueue, const VkPresentInfoKHR*) { 98 ALOGE("VK_KHR_swapchain not enabled. vkQueuePresentKHR not executed."); 99 return VK_SUCCESS; 100} 101 102VKAPI_ATTR VkResult disabledCreateAndroidSurfaceKHR(VkInstance, const VkAndroidSurfaceCreateInfoKHR*, const VkAllocationCallbacks*, VkSurfaceKHR*) { 103 ALOGE("VK_KHR_android_surface not enabled. vkCreateAndroidSurfaceKHR not executed."); 104 return VK_SUCCESS; 105} 106 107// clang-format on 108 109} // anonymous 110 111bool InitDispatchTable( 112 VkInstance instance, 113 PFN_vkGetInstanceProcAddr get_proc, 114 const std::bitset<driver::ProcHook::EXTENSION_COUNT>& extensions) { 115 auto& data = GetData(instance); 116 bool success = true; 117 118 // clang-format off 119 INIT_PROC(instance, DestroyInstance); 120 INIT_PROC(instance, EnumeratePhysicalDevices); 121 INIT_PROC(instance, GetInstanceProcAddr); 122 INIT_PROC(instance, GetPhysicalDeviceProperties); 123 INIT_PROC(instance, GetPhysicalDeviceQueueFamilyProperties); 124 INIT_PROC(instance, GetPhysicalDeviceMemoryProperties); 125 INIT_PROC(instance, GetPhysicalDeviceFeatures); 126 INIT_PROC(instance, GetPhysicalDeviceFormatProperties); 127 INIT_PROC(instance, GetPhysicalDeviceImageFormatProperties); 128 INIT_PROC(instance, CreateDevice); 129 INIT_PROC(instance, EnumerateDeviceLayerProperties); 130 INIT_PROC(instance, EnumerateDeviceExtensionProperties); 131 INIT_PROC(instance, GetPhysicalDeviceSparseImageFormatProperties); 132 INIT_PROC_EXT(KHR_surface, instance, DestroySurfaceKHR); 133 INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceSupportKHR); 134 INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceCapabilitiesKHR); 135 INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfaceFormatsKHR); 136 INIT_PROC_EXT(KHR_surface, instance, GetPhysicalDeviceSurfacePresentModesKHR); 137 INIT_PROC_EXT(KHR_android_surface, instance, CreateAndroidSurfaceKHR); 138 // clang-format on 139 140 return success; 141} 142 143bool InitDispatchTable( 144 VkDevice dev, 145 PFN_vkGetDeviceProcAddr get_proc, 146 const std::bitset<driver::ProcHook::EXTENSION_COUNT>& extensions) { 147 auto& data = GetData(dev); 148 bool success = true; 149 150 // clang-format off 151 INIT_PROC(dev, GetDeviceProcAddr); 152 INIT_PROC(dev, DestroyDevice); 153 INIT_PROC(dev, GetDeviceQueue); 154 INIT_PROC(dev, QueueSubmit); 155 INIT_PROC(dev, QueueWaitIdle); 156 INIT_PROC(dev, DeviceWaitIdle); 157 INIT_PROC(dev, AllocateMemory); 158 INIT_PROC(dev, FreeMemory); 159 INIT_PROC(dev, MapMemory); 160 INIT_PROC(dev, UnmapMemory); 161 INIT_PROC(dev, FlushMappedMemoryRanges); 162 INIT_PROC(dev, InvalidateMappedMemoryRanges); 163 INIT_PROC(dev, GetDeviceMemoryCommitment); 164 INIT_PROC(dev, GetBufferMemoryRequirements); 165 INIT_PROC(dev, BindBufferMemory); 166 INIT_PROC(dev, GetImageMemoryRequirements); 167 INIT_PROC(dev, BindImageMemory); 168 INIT_PROC(dev, GetImageSparseMemoryRequirements); 169 INIT_PROC(dev, QueueBindSparse); 170 INIT_PROC(dev, CreateFence); 171 INIT_PROC(dev, DestroyFence); 172 INIT_PROC(dev, ResetFences); 173 INIT_PROC(dev, GetFenceStatus); 174 INIT_PROC(dev, WaitForFences); 175 INIT_PROC(dev, CreateSemaphore); 176 INIT_PROC(dev, DestroySemaphore); 177 INIT_PROC(dev, CreateEvent); 178 INIT_PROC(dev, DestroyEvent); 179 INIT_PROC(dev, GetEventStatus); 180 INIT_PROC(dev, SetEvent); 181 INIT_PROC(dev, ResetEvent); 182 INIT_PROC(dev, CreateQueryPool); 183 INIT_PROC(dev, DestroyQueryPool); 184 INIT_PROC(dev, GetQueryPoolResults); 185 INIT_PROC(dev, CreateBuffer); 186 INIT_PROC(dev, DestroyBuffer); 187 INIT_PROC(dev, CreateBufferView); 188 INIT_PROC(dev, DestroyBufferView); 189 INIT_PROC(dev, CreateImage); 190 INIT_PROC(dev, DestroyImage); 191 INIT_PROC(dev, GetImageSubresourceLayout); 192 INIT_PROC(dev, CreateImageView); 193 INIT_PROC(dev, DestroyImageView); 194 INIT_PROC(dev, CreateShaderModule); 195 INIT_PROC(dev, DestroyShaderModule); 196 INIT_PROC(dev, CreatePipelineCache); 197 INIT_PROC(dev, DestroyPipelineCache); 198 INIT_PROC(dev, GetPipelineCacheData); 199 INIT_PROC(dev, MergePipelineCaches); 200 INIT_PROC(dev, CreateGraphicsPipelines); 201 INIT_PROC(dev, CreateComputePipelines); 202 INIT_PROC(dev, DestroyPipeline); 203 INIT_PROC(dev, CreatePipelineLayout); 204 INIT_PROC(dev, DestroyPipelineLayout); 205 INIT_PROC(dev, CreateSampler); 206 INIT_PROC(dev, DestroySampler); 207 INIT_PROC(dev, CreateDescriptorSetLayout); 208 INIT_PROC(dev, DestroyDescriptorSetLayout); 209 INIT_PROC(dev, CreateDescriptorPool); 210 INIT_PROC(dev, DestroyDescriptorPool); 211 INIT_PROC(dev, ResetDescriptorPool); 212 INIT_PROC(dev, AllocateDescriptorSets); 213 INIT_PROC(dev, FreeDescriptorSets); 214 INIT_PROC(dev, UpdateDescriptorSets); 215 INIT_PROC(dev, CreateFramebuffer); 216 INIT_PROC(dev, DestroyFramebuffer); 217 INIT_PROC(dev, CreateRenderPass); 218 INIT_PROC(dev, DestroyRenderPass); 219 INIT_PROC(dev, GetRenderAreaGranularity); 220 INIT_PROC(dev, CreateCommandPool); 221 INIT_PROC(dev, DestroyCommandPool); 222 INIT_PROC(dev, ResetCommandPool); 223 INIT_PROC(dev, AllocateCommandBuffers); 224 INIT_PROC(dev, FreeCommandBuffers); 225 INIT_PROC(dev, BeginCommandBuffer); 226 INIT_PROC(dev, EndCommandBuffer); 227 INIT_PROC(dev, ResetCommandBuffer); 228 INIT_PROC(dev, CmdBindPipeline); 229 INIT_PROC(dev, CmdSetViewport); 230 INIT_PROC(dev, CmdSetScissor); 231 INIT_PROC(dev, CmdSetLineWidth); 232 INIT_PROC(dev, CmdSetDepthBias); 233 INIT_PROC(dev, CmdSetBlendConstants); 234 INIT_PROC(dev, CmdSetDepthBounds); 235 INIT_PROC(dev, CmdSetStencilCompareMask); 236 INIT_PROC(dev, CmdSetStencilWriteMask); 237 INIT_PROC(dev, CmdSetStencilReference); 238 INIT_PROC(dev, CmdBindDescriptorSets); 239 INIT_PROC(dev, CmdBindIndexBuffer); 240 INIT_PROC(dev, CmdBindVertexBuffers); 241 INIT_PROC(dev, CmdDraw); 242 INIT_PROC(dev, CmdDrawIndexed); 243 INIT_PROC(dev, CmdDrawIndirect); 244 INIT_PROC(dev, CmdDrawIndexedIndirect); 245 INIT_PROC(dev, CmdDispatch); 246 INIT_PROC(dev, CmdDispatchIndirect); 247 INIT_PROC(dev, CmdCopyBuffer); 248 INIT_PROC(dev, CmdCopyImage); 249 INIT_PROC(dev, CmdBlitImage); 250 INIT_PROC(dev, CmdCopyBufferToImage); 251 INIT_PROC(dev, CmdCopyImageToBuffer); 252 INIT_PROC(dev, CmdUpdateBuffer); 253 INIT_PROC(dev, CmdFillBuffer); 254 INIT_PROC(dev, CmdClearColorImage); 255 INIT_PROC(dev, CmdClearDepthStencilImage); 256 INIT_PROC(dev, CmdClearAttachments); 257 INIT_PROC(dev, CmdResolveImage); 258 INIT_PROC(dev, CmdSetEvent); 259 INIT_PROC(dev, CmdResetEvent); 260 INIT_PROC(dev, CmdWaitEvents); 261 INIT_PROC(dev, CmdPipelineBarrier); 262 INIT_PROC(dev, CmdBeginQuery); 263 INIT_PROC(dev, CmdEndQuery); 264 INIT_PROC(dev, CmdResetQueryPool); 265 INIT_PROC(dev, CmdWriteTimestamp); 266 INIT_PROC(dev, CmdCopyQueryPoolResults); 267 INIT_PROC(dev, CmdPushConstants); 268 INIT_PROC(dev, CmdBeginRenderPass); 269 INIT_PROC(dev, CmdNextSubpass); 270 INIT_PROC(dev, CmdEndRenderPass); 271 INIT_PROC(dev, CmdExecuteCommands); 272 INIT_PROC_EXT(KHR_swapchain, dev, CreateSwapchainKHR); 273 INIT_PROC_EXT(KHR_swapchain, dev, DestroySwapchainKHR); 274 INIT_PROC_EXT(KHR_swapchain, dev, GetSwapchainImagesKHR); 275 INIT_PROC_EXT(KHR_swapchain, dev, AcquireNextImageKHR); 276 INIT_PROC_EXT(KHR_swapchain, dev, QueuePresentKHR); 277 // clang-format on 278 279 return success; 280} 281 282} // namespace api 283} // namespace vulkan 284 285// clang-format off 286 287__attribute__((visibility("default"))) 288VKAPI_ATTR VkResult vkCreateInstance(const VkInstanceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkInstance* pInstance) { 289 // call into api.cpp 290 return vulkan::api::CreateInstance(pCreateInfo, pAllocator, pInstance); 291} 292 293__attribute__((visibility("default"))) 294VKAPI_ATTR void vkDestroyInstance(VkInstance instance, const VkAllocationCallbacks* pAllocator) { 295 // call into api.cpp 296 vulkan::api::DestroyInstance(instance, pAllocator); 297} 298 299__attribute__((visibility("default"))) 300VKAPI_ATTR VkResult vkEnumeratePhysicalDevices(VkInstance instance, uint32_t* pPhysicalDeviceCount, VkPhysicalDevice* pPhysicalDevices) { 301 return vulkan::api::GetData(instance).dispatch.EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, pPhysicalDevices); 302} 303 304__attribute__((visibility("default"))) 305VKAPI_ATTR PFN_vkVoidFunction vkGetDeviceProcAddr(VkDevice device, const char* pName) { 306 if (device == VK_NULL_HANDLE) { 307 ALOGE("vkGetDeviceProcAddr called with invalid device"); 308 return nullptr; 309 } 310 311 static const char* const known_non_device_names[] = { 312 "vkCreateAndroidSurfaceKHR", 313 "vkCreateDebugReportCallbackEXT", 314 "vkCreateDevice", 315 "vkCreateInstance", 316 "vkDebugReportMessageEXT", 317 "vkDestroyDebugReportCallbackEXT", 318 "vkDestroyInstance", 319 "vkDestroySurfaceKHR", 320 "vkEnumerateDeviceExtensionProperties", 321 "vkEnumerateDeviceLayerProperties", 322 "vkEnumerateInstanceExtensionProperties", 323 "vkEnumerateInstanceLayerProperties", 324 "vkEnumeratePhysicalDevices", 325 "vkGetInstanceProcAddr", 326 "vkGetPhysicalDeviceFeatures", 327 "vkGetPhysicalDeviceFormatProperties", 328 "vkGetPhysicalDeviceImageFormatProperties", 329 "vkGetPhysicalDeviceMemoryProperties", 330 "vkGetPhysicalDeviceProperties", 331 "vkGetPhysicalDeviceQueueFamilyProperties", 332 "vkGetPhysicalDeviceSparseImageFormatProperties", 333 "vkGetPhysicalDeviceSurfaceCapabilitiesKHR", 334 "vkGetPhysicalDeviceSurfaceFormatsKHR", 335 "vkGetPhysicalDeviceSurfacePresentModesKHR", 336 "vkGetPhysicalDeviceSurfaceSupportKHR", 337 }; 338 // clang-format on 339 constexpr size_t count = 340 sizeof(known_non_device_names) / sizeof(known_non_device_names[0]); 341 if (!pName || 342 std::binary_search( 343 known_non_device_names, known_non_device_names + count, pName, 344 [](const char* a, const char* b) { return (strcmp(a, b) < 0); })) { 345 ALOGE("vkGetDeviceProcAddr called with %s", (pName) ? pName : "(null)"); 346 return nullptr; 347 } 348 // clang-format off 349 350 if (strcmp(pName, "vkGetDeviceProcAddr") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr); 351 if (strcmp(pName, "vkDestroyDevice") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::DestroyDevice); 352 353 return vulkan::api::GetData(device).dispatch.GetDeviceProcAddr(device, pName); 354} 355 356__attribute__((visibility("default"))) 357VKAPI_ATTR PFN_vkVoidFunction vkGetInstanceProcAddr(VkInstance instance, const char* pName) { 358 // global functions 359 if (!instance) { 360 if (strcmp(pName, "vkCreateInstance") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::CreateInstance); 361 if (strcmp(pName, "vkEnumerateInstanceLayerProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateInstanceLayerProperties); 362 if (strcmp(pName, "vkEnumerateInstanceExtensionProperties") == 0) return reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateInstanceExtensionProperties); 363 364 ALOGE("vkGetInstanceProcAddr called with %s without instance", pName); 365 return nullptr; 366 } 367 368 static const struct Hook { 369 const char* name; 370 PFN_vkVoidFunction proc; 371 } hooks[] = { 372 { "vkAcquireNextImageKHR", reinterpret_cast<PFN_vkVoidFunction>(vkAcquireNextImageKHR) }, 373 { "vkAllocateCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateCommandBuffers) }, 374 { "vkAllocateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateDescriptorSets) }, 375 { "vkAllocateMemory", reinterpret_cast<PFN_vkVoidFunction>(vkAllocateMemory) }, 376 { "vkBeginCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkBeginCommandBuffer) }, 377 { "vkBindBufferMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindBufferMemory) }, 378 { "vkBindImageMemory", reinterpret_cast<PFN_vkVoidFunction>(vkBindImageMemory) }, 379 { "vkCmdBeginQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginQuery) }, 380 { "vkCmdBeginRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBeginRenderPass) }, 381 { "vkCmdBindDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindDescriptorSets) }, 382 { "vkCmdBindIndexBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindIndexBuffer) }, 383 { "vkCmdBindPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindPipeline) }, 384 { "vkCmdBindVertexBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBindVertexBuffers) }, 385 { "vkCmdBlitImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdBlitImage) }, 386 { "vkCmdClearAttachments", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearAttachments) }, 387 { "vkCmdClearColorImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearColorImage) }, 388 { "vkCmdClearDepthStencilImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdClearDepthStencilImage) }, 389 { "vkCmdCopyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBuffer) }, 390 { "vkCmdCopyBufferToImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyBufferToImage) }, 391 { "vkCmdCopyImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImage) }, 392 { "vkCmdCopyImageToBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyImageToBuffer) }, 393 { "vkCmdCopyQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkCmdCopyQueryPoolResults) }, 394 { "vkCmdDispatch", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatch) }, 395 { "vkCmdDispatchIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDispatchIndirect) }, 396 { "vkCmdDraw", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDraw) }, 397 { "vkCmdDrawIndexed", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexed) }, 398 { "vkCmdDrawIndexedIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndexedIndirect) }, 399 { "vkCmdDrawIndirect", reinterpret_cast<PFN_vkVoidFunction>(vkCmdDrawIndirect) }, 400 { "vkCmdEndQuery", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndQuery) }, 401 { "vkCmdEndRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdEndRenderPass) }, 402 { "vkCmdExecuteCommands", reinterpret_cast<PFN_vkVoidFunction>(vkCmdExecuteCommands) }, 403 { "vkCmdFillBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdFillBuffer) }, 404 { "vkCmdNextSubpass", reinterpret_cast<PFN_vkVoidFunction>(vkCmdNextSubpass) }, 405 { "vkCmdPipelineBarrier", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPipelineBarrier) }, 406 { "vkCmdPushConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdPushConstants) }, 407 { "vkCmdResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetEvent) }, 408 { "vkCmdResetQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResetQueryPool) }, 409 { "vkCmdResolveImage", reinterpret_cast<PFN_vkVoidFunction>(vkCmdResolveImage) }, 410 { "vkCmdSetBlendConstants", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetBlendConstants) }, 411 { "vkCmdSetDepthBias", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBias) }, 412 { "vkCmdSetDepthBounds", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetDepthBounds) }, 413 { "vkCmdSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetEvent) }, 414 { "vkCmdSetLineWidth", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetLineWidth) }, 415 { "vkCmdSetScissor", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetScissor) }, 416 { "vkCmdSetStencilCompareMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilCompareMask) }, 417 { "vkCmdSetStencilReference", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilReference) }, 418 { "vkCmdSetStencilWriteMask", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetStencilWriteMask) }, 419 { "vkCmdSetViewport", reinterpret_cast<PFN_vkVoidFunction>(vkCmdSetViewport) }, 420 { "vkCmdUpdateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCmdUpdateBuffer) }, 421 { "vkCmdWaitEvents", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWaitEvents) }, 422 { "vkCmdWriteTimestamp", reinterpret_cast<PFN_vkVoidFunction>(vkCmdWriteTimestamp) }, 423 { "vkCreateBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBuffer) }, 424 { "vkCreateBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateBufferView) }, 425 { "vkCreateCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateCommandPool) }, 426 { "vkCreateComputePipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateComputePipelines) }, 427 { "vkCreateDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorPool) }, 428 { "vkCreateDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreateDescriptorSetLayout) }, 429 { "vkCreateDevice", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::CreateDevice) }, 430 { "vkCreateEvent", reinterpret_cast<PFN_vkVoidFunction>(vkCreateEvent) }, 431 { "vkCreateFence", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFence) }, 432 { "vkCreateFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkCreateFramebuffer) }, 433 { "vkCreateGraphicsPipelines", reinterpret_cast<PFN_vkVoidFunction>(vkCreateGraphicsPipelines) }, 434 { "vkCreateImage", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImage) }, 435 { "vkCreateImageView", reinterpret_cast<PFN_vkVoidFunction>(vkCreateImageView) }, 436 { "vkCreateInstance", nullptr }, 437 { "vkCreatePipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineCache) }, 438 { "vkCreatePipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkCreatePipelineLayout) }, 439 { "vkCreateQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkCreateQueryPool) }, 440 { "vkCreateRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkCreateRenderPass) }, 441 { "vkCreateSampler", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSampler) }, 442 { "vkCreateSemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSemaphore) }, 443 { "vkCreateShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkCreateShaderModule) }, 444 { "vkCreateSwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkCreateSwapchainKHR) }, 445 { "vkDestroyBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBuffer) }, 446 { "vkDestroyBufferView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyBufferView) }, 447 { "vkDestroyCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyCommandPool) }, 448 { "vkDestroyDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorPool) }, 449 { "vkDestroyDescriptorSetLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyDescriptorSetLayout) }, 450 { "vkDestroyDevice", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::DestroyDevice) }, 451 { "vkDestroyEvent", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyEvent) }, 452 { "vkDestroyFence", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFence) }, 453 { "vkDestroyFramebuffer", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyFramebuffer) }, 454 { "vkDestroyImage", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImage) }, 455 { "vkDestroyImageView", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyImageView) }, 456 { "vkDestroyInstance", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::DestroyInstance) }, 457 { "vkDestroyPipeline", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipeline) }, 458 { "vkDestroyPipelineCache", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineCache) }, 459 { "vkDestroyPipelineLayout", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyPipelineLayout) }, 460 { "vkDestroyQueryPool", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyQueryPool) }, 461 { "vkDestroyRenderPass", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyRenderPass) }, 462 { "vkDestroySampler", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySampler) }, 463 { "vkDestroySemaphore", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySemaphore) }, 464 { "vkDestroyShaderModule", reinterpret_cast<PFN_vkVoidFunction>(vkDestroyShaderModule) }, 465 { "vkDestroySwapchainKHR", reinterpret_cast<PFN_vkVoidFunction>(vkDestroySwapchainKHR) }, 466 { "vkDeviceWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkDeviceWaitIdle) }, 467 { "vkEndCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkEndCommandBuffer) }, 468 { "vkEnumerateDeviceExtensionProperties", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateDeviceExtensionProperties) }, 469 { "vkEnumerateDeviceLayerProperties", reinterpret_cast<PFN_vkVoidFunction>(vulkan::api::EnumerateDeviceLayerProperties) }, 470 { "vkEnumerateInstanceExtensionProperties", nullptr }, 471 { "vkEnumerateInstanceLayerProperties", nullptr }, 472 { "vkFlushMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkFlushMappedMemoryRanges) }, 473 { "vkFreeCommandBuffers", reinterpret_cast<PFN_vkVoidFunction>(vkFreeCommandBuffers) }, 474 { "vkFreeDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkFreeDescriptorSets) }, 475 { "vkFreeMemory", reinterpret_cast<PFN_vkVoidFunction>(vkFreeMemory) }, 476 { "vkGetBufferMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetBufferMemoryRequirements) }, 477 { "vkGetDeviceMemoryCommitment", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceMemoryCommitment) }, 478 { "vkGetDeviceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceProcAddr) }, 479 { "vkGetDeviceQueue", reinterpret_cast<PFN_vkVoidFunction>(vkGetDeviceQueue) }, 480 { "vkGetEventStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetEventStatus) }, 481 { "vkGetFenceStatus", reinterpret_cast<PFN_vkVoidFunction>(vkGetFenceStatus) }, 482 { "vkGetImageMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageMemoryRequirements) }, 483 { "vkGetImageSparseMemoryRequirements", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSparseMemoryRequirements) }, 484 { "vkGetImageSubresourceLayout", reinterpret_cast<PFN_vkVoidFunction>(vkGetImageSubresourceLayout) }, 485 { "vkGetInstanceProcAddr", reinterpret_cast<PFN_vkVoidFunction>(vkGetInstanceProcAddr) }, 486 { "vkGetPipelineCacheData", reinterpret_cast<PFN_vkVoidFunction>(vkGetPipelineCacheData) }, 487 { "vkGetQueryPoolResults", reinterpret_cast<PFN_vkVoidFunction>(vkGetQueryPoolResults) }, 488 { "vkGetRenderAreaGranularity", reinterpret_cast<PFN_vkVoidFunction>(vkGetRenderAreaGranularity) }, 489 { "vkGetSwapchainImagesKHR", reinterpret_cast<PFN_vkVoidFunction>(vkGetSwapchainImagesKHR) }, 490 { "vkInvalidateMappedMemoryRanges", reinterpret_cast<PFN_vkVoidFunction>(vkInvalidateMappedMemoryRanges) }, 491 { "vkMapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkMapMemory) }, 492 { "vkMergePipelineCaches", reinterpret_cast<PFN_vkVoidFunction>(vkMergePipelineCaches) }, 493 { "vkQueueBindSparse", reinterpret_cast<PFN_vkVoidFunction>(vkQueueBindSparse) }, 494 { "vkQueuePresentKHR", reinterpret_cast<PFN_vkVoidFunction>(vkQueuePresentKHR) }, 495 { "vkQueueSubmit", reinterpret_cast<PFN_vkVoidFunction>(vkQueueSubmit) }, 496 { "vkQueueWaitIdle", reinterpret_cast<PFN_vkVoidFunction>(vkQueueWaitIdle) }, 497 { "vkResetCommandBuffer", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandBuffer) }, 498 { "vkResetCommandPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetCommandPool) }, 499 { "vkResetDescriptorPool", reinterpret_cast<PFN_vkVoidFunction>(vkResetDescriptorPool) }, 500 { "vkResetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkResetEvent) }, 501 { "vkResetFences", reinterpret_cast<PFN_vkVoidFunction>(vkResetFences) }, 502 { "vkSetEvent", reinterpret_cast<PFN_vkVoidFunction>(vkSetEvent) }, 503 { "vkUnmapMemory", reinterpret_cast<PFN_vkVoidFunction>(vkUnmapMemory) }, 504 { "vkUpdateDescriptorSets", reinterpret_cast<PFN_vkVoidFunction>(vkUpdateDescriptorSets) }, 505 { "vkWaitForFences", reinterpret_cast<PFN_vkVoidFunction>(vkWaitForFences) }, 506 }; 507 // clang-format on 508 constexpr size_t count = sizeof(hooks) / sizeof(hooks[0]); 509 auto hook = std::lower_bound( 510 hooks, hooks + count, pName, 511 [](const Hook& h, const char* n) { return strcmp(h.name, n) < 0; }); 512 if (hook < hooks + count && strcmp(hook->name, pName) == 0) { 513 if (!hook->proc) 514 ALOGE("vkGetInstanceProcAddr called with %s with instance", pName); 515 return hook->proc; 516 } 517 // clang-format off 518 519 return vulkan::api::GetData(instance).dispatch.GetInstanceProcAddr(instance, pName); 520} 521 522__attribute__((visibility("default"))) 523VKAPI_ATTR void vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceProperties* pProperties) { 524 vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceProperties(physicalDevice, pProperties); 525} 526 527__attribute__((visibility("default"))) 528VKAPI_ATTR void vkGetPhysicalDeviceQueueFamilyProperties(VkPhysicalDevice physicalDevice, uint32_t* pQueueFamilyPropertyCount, VkQueueFamilyProperties* pQueueFamilyProperties) { 529 vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceQueueFamilyProperties(physicalDevice, pQueueFamilyPropertyCount, pQueueFamilyProperties); 530} 531 532__attribute__((visibility("default"))) 533VKAPI_ATTR void vkGetPhysicalDeviceMemoryProperties(VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties* pMemoryProperties) { 534 vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceMemoryProperties(physicalDevice, pMemoryProperties); 535} 536 537__attribute__((visibility("default"))) 538VKAPI_ATTR void vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, VkPhysicalDeviceFeatures* pFeatures) { 539 vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceFeatures(physicalDevice, pFeatures); 540} 541 542__attribute__((visibility("default"))) 543VKAPI_ATTR void vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkFormatProperties* pFormatProperties) { 544 vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceFormatProperties(physicalDevice, format, pFormatProperties); 545} 546 547__attribute__((visibility("default"))) 548VKAPI_ATTR VkResult vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) { 549 return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); 550} 551 552__attribute__((visibility("default"))) 553VKAPI_ATTR VkResult vkCreateDevice(VkPhysicalDevice physicalDevice, const VkDeviceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDevice* pDevice) { 554 // call into api.cpp 555 return vulkan::api::CreateDevice(physicalDevice, pCreateInfo, pAllocator, pDevice); 556} 557 558__attribute__((visibility("default"))) 559VKAPI_ATTR void vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) { 560 // call into api.cpp 561 vulkan::api::DestroyDevice(device, pAllocator); 562} 563 564__attribute__((visibility("default"))) 565VKAPI_ATTR VkResult vkEnumerateInstanceLayerProperties(uint32_t* pPropertyCount, VkLayerProperties* pProperties) { 566 // call into api.cpp 567 return vulkan::api::EnumerateInstanceLayerProperties(pPropertyCount, pProperties); 568} 569 570__attribute__((visibility("default"))) 571VKAPI_ATTR VkResult vkEnumerateInstanceExtensionProperties(const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { 572 // call into api.cpp 573 return vulkan::api::EnumerateInstanceExtensionProperties(pLayerName, pPropertyCount, pProperties); 574} 575 576__attribute__((visibility("default"))) 577VKAPI_ATTR VkResult vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, uint32_t* pPropertyCount, VkLayerProperties* pProperties) { 578 // call into api.cpp 579 return vulkan::api::EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); 580} 581 582__attribute__((visibility("default"))) 583VKAPI_ATTR VkResult vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, const char* pLayerName, uint32_t* pPropertyCount, VkExtensionProperties* pProperties) { 584 // call into api.cpp 585 return vulkan::api::EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); 586} 587 588__attribute__((visibility("default"))) 589VKAPI_ATTR void vkGetDeviceQueue(VkDevice device, uint32_t queueFamilyIndex, uint32_t queueIndex, VkQueue* pQueue) { 590 vulkan::api::GetData(device).dispatch.GetDeviceQueue(device, queueFamilyIndex, queueIndex, pQueue); 591} 592 593__attribute__((visibility("default"))) 594VKAPI_ATTR VkResult vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) { 595 return vulkan::api::GetData(queue).dispatch.QueueSubmit(queue, submitCount, pSubmits, fence); 596} 597 598__attribute__((visibility("default"))) 599VKAPI_ATTR VkResult vkQueueWaitIdle(VkQueue queue) { 600 return vulkan::api::GetData(queue).dispatch.QueueWaitIdle(queue); 601} 602 603__attribute__((visibility("default"))) 604VKAPI_ATTR VkResult vkDeviceWaitIdle(VkDevice device) { 605 return vulkan::api::GetData(device).dispatch.DeviceWaitIdle(device); 606} 607 608__attribute__((visibility("default"))) 609VKAPI_ATTR VkResult vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) { 610 return vulkan::api::GetData(device).dispatch.AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); 611} 612 613__attribute__((visibility("default"))) 614VKAPI_ATTR void vkFreeMemory(VkDevice device, VkDeviceMemory memory, const VkAllocationCallbacks* pAllocator) { 615 vulkan::api::GetData(device).dispatch.FreeMemory(device, memory, pAllocator); 616} 617 618__attribute__((visibility("default"))) 619VKAPI_ATTR VkResult vkMapMemory(VkDevice device, VkDeviceMemory memory, VkDeviceSize offset, VkDeviceSize size, VkMemoryMapFlags flags, void** ppData) { 620 return vulkan::api::GetData(device).dispatch.MapMemory(device, memory, offset, size, flags, ppData); 621} 622 623__attribute__((visibility("default"))) 624VKAPI_ATTR void vkUnmapMemory(VkDevice device, VkDeviceMemory memory) { 625 vulkan::api::GetData(device).dispatch.UnmapMemory(device, memory); 626} 627 628__attribute__((visibility("default"))) 629VKAPI_ATTR VkResult vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { 630 return vulkan::api::GetData(device).dispatch.FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 631} 632 633__attribute__((visibility("default"))) 634VKAPI_ATTR VkResult vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) { 635 return vulkan::api::GetData(device).dispatch.InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 636} 637 638__attribute__((visibility("default"))) 639VKAPI_ATTR void vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) { 640 vulkan::api::GetData(device).dispatch.GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 641} 642 643__attribute__((visibility("default"))) 644VKAPI_ATTR void vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) { 645 vulkan::api::GetData(device).dispatch.GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); 646} 647 648__attribute__((visibility("default"))) 649VKAPI_ATTR VkResult vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory memory, VkDeviceSize memoryOffset) { 650 return vulkan::api::GetData(device).dispatch.BindBufferMemory(device, buffer, memory, memoryOffset); 651} 652 653__attribute__((visibility("default"))) 654VKAPI_ATTR void vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) { 655 vulkan::api::GetData(device).dispatch.GetImageMemoryRequirements(device, image, pMemoryRequirements); 656} 657 658__attribute__((visibility("default"))) 659VKAPI_ATTR VkResult vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory memory, VkDeviceSize memoryOffset) { 660 return vulkan::api::GetData(device).dispatch.BindImageMemory(device, image, memory, memoryOffset); 661} 662 663__attribute__((visibility("default"))) 664VKAPI_ATTR void vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) { 665 vulkan::api::GetData(device).dispatch.GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 666} 667 668__attribute__((visibility("default"))) 669VKAPI_ATTR void vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) { 670 vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); 671} 672 673__attribute__((visibility("default"))) 674VKAPI_ATTR VkResult vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) { 675 return vulkan::api::GetData(queue).dispatch.QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); 676} 677 678__attribute__((visibility("default"))) 679VKAPI_ATTR VkResult vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) { 680 return vulkan::api::GetData(device).dispatch.CreateFence(device, pCreateInfo, pAllocator, pFence); 681} 682 683__attribute__((visibility("default"))) 684VKAPI_ATTR void vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) { 685 vulkan::api::GetData(device).dispatch.DestroyFence(device, fence, pAllocator); 686} 687 688__attribute__((visibility("default"))) 689VKAPI_ATTR VkResult vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) { 690 return vulkan::api::GetData(device).dispatch.ResetFences(device, fenceCount, pFences); 691} 692 693__attribute__((visibility("default"))) 694VKAPI_ATTR VkResult vkGetFenceStatus(VkDevice device, VkFence fence) { 695 return vulkan::api::GetData(device).dispatch.GetFenceStatus(device, fence); 696} 697 698__attribute__((visibility("default"))) 699VKAPI_ATTR VkResult vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) { 700 return vulkan::api::GetData(device).dispatch.WaitForFences(device, fenceCount, pFences, waitAll, timeout); 701} 702 703__attribute__((visibility("default"))) 704VKAPI_ATTR VkResult vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) { 705 return vulkan::api::GetData(device).dispatch.CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); 706} 707 708__attribute__((visibility("default"))) 709VKAPI_ATTR void vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) { 710 vulkan::api::GetData(device).dispatch.DestroySemaphore(device, semaphore, pAllocator); 711} 712 713__attribute__((visibility("default"))) 714VKAPI_ATTR VkResult vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) { 715 return vulkan::api::GetData(device).dispatch.CreateEvent(device, pCreateInfo, pAllocator, pEvent); 716} 717 718__attribute__((visibility("default"))) 719VKAPI_ATTR void vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) { 720 vulkan::api::GetData(device).dispatch.DestroyEvent(device, event, pAllocator); 721} 722 723__attribute__((visibility("default"))) 724VKAPI_ATTR VkResult vkGetEventStatus(VkDevice device, VkEvent event) { 725 return vulkan::api::GetData(device).dispatch.GetEventStatus(device, event); 726} 727 728__attribute__((visibility("default"))) 729VKAPI_ATTR VkResult vkSetEvent(VkDevice device, VkEvent event) { 730 return vulkan::api::GetData(device).dispatch.SetEvent(device, event); 731} 732 733__attribute__((visibility("default"))) 734VKAPI_ATTR VkResult vkResetEvent(VkDevice device, VkEvent event) { 735 return vulkan::api::GetData(device).dispatch.ResetEvent(device, event); 736} 737 738__attribute__((visibility("default"))) 739VKAPI_ATTR VkResult vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) { 740 return vulkan::api::GetData(device).dispatch.CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 741} 742 743__attribute__((visibility("default"))) 744VKAPI_ATTR void vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) { 745 vulkan::api::GetData(device).dispatch.DestroyQueryPool(device, queryPool, pAllocator); 746} 747 748__attribute__((visibility("default"))) 749VKAPI_ATTR VkResult vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) { 750 return vulkan::api::GetData(device).dispatch.GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); 751} 752 753__attribute__((visibility("default"))) 754VKAPI_ATTR VkResult vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) { 755 return vulkan::api::GetData(device).dispatch.CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); 756} 757 758__attribute__((visibility("default"))) 759VKAPI_ATTR void vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) { 760 vulkan::api::GetData(device).dispatch.DestroyBuffer(device, buffer, pAllocator); 761} 762 763__attribute__((visibility("default"))) 764VKAPI_ATTR VkResult vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) { 765 return vulkan::api::GetData(device).dispatch.CreateBufferView(device, pCreateInfo, pAllocator, pView); 766} 767 768__attribute__((visibility("default"))) 769VKAPI_ATTR void vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) { 770 vulkan::api::GetData(device).dispatch.DestroyBufferView(device, bufferView, pAllocator); 771} 772 773__attribute__((visibility("default"))) 774VKAPI_ATTR VkResult vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) { 775 return vulkan::api::GetData(device).dispatch.CreateImage(device, pCreateInfo, pAllocator, pImage); 776} 777 778__attribute__((visibility("default"))) 779VKAPI_ATTR void vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) { 780 vulkan::api::GetData(device).dispatch.DestroyImage(device, image, pAllocator); 781} 782 783__attribute__((visibility("default"))) 784VKAPI_ATTR void vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) { 785 vulkan::api::GetData(device).dispatch.GetImageSubresourceLayout(device, image, pSubresource, pLayout); 786} 787 788__attribute__((visibility("default"))) 789VKAPI_ATTR VkResult vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) { 790 return vulkan::api::GetData(device).dispatch.CreateImageView(device, pCreateInfo, pAllocator, pView); 791} 792 793__attribute__((visibility("default"))) 794VKAPI_ATTR void vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) { 795 vulkan::api::GetData(device).dispatch.DestroyImageView(device, imageView, pAllocator); 796} 797 798__attribute__((visibility("default"))) 799VKAPI_ATTR VkResult vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShaderModule) { 800 return vulkan::api::GetData(device).dispatch.CreateShaderModule(device, pCreateInfo, pAllocator, pShaderModule); 801} 802 803__attribute__((visibility("default"))) 804VKAPI_ATTR void vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) { 805 vulkan::api::GetData(device).dispatch.DestroyShaderModule(device, shaderModule, pAllocator); 806} 807 808__attribute__((visibility("default"))) 809VKAPI_ATTR VkResult vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) { 810 return vulkan::api::GetData(device).dispatch.CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); 811} 812 813__attribute__((visibility("default"))) 814VKAPI_ATTR void vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) { 815 vulkan::api::GetData(device).dispatch.DestroyPipelineCache(device, pipelineCache, pAllocator); 816} 817 818__attribute__((visibility("default"))) 819VKAPI_ATTR VkResult vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) { 820 return vulkan::api::GetData(device).dispatch.GetPipelineCacheData(device, pipelineCache, pDataSize, pData); 821} 822 823__attribute__((visibility("default"))) 824VKAPI_ATTR VkResult vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) { 825 return vulkan::api::GetData(device).dispatch.MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); 826} 827 828__attribute__((visibility("default"))) 829VKAPI_ATTR VkResult vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { 830 return vulkan::api::GetData(device).dispatch.CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 831} 832 833__attribute__((visibility("default"))) 834VKAPI_ATTR VkResult vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) { 835 return vulkan::api::GetData(device).dispatch.CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 836} 837 838__attribute__((visibility("default"))) 839VKAPI_ATTR void vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) { 840 vulkan::api::GetData(device).dispatch.DestroyPipeline(device, pipeline, pAllocator); 841} 842 843__attribute__((visibility("default"))) 844VKAPI_ATTR VkResult vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) { 845 return vulkan::api::GetData(device).dispatch.CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); 846} 847 848__attribute__((visibility("default"))) 849VKAPI_ATTR void vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) { 850 vulkan::api::GetData(device).dispatch.DestroyPipelineLayout(device, pipelineLayout, pAllocator); 851} 852 853__attribute__((visibility("default"))) 854VKAPI_ATTR VkResult vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) { 855 return vulkan::api::GetData(device).dispatch.CreateSampler(device, pCreateInfo, pAllocator, pSampler); 856} 857 858__attribute__((visibility("default"))) 859VKAPI_ATTR void vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) { 860 vulkan::api::GetData(device).dispatch.DestroySampler(device, sampler, pAllocator); 861} 862 863__attribute__((visibility("default"))) 864VKAPI_ATTR VkResult vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) { 865 return vulkan::api::GetData(device).dispatch.CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); 866} 867 868__attribute__((visibility("default"))) 869VKAPI_ATTR void vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) { 870 vulkan::api::GetData(device).dispatch.DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); 871} 872 873__attribute__((visibility("default"))) 874VKAPI_ATTR VkResult vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) { 875 return vulkan::api::GetData(device).dispatch.CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); 876} 877 878__attribute__((visibility("default"))) 879VKAPI_ATTR void vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) { 880 vulkan::api::GetData(device).dispatch.DestroyDescriptorPool(device, descriptorPool, pAllocator); 881} 882 883__attribute__((visibility("default"))) 884VKAPI_ATTR VkResult vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) { 885 return vulkan::api::GetData(device).dispatch.ResetDescriptorPool(device, descriptorPool, flags); 886} 887 888__attribute__((visibility("default"))) 889VKAPI_ATTR VkResult vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) { 890 return vulkan::api::GetData(device).dispatch.AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); 891} 892 893__attribute__((visibility("default"))) 894VKAPI_ATTR VkResult vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) { 895 return vulkan::api::GetData(device).dispatch.FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); 896} 897 898__attribute__((visibility("default"))) 899VKAPI_ATTR void vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) { 900 vulkan::api::GetData(device).dispatch.UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); 901} 902 903__attribute__((visibility("default"))) 904VKAPI_ATTR VkResult vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) { 905 return vulkan::api::GetData(device).dispatch.CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); 906} 907 908__attribute__((visibility("default"))) 909VKAPI_ATTR void vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) { 910 vulkan::api::GetData(device).dispatch.DestroyFramebuffer(device, framebuffer, pAllocator); 911} 912 913__attribute__((visibility("default"))) 914VKAPI_ATTR VkResult vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) { 915 return vulkan::api::GetData(device).dispatch.CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); 916} 917 918__attribute__((visibility("default"))) 919VKAPI_ATTR void vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) { 920 vulkan::api::GetData(device).dispatch.DestroyRenderPass(device, renderPass, pAllocator); 921} 922 923__attribute__((visibility("default"))) 924VKAPI_ATTR void vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) { 925 vulkan::api::GetData(device).dispatch.GetRenderAreaGranularity(device, renderPass, pGranularity); 926} 927 928__attribute__((visibility("default"))) 929VKAPI_ATTR VkResult vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) { 930 return vulkan::api::GetData(device).dispatch.CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); 931} 932 933__attribute__((visibility("default"))) 934VKAPI_ATTR void vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) { 935 vulkan::api::GetData(device).dispatch.DestroyCommandPool(device, commandPool, pAllocator); 936} 937 938__attribute__((visibility("default"))) 939VKAPI_ATTR VkResult vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) { 940 return vulkan::api::GetData(device).dispatch.ResetCommandPool(device, commandPool, flags); 941} 942 943__attribute__((visibility("default"))) 944VKAPI_ATTR VkResult vkAllocateCommandBuffers(VkDevice device, const VkCommandBufferAllocateInfo* pAllocateInfo, VkCommandBuffer* pCommandBuffers) { 945 return vulkan::api::GetData(device).dispatch.AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); 946} 947 948__attribute__((visibility("default"))) 949VKAPI_ATTR void vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { 950 vulkan::api::GetData(device).dispatch.FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); 951} 952 953__attribute__((visibility("default"))) 954VKAPI_ATTR VkResult vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) { 955 return vulkan::api::GetData(commandBuffer).dispatch.BeginCommandBuffer(commandBuffer, pBeginInfo); 956} 957 958__attribute__((visibility("default"))) 959VKAPI_ATTR VkResult vkEndCommandBuffer(VkCommandBuffer commandBuffer) { 960 return vulkan::api::GetData(commandBuffer).dispatch.EndCommandBuffer(commandBuffer); 961} 962 963__attribute__((visibility("default"))) 964VKAPI_ATTR VkResult vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) { 965 return vulkan::api::GetData(commandBuffer).dispatch.ResetCommandBuffer(commandBuffer, flags); 966} 967 968__attribute__((visibility("default"))) 969VKAPI_ATTR void vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { 970 vulkan::api::GetData(commandBuffer).dispatch.CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); 971} 972 973__attribute__((visibility("default"))) 974VKAPI_ATTR void vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) { 975 vulkan::api::GetData(commandBuffer).dispatch.CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); 976} 977 978__attribute__((visibility("default"))) 979VKAPI_ATTR void vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) { 980 vulkan::api::GetData(commandBuffer).dispatch.CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); 981} 982 983__attribute__((visibility("default"))) 984VKAPI_ATTR void vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { 985 vulkan::api::GetData(commandBuffer).dispatch.CmdSetLineWidth(commandBuffer, lineWidth); 986} 987 988__attribute__((visibility("default"))) 989VKAPI_ATTR void vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) { 990 vulkan::api::GetData(commandBuffer).dispatch.CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); 991} 992 993__attribute__((visibility("default"))) 994VKAPI_ATTR void vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) { 995 vulkan::api::GetData(commandBuffer).dispatch.CmdSetBlendConstants(commandBuffer, blendConstants); 996} 997 998__attribute__((visibility("default"))) 999VKAPI_ATTR void vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) { 1000 vulkan::api::GetData(commandBuffer).dispatch.CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); 1001} 1002 1003__attribute__((visibility("default"))) 1004VKAPI_ATTR void vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) { 1005 vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); 1006} 1007 1008__attribute__((visibility("default"))) 1009VKAPI_ATTR void vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) { 1010 vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); 1011} 1012 1013__attribute__((visibility("default"))) 1014VKAPI_ATTR void vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) { 1015 vulkan::api::GetData(commandBuffer).dispatch.CmdSetStencilReference(commandBuffer, faceMask, reference); 1016} 1017 1018__attribute__((visibility("default"))) 1019VKAPI_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) { 1020 vulkan::api::GetData(commandBuffer).dispatch.CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 1021} 1022 1023__attribute__((visibility("default"))) 1024VKAPI_ATTR void vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) { 1025 vulkan::api::GetData(commandBuffer).dispatch.CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); 1026} 1027 1028__attribute__((visibility("default"))) 1029VKAPI_ATTR void vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) { 1030 vulkan::api::GetData(commandBuffer).dispatch.CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); 1031} 1032 1033__attribute__((visibility("default"))) 1034VKAPI_ATTR void vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) { 1035 vulkan::api::GetData(commandBuffer).dispatch.CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); 1036} 1037 1038__attribute__((visibility("default"))) 1039VKAPI_ATTR void vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) { 1040 vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); 1041} 1042 1043__attribute__((visibility("default"))) 1044VKAPI_ATTR void vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { 1045 vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); 1046} 1047 1048__attribute__((visibility("default"))) 1049VKAPI_ATTR void vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { 1050 vulkan::api::GetData(commandBuffer).dispatch.CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); 1051} 1052 1053__attribute__((visibility("default"))) 1054VKAPI_ATTR void vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) { 1055 vulkan::api::GetData(commandBuffer).dispatch.CmdDispatch(commandBuffer, x, y, z); 1056} 1057 1058__attribute__((visibility("default"))) 1059VKAPI_ATTR void vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) { 1060 vulkan::api::GetData(commandBuffer).dispatch.CmdDispatchIndirect(commandBuffer, buffer, offset); 1061} 1062 1063__attribute__((visibility("default"))) 1064VKAPI_ATTR void vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) { 1065 vulkan::api::GetData(commandBuffer).dispatch.CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); 1066} 1067 1068__attribute__((visibility("default"))) 1069VKAPI_ATTR void vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) { 1070 vulkan::api::GetData(commandBuffer).dispatch.CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1071} 1072 1073__attribute__((visibility("default"))) 1074VKAPI_ATTR void vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) { 1075 vulkan::api::GetData(commandBuffer).dispatch.CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); 1076} 1077 1078__attribute__((visibility("default"))) 1079VKAPI_ATTR void vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) { 1080 vulkan::api::GetData(commandBuffer).dispatch.CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); 1081} 1082 1083__attribute__((visibility("default"))) 1084VKAPI_ATTR void vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) { 1085 vulkan::api::GetData(commandBuffer).dispatch.CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); 1086} 1087 1088__attribute__((visibility("default"))) 1089VKAPI_ATTR void vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) { 1090 vulkan::api::GetData(commandBuffer).dispatch.CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); 1091} 1092 1093__attribute__((visibility("default"))) 1094VKAPI_ATTR void vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { 1095 vulkan::api::GetData(commandBuffer).dispatch.CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); 1096} 1097 1098__attribute__((visibility("default"))) 1099VKAPI_ATTR void vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { 1100 vulkan::api::GetData(commandBuffer).dispatch.CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); 1101} 1102 1103__attribute__((visibility("default"))) 1104VKAPI_ATTR void vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) { 1105 vulkan::api::GetData(commandBuffer).dispatch.CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); 1106} 1107 1108__attribute__((visibility("default"))) 1109VKAPI_ATTR void vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) { 1110 vulkan::api::GetData(commandBuffer).dispatch.CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); 1111} 1112 1113__attribute__((visibility("default"))) 1114VKAPI_ATTR void vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) { 1115 vulkan::api::GetData(commandBuffer).dispatch.CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1116} 1117 1118__attribute__((visibility("default"))) 1119VKAPI_ATTR void vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { 1120 vulkan::api::GetData(commandBuffer).dispatch.CmdSetEvent(commandBuffer, event, stageMask); 1121} 1122 1123__attribute__((visibility("default"))) 1124VKAPI_ATTR void vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) { 1125 vulkan::api::GetData(commandBuffer).dispatch.CmdResetEvent(commandBuffer, event, stageMask); 1126} 1127 1128__attribute__((visibility("default"))) 1129VKAPI_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) { 1130 vulkan::api::GetData(commandBuffer).dispatch.CmdWaitEvents(commandBuffer, eventCount, pEvents, srcStageMask, dstStageMask, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 1131} 1132 1133__attribute__((visibility("default"))) 1134VKAPI_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) { 1135 vulkan::api::GetData(commandBuffer).dispatch.CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 1136} 1137 1138__attribute__((visibility("default"))) 1139VKAPI_ATTR void vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query, VkQueryControlFlags flags) { 1140 vulkan::api::GetData(commandBuffer).dispatch.CmdBeginQuery(commandBuffer, queryPool, query, flags); 1141} 1142 1143__attribute__((visibility("default"))) 1144VKAPI_ATTR void vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t query) { 1145 vulkan::api::GetData(commandBuffer).dispatch.CmdEndQuery(commandBuffer, queryPool, query); 1146} 1147 1148__attribute__((visibility("default"))) 1149VKAPI_ATTR void vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) { 1150 vulkan::api::GetData(commandBuffer).dispatch.CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); 1151} 1152 1153__attribute__((visibility("default"))) 1154VKAPI_ATTR void vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t query) { 1155 vulkan::api::GetData(commandBuffer).dispatch.CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, query); 1156} 1157 1158__attribute__((visibility("default"))) 1159VKAPI_ATTR void vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkQueryResultFlags flags) { 1160 vulkan::api::GetData(commandBuffer).dispatch.CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); 1161} 1162 1163__attribute__((visibility("default"))) 1164VKAPI_ATTR void vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) { 1165 vulkan::api::GetData(commandBuffer).dispatch.CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); 1166} 1167 1168__attribute__((visibility("default"))) 1169VKAPI_ATTR void vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) { 1170 vulkan::api::GetData(commandBuffer).dispatch.CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); 1171} 1172 1173__attribute__((visibility("default"))) 1174VKAPI_ATTR void vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { 1175 vulkan::api::GetData(commandBuffer).dispatch.CmdNextSubpass(commandBuffer, contents); 1176} 1177 1178__attribute__((visibility("default"))) 1179VKAPI_ATTR void vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { 1180 vulkan::api::GetData(commandBuffer).dispatch.CmdEndRenderPass(commandBuffer); 1181} 1182 1183__attribute__((visibility("default"))) 1184VKAPI_ATTR void vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBufferCount, const VkCommandBuffer* pCommandBuffers) { 1185 vulkan::api::GetData(commandBuffer).dispatch.CmdExecuteCommands(commandBuffer, commandBufferCount, pCommandBuffers); 1186} 1187 1188__attribute__((visibility("default"))) 1189VKAPI_ATTR void vkDestroySurfaceKHR(VkInstance instance, VkSurfaceKHR surface, const VkAllocationCallbacks* pAllocator) { 1190 vulkan::api::GetData(instance).dispatch.DestroySurfaceKHR(instance, surface, pAllocator); 1191} 1192 1193__attribute__((visibility("default"))) 1194VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceSupportKHR(VkPhysicalDevice physicalDevice, uint32_t queueFamilyIndex, VkSurfaceKHR surface, VkBool32* pSupported) { 1195 return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceSupportKHR(physicalDevice, queueFamilyIndex, surface, pSupported); 1196} 1197 1198__attribute__((visibility("default"))) 1199VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceCapabilitiesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilitiesKHR* pSurfaceCapabilities) { 1200 return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceCapabilitiesKHR(physicalDevice, surface, pSurfaceCapabilities); 1201} 1202 1203__attribute__((visibility("default"))) 1204VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfaceFormatsKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pSurfaceFormatCount, VkSurfaceFormatKHR* pSurfaceFormats) { 1205 return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfaceFormatsKHR(physicalDevice, surface, pSurfaceFormatCount, pSurfaceFormats); 1206} 1207 1208__attribute__((visibility("default"))) 1209VKAPI_ATTR VkResult vkGetPhysicalDeviceSurfacePresentModesKHR(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, uint32_t* pPresentModeCount, VkPresentModeKHR* pPresentModes) { 1210 return vulkan::api::GetData(physicalDevice).dispatch.GetPhysicalDeviceSurfacePresentModesKHR(physicalDevice, surface, pPresentModeCount, pPresentModes); 1211} 1212 1213__attribute__((visibility("default"))) 1214VKAPI_ATTR VkResult vkCreateSwapchainKHR(VkDevice device, const VkSwapchainCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSwapchainKHR* pSwapchain) { 1215 return vulkan::api::GetData(device).dispatch.CreateSwapchainKHR(device, pCreateInfo, pAllocator, pSwapchain); 1216} 1217 1218__attribute__((visibility("default"))) 1219VKAPI_ATTR void vkDestroySwapchainKHR(VkDevice device, VkSwapchainKHR swapchain, const VkAllocationCallbacks* pAllocator) { 1220 vulkan::api::GetData(device).dispatch.DestroySwapchainKHR(device, swapchain, pAllocator); 1221} 1222 1223__attribute__((visibility("default"))) 1224VKAPI_ATTR VkResult vkGetSwapchainImagesKHR(VkDevice device, VkSwapchainKHR swapchain, uint32_t* pSwapchainImageCount, VkImage* pSwapchainImages) { 1225 return vulkan::api::GetData(device).dispatch.GetSwapchainImagesKHR(device, swapchain, pSwapchainImageCount, pSwapchainImages); 1226} 1227 1228__attribute__((visibility("default"))) 1229VKAPI_ATTR VkResult vkAcquireNextImageKHR(VkDevice device, VkSwapchainKHR swapchain, uint64_t timeout, VkSemaphore semaphore, VkFence fence, uint32_t* pImageIndex) { 1230 return vulkan::api::GetData(device).dispatch.AcquireNextImageKHR(device, swapchain, timeout, semaphore, fence, pImageIndex); 1231} 1232 1233__attribute__((visibility("default"))) 1234VKAPI_ATTR VkResult vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR* pPresentInfo) { 1235 return vulkan::api::GetData(queue).dispatch.QueuePresentKHR(queue, pPresentInfo); 1236} 1237 1238__attribute__((visibility("default"))) 1239VKAPI_ATTR VkResult vkCreateAndroidSurfaceKHR(VkInstance instance, const VkAndroidSurfaceCreateInfoKHR* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSurfaceKHR* pSurface) { 1240 return vulkan::api::GetData(instance).dispatch.CreateAndroidSurfaceKHR(instance, pCreateInfo, pAllocator, pSurface); 1241} 1242 1243// clang-format on 1244