api_gen.cpp revision 0c2032490b80178ec823bf22a7f5d08398851cc3 
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
1171