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