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