trampoline.c revision 2954dae5bddd8d0686e5baff6f4f3dc7b4e3d2bc 
1/*
2 *
3 * Copyright (C) 2015 Valve Corporation
4 * Copyright (C) 2015 Google Inc.
5 *
6 * Permission is hereby granted, free of charge, to any person obtaining a
7 * copy of this software and associated documentation files (the "Software"),
8 * to deal in the Software without restriction, including without limitation
9 * the rights to use, copy, modify, merge, publish, distribute, sublicense,
10 * and/or sell copies of the Software, and to permit persons to whom the
11 * Software is furnished to do so, subject to the following conditions:
12 *
13 * The above copyright notice and this permission notice shall be included
14 * in all copies or substantial portions of the Software.
15 *
16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.  IN NO EVENT SHALL
19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING
21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER
22 * DEALINGS IN THE SOFTWARE.
23 *
24 * Author: Chris Forbes <chrisf@ijw.co.nz>
25 * Author: Cody Northrop <cody@lunarg.com>
26 * Author: Jon Ashburn <jon@lunarg.com>
27 * Author: Tony Barbour <tony@LunarG.com>
28 */
29#define _GNU_SOURCE
30#include <stdlib.h>
31#include <string.h>
32
33#include "vk_loader_platform.h"
34#include "loader.h"
35#include "debug_report.h"
36#include "wsi.h"
37
38
39/* Trampoline entrypoints */
40LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance(
41        const VkInstanceCreateInfo* pCreateInfo,
42        const VkAllocationCallbacks* pAllocator,
43        VkInstance* pInstance)
44{
45    struct loader_instance *ptr_instance = NULL;
46    VkResult res = VK_ERROR_INITIALIZATION_FAILED;
47    VkDebugReportCallbackEXT instance_callback = VK_NULL_HANDLE;
48    void *pNext = (void *) pCreateInfo->pNext;
49
50    loader_platform_thread_once(&once_init, loader_initialize);
51
52    if (pAllocator) {
53        ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation(
54                           pAllocator->pUserData,
55                           sizeof(struct loader_instance),
56                           sizeof(int *),
57                           VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
58    } else {
59        ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance));
60    }
61    if (ptr_instance == NULL) {
62        return VK_ERROR_OUT_OF_HOST_MEMORY;
63    }
64
65    tls_instance = ptr_instance;
66    loader_platform_thread_lock_mutex(&loader_lock);
67    memset(ptr_instance, 0, sizeof(struct loader_instance));
68
69    if (pAllocator) {
70        ptr_instance->alloc_callbacks = *pAllocator;
71    }
72
73    /*
74     * Look for a debug report create info structure
75     * and setup a callback if found.
76     */
77    while (pNext) {
78        if (((VkInstanceCreateInfo *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
79            instance_callback = (VkDebugReportCallbackEXT) ptr_instance;
80            if (util_CreateDebugReportCallback(ptr_instance, pNext, pAllocator, instance_callback)) {
81                loader_heap_free(ptr_instance, ptr_instance);
82                loader_platform_thread_unlock_mutex(&loader_lock);
83                return VK_ERROR_OUT_OF_HOST_MEMORY;
84            }
85        }
86        pNext = (void *) ((VkInstanceCreateInfo *)pNext)->pNext;
87    }
88
89    /* Due to implicit layers need to get layer list even if
90     * enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
91     * get layer list (both instance and device) via loader_layer_scan(). */
92    memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list));
93    memset(&ptr_instance->device_layer_list, 0, sizeof(ptr_instance->device_layer_list));
94    loader_layer_scan(ptr_instance,
95                      &ptr_instance->instance_layer_list,
96                      &ptr_instance->device_layer_list);
97
98    /* validate the app requested layers to be enabled */
99    if (pCreateInfo->enabledLayerCount > 0) {
100        res = loader_validate_layers(pCreateInfo->enabledLayerCount,
101                                     pCreateInfo->ppEnabledLayerNames,
102                                     &ptr_instance->instance_layer_list);
103        if (res != VK_SUCCESS) {
104            util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator);
105            loader_heap_free(ptr_instance, ptr_instance);
106            loader_platform_thread_unlock_mutex(&loader_lock);
107            return res;
108        }
109    }
110
111    /* Scan/discover all ICD libraries */
112    memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
113    loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
114
115    /* get extensions from all ICD's, merge so no duplicates, then validate */
116    loader_get_icd_loader_instance_extensions(ptr_instance,
117                                              &ptr_instance->icd_libs,
118                                              &ptr_instance->ext_list);
119    res = loader_validate_instance_extensions(&ptr_instance->ext_list,
120                                              &ptr_instance->instance_layer_list,
121                                              pCreateInfo);
122    if (res != VK_SUCCESS) {
123        loader_delete_layer_properties(ptr_instance,
124                                       &ptr_instance->device_layer_list);
125        loader_delete_layer_properties(ptr_instance,
126                                       &ptr_instance->instance_layer_list);
127        loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
128        loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)
129                                    &ptr_instance->ext_list);
130        util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator);
131        loader_platform_thread_unlock_mutex(&loader_lock);
132        loader_heap_free(ptr_instance, ptr_instance);
133        return res;
134    }
135
136    ptr_instance->disp = loader_heap_alloc(
137                             ptr_instance,
138                             sizeof(VkLayerInstanceDispatchTable),
139                             VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
140    if (ptr_instance->disp == NULL) {
141        loader_delete_layer_properties(ptr_instance,
142                                       &ptr_instance->device_layer_list);
143        loader_delete_layer_properties(ptr_instance,
144                                       &ptr_instance->instance_layer_list);
145        loader_scanned_icd_clear(ptr_instance,
146                                 &ptr_instance->icd_libs);
147        loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)
148                                &ptr_instance->ext_list);
149        util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator);
150        loader_platform_thread_unlock_mutex(&loader_lock);
151        loader_heap_free(ptr_instance, ptr_instance);
152        return VK_ERROR_OUT_OF_HOST_MEMORY;
153    }
154    memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp));
155    ptr_instance->next = loader.instances;
156    loader.instances = ptr_instance;
157
158    /* activate any layers on instance chain */
159    res = loader_enable_instance_layers(ptr_instance,
160                                        pCreateInfo,
161                                        &ptr_instance->instance_layer_list);
162    if (res != VK_SUCCESS) {
163        loader_delete_layer_properties(ptr_instance,
164                                       &ptr_instance->device_layer_list);
165        loader_delete_layer_properties(ptr_instance,
166                                       &ptr_instance->instance_layer_list);
167        loader_scanned_icd_clear(ptr_instance,
168                                 &ptr_instance->icd_libs);
169        loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *)
170                                &ptr_instance->ext_list);
171        loader.instances = ptr_instance->next;
172        util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator);
173        loader_platform_thread_unlock_mutex(&loader_lock);
174        loader_heap_free(ptr_instance, ptr_instance->disp);
175        loader_heap_free(ptr_instance, ptr_instance);
176        return res;
177    }
178    loader_activate_instance_layers(ptr_instance);
179
180    wsi_create_instance(ptr_instance, pCreateInfo);
181    debug_report_create_instance(ptr_instance, pCreateInfo);
182
183
184    *pInstance = (VkInstance) ptr_instance;
185
186    res = ptr_instance->disp->CreateInstance(pCreateInfo, pAllocator, pInstance);
187
188    /*
189     * Finally have the layers in place and everyone has seen
190     * the CreateInstance command go by. This allows the layer's
191     * GetInstanceProcAddr functions to return valid extension functions
192     * if enabled.
193     */
194    loader_activate_instance_layer_extensions(ptr_instance, *pInstance);
195    /* Remove temporary debug_report callback */
196    util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator);
197
198    loader_platform_thread_unlock_mutex(&loader_lock);
199    return res;
200}
201
202LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance(
203                                            VkInstance instance,
204                                            const VkAllocationCallbacks* pAllocator)
205{
206    const VkLayerInstanceDispatchTable *disp;
207    struct loader_instance *ptr_instance = NULL;
208    disp = loader_get_instance_dispatch(instance);
209
210    loader_platform_thread_lock_mutex(&loader_lock);
211
212    /* TODO: Do we need a temporary callback here to catch cleanup issues? */
213
214    ptr_instance = loader_get_instance(instance);
215    disp->DestroyInstance(instance, pAllocator);
216
217    loader_deactivate_instance_layers(ptr_instance);
218    loader_heap_free(ptr_instance, ptr_instance->disp);
219    loader_heap_free(ptr_instance, ptr_instance);
220    loader_platform_thread_unlock_mutex(&loader_lock);
221}
222
223LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices(
224                                            VkInstance instance,
225                                            uint32_t* pPhysicalDeviceCount,
226                                            VkPhysicalDevice* pPhysicalDevices)
227{
228    const VkLayerInstanceDispatchTable *disp;
229    VkResult res;
230    disp = loader_get_instance_dispatch(instance);
231
232    loader_platform_thread_lock_mutex(&loader_lock);
233    res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
234                                         pPhysicalDevices);
235    loader_platform_thread_unlock_mutex(&loader_lock);
236    return res;
237}
238
239LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures(
240                                            VkPhysicalDevice gpu,
241                                            VkPhysicalDeviceFeatures *pFeatures)
242{
243    const VkLayerInstanceDispatchTable *disp;
244
245    disp = loader_get_instance_dispatch(gpu);
246    disp->GetPhysicalDeviceFeatures(gpu, pFeatures);
247}
248
249LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties(
250                                            VkPhysicalDevice gpu,
251                                            VkFormat format,
252                                            VkFormatProperties *pFormatInfo)
253{
254    const VkLayerInstanceDispatchTable *disp;
255
256    disp = loader_get_instance_dispatch(gpu);
257    disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
258}
259
260LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
261{
262    const VkLayerInstanceDispatchTable *disp;
263
264    disp = loader_get_instance_dispatch(physicalDevice);
265    return disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
266}
267
268LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties(
269                                            VkPhysicalDevice gpu,
270                                            VkPhysicalDeviceProperties* pProperties)
271{
272    const VkLayerInstanceDispatchTable *disp;
273
274    disp = loader_get_instance_dispatch(gpu);
275    disp->GetPhysicalDeviceProperties(gpu, pProperties);
276}
277
278LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties(
279                                            VkPhysicalDevice gpu,
280                                            uint32_t* pQueueFamilyPropertyCount,
281                                            VkQueueFamilyProperties* pQueueProperties)
282{
283    const VkLayerInstanceDispatchTable *disp;
284
285    disp = loader_get_instance_dispatch(gpu);
286    disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pQueueFamilyPropertyCount, pQueueProperties);
287}
288
289LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
290                                            VkPhysicalDevice gpu,
291                                            VkPhysicalDeviceMemoryProperties* pMemoryProperties)
292{
293    const VkLayerInstanceDispatchTable *disp;
294
295    disp = loader_get_instance_dispatch(gpu);
296    disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
297}
298
299LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice(
300        VkPhysicalDevice gpu,
301        const VkDeviceCreateInfo* pCreateInfo,
302        const VkAllocationCallbacks* pAllocator,
303        VkDevice* pDevice)
304{
305    VkResult res;
306
307    loader_platform_thread_lock_mutex(&loader_lock);
308
309    res = loader_CreateDevice(gpu, pCreateInfo, pAllocator, pDevice);
310
311    loader_platform_thread_unlock_mutex(&loader_lock);
312    return res;
313}
314
315LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator)
316{
317    const VkLayerDispatchTable *disp;
318    struct loader_device *dev;
319    struct loader_icd *icd = loader_get_icd_and_device(device, &dev);
320    const struct loader_instance *inst = icd->this_instance;
321    disp = loader_get_dispatch(device);
322
323    loader_platform_thread_lock_mutex(&loader_lock);
324    disp->DestroyDevice(device, pAllocator);
325    dev->device = NULL;
326    loader_remove_logical_device(inst, icd, dev);
327
328    loader_platform_thread_unlock_mutex(&loader_lock);
329}
330
331LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties(
332    VkPhysicalDevice                            physicalDevice,
333    const char*                                 pLayerName,
334    uint32_t*                                   pPropertyCount,
335    VkExtensionProperties*                      pProperties)
336{
337    VkResult res;
338
339    loader_platform_thread_lock_mutex(&loader_lock);
340
341    /* If pLayerName == NULL, then querying ICD extensions, pass this call
342       down the instance chain which will terminate in the ICD. This allows
343       layers to filter the extensions coming back up the chain.
344       If pLayerName != NULL then get layer extensions from manifest file.  */
345    if (pLayerName == NULL  || strlen(pLayerName) == 0) {
346        const VkLayerInstanceDispatchTable *disp;
347
348        disp = loader_get_instance_dispatch(physicalDevice);
349        res = disp->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pPropertyCount, pProperties);
350    } else {
351        res = loader_EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties);
352    }
353
354    loader_platform_thread_unlock_mutex(&loader_lock);
355    return res;
356}
357
358LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties(
359    VkPhysicalDevice                            physicalDevice,
360    uint32_t*                                   pPropertyCount,
361    VkLayerProperties*                          pProperties)
362{
363    VkResult res;
364
365    loader_platform_thread_lock_mutex(&loader_lock);
366
367    /* Don't dispatch this call down the instance chain, want all device layers
368       enumerated and instance chain may not contain all device layers */
369    res = loader_EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties);
370    loader_platform_thread_unlock_mutex(&loader_lock);
371    return res;
372}
373
374LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue)
375{
376    const VkLayerDispatchTable *disp;
377
378    disp = loader_get_dispatch(device);
379
380    disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
381    loader_set_dispatch(*pQueue, disp);
382}
383
384LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence)
385{
386    const VkLayerDispatchTable *disp;
387
388    disp = loader_get_dispatch(queue);
389
390    return disp->QueueSubmit(queue, submitCount, pSubmits, fence);
391}
392
393LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue)
394{
395    const VkLayerDispatchTable *disp;
396
397    disp = loader_get_dispatch(queue);
398
399    return disp->QueueWaitIdle(queue);
400}
401
402LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device)
403{
404    const VkLayerDispatchTable *disp;
405
406    disp = loader_get_dispatch(device);
407
408    return disp->DeviceWaitIdle(device);
409}
410
411LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory)
412{
413    const VkLayerDispatchTable *disp;
414
415    disp = loader_get_dispatch(device);
416
417    return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
418}
419
420LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* pAllocator)
421{
422    const VkLayerDispatchTable *disp;
423
424    disp = loader_get_dispatch(device);
425
426    disp->FreeMemory(device, mem, pAllocator);
427}
428
429LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData)
430{
431    const VkLayerDispatchTable *disp;
432
433    disp = loader_get_dispatch(device);
434
435    return disp->MapMemory(device, mem, offset, size, flags, ppData);
436}
437
438LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem)
439{
440    const VkLayerDispatchTable *disp;
441
442    disp = loader_get_dispatch(device);
443
444    disp->UnmapMemory(device, mem);
445}
446
447LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
448{
449    const VkLayerDispatchTable *disp;
450
451    disp = loader_get_dispatch(device);
452
453    return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
454}
455
456LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges)
457{
458    const VkLayerDispatchTable *disp;
459
460    disp = loader_get_dispatch(device);
461
462    return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges);
463}
464
465LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
466{
467    const VkLayerDispatchTable *disp;
468
469    disp = loader_get_dispatch(device);
470
471    disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
472}
473
474LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset)
475{
476    const VkLayerDispatchTable *disp;
477
478    disp = loader_get_dispatch(device);
479
480    return disp->BindBufferMemory(device, buffer, mem, offset);
481}
482
483LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize offset)
484{
485    const VkLayerDispatchTable *disp;
486
487    disp = loader_get_dispatch(device);
488
489    return disp->BindImageMemory(device, image, mem, offset);
490}
491
492LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
493{
494    const VkLayerDispatchTable *disp;
495
496    disp = loader_get_dispatch(device);
497
498    disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
499}
500
501LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
502{
503    const VkLayerDispatchTable *disp;
504
505    disp = loader_get_dispatch(device);
506
507    disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
508}
509
510LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
511{
512    const VkLayerDispatchTable *disp;
513
514    disp = loader_get_dispatch(device);
515
516    disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements);
517}
518
519LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties)
520{
521    const VkLayerInstanceDispatchTable *disp;
522
523    disp = loader_get_instance_dispatch(physicalDevice);
524
525    disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties);
526}
527
528LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence)
529{
530    const VkLayerDispatchTable *disp;
531
532    disp = loader_get_dispatch(queue);
533
534    return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
535}
536
537LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence)
538{
539    const VkLayerDispatchTable *disp;
540
541    disp = loader_get_dispatch(device);
542
543    return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
544}
545
546LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator)
547{
548    const VkLayerDispatchTable *disp;
549
550    disp = loader_get_dispatch(device);
551
552    disp->DestroyFence(device, fence, pAllocator);
553}
554
555LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
556{
557    const VkLayerDispatchTable *disp;
558
559    disp = loader_get_dispatch(device);
560
561    return disp->ResetFences(device, fenceCount, pFences);
562}
563
564LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence)
565{
566    const VkLayerDispatchTable *disp;
567
568    disp = loader_get_dispatch(device);
569
570    return disp->GetFenceStatus(device, fence);
571}
572
573LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
574{
575    const VkLayerDispatchTable *disp;
576
577    disp = loader_get_dispatch(device);
578
579    return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
580}
581
582LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore)
583{
584    const VkLayerDispatchTable *disp;
585
586    disp = loader_get_dispatch(device);
587
588    return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
589}
590
591LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator)
592{
593    const VkLayerDispatchTable *disp;
594
595    disp = loader_get_dispatch(device);
596
597    disp->DestroySemaphore(device, semaphore, pAllocator);
598}
599
600LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent)
601{
602    const VkLayerDispatchTable *disp;
603
604    disp = loader_get_dispatch(device);
605
606    return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
607}
608
609LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator)
610{
611    const VkLayerDispatchTable *disp;
612
613    disp = loader_get_dispatch(device);
614
615    disp->DestroyEvent(device, event, pAllocator);
616}
617
618LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event)
619{
620    const VkLayerDispatchTable *disp;
621
622    disp = loader_get_dispatch(device);
623
624    return disp->GetEventStatus(device, event);
625}
626
627LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event)
628{
629    const VkLayerDispatchTable *disp;
630
631    disp = loader_get_dispatch(device);
632
633    return disp->SetEvent(device, event);
634}
635
636LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event)
637{
638    const VkLayerDispatchTable *disp;
639
640    disp = loader_get_dispatch(device);
641
642    return disp->ResetEvent(device, event);
643}
644
645LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool)
646{
647    const VkLayerDispatchTable *disp;
648
649    disp = loader_get_dispatch(device);
650
651    return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
652}
653
654LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator)
655{
656    const VkLayerDispatchTable *disp;
657
658    disp = loader_get_dispatch(device);
659
660    disp->DestroyQueryPool(device, queryPool, pAllocator);
661}
662
663LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags)
664{
665    const VkLayerDispatchTable *disp;
666
667    disp = loader_get_dispatch(device);
668
669    return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags);
670}
671
672LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer)
673{
674    const VkLayerDispatchTable *disp;
675
676    disp = loader_get_dispatch(device);
677
678    return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
679}
680
681LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator)
682{
683    const VkLayerDispatchTable *disp;
684
685    disp = loader_get_dispatch(device);
686
687    disp->DestroyBuffer(device, buffer, pAllocator);
688}
689
690LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView)
691{
692    const VkLayerDispatchTable *disp;
693
694    disp = loader_get_dispatch(device);
695
696    return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
697}
698
699LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator)
700{
701    const VkLayerDispatchTable *disp;
702
703    disp = loader_get_dispatch(device);
704
705    disp->DestroyBufferView(device, bufferView, pAllocator);
706}
707
708LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage)
709{
710    const VkLayerDispatchTable *disp;
711
712    disp = loader_get_dispatch(device);
713
714    return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
715}
716
717LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator)
718{
719    const VkLayerDispatchTable *disp;
720
721    disp = loader_get_dispatch(device);
722
723    disp->DestroyImage(device, image, pAllocator);
724}
725
726LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
727{
728    const VkLayerDispatchTable *disp;
729
730    disp = loader_get_dispatch(device);
731
732    disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
733}
734
735LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView)
736{
737    const VkLayerDispatchTable *disp;
738
739    disp = loader_get_dispatch(device);
740
741    return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
742}
743
744LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator)
745{
746    const VkLayerDispatchTable *disp;
747
748    disp = loader_get_dispatch(device);
749
750    disp->DestroyImageView(device, imageView, pAllocator);
751}
752
753LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShader)
754{
755    const VkLayerDispatchTable *disp;
756
757    disp = loader_get_dispatch(device);
758
759    return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
760}
761
762LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator)
763{
764    const VkLayerDispatchTable *disp;
765
766    disp = loader_get_dispatch(device);
767
768    disp->DestroyShaderModule(device, shaderModule, pAllocator);
769}
770
771LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache)
772{
773    const VkLayerDispatchTable *disp;
774
775    disp = loader_get_dispatch(device);
776
777    return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache);
778}
779
780LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator)
781{
782    const VkLayerDispatchTable *disp;
783
784    disp = loader_get_dispatch(device);
785
786    disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
787}
788
789LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData)
790{
791    const VkLayerDispatchTable *disp;
792
793    disp = loader_get_dispatch(device);
794
795    return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
796}
797
798LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
799{
800    const VkLayerDispatchTable *disp;
801
802    disp = loader_get_dispatch(device);
803
804    return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches);
805}
806
807LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
808{
809    const VkLayerDispatchTable *disp;
810
811    disp = loader_get_dispatch(device);
812
813    return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
814}
815
816LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines)
817{
818    const VkLayerDispatchTable *disp;
819
820    disp = loader_get_dispatch(device);
821
822    return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines);
823}
824
825LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator)
826{
827    const VkLayerDispatchTable *disp;
828
829    disp = loader_get_dispatch(device);
830
831    disp->DestroyPipeline(device, pipeline, pAllocator);
832}
833
834LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout)
835{
836    const VkLayerDispatchTable *disp;
837
838    disp = loader_get_dispatch(device);
839
840    return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout);
841}
842
843LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator)
844{
845    const VkLayerDispatchTable *disp;
846
847    disp = loader_get_dispatch(device);
848
849    disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
850}
851
852LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler)
853{
854    const VkLayerDispatchTable *disp;
855
856    disp = loader_get_dispatch(device);
857
858    return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
859}
860
861LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator)
862{
863    const VkLayerDispatchTable *disp;
864
865    disp = loader_get_dispatch(device);
866
867    disp->DestroySampler(device, sampler, pAllocator);
868}
869
870
871LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout)
872{
873    const VkLayerDispatchTable *disp;
874
875    disp = loader_get_dispatch(device);
876
877    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout);
878}
879
880LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator)
881{
882    const VkLayerDispatchTable *disp;
883
884    disp = loader_get_dispatch(device);
885
886    disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
887}
888
889LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool)
890{
891    const VkLayerDispatchTable *disp;
892
893    disp = loader_get_dispatch(device);
894
895    return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool);
896}
897
898LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator)
899{
900    const VkLayerDispatchTable *disp;
901
902    disp = loader_get_dispatch(device);
903
904    disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
905}
906
907
908LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags)
909{
910    const VkLayerDispatchTable *disp;
911
912    disp = loader_get_dispatch(device);
913
914    return disp->ResetDescriptorPool(device, descriptorPool, flags);
915}
916
917LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets)
918{
919    const VkLayerDispatchTable *disp;
920
921    disp = loader_get_dispatch(device);
922
923    return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
924}
925
926LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets)
927{
928    const VkLayerDispatchTable *disp;
929
930    disp = loader_get_dispatch(device);
931
932    return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets);
933}
934
935LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies)
936{
937    const VkLayerDispatchTable *disp;
938
939    disp = loader_get_dispatch(device);
940
941    disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies);
942}
943
944LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer)
945{
946    const VkLayerDispatchTable *disp;
947
948    disp = loader_get_dispatch(device);
949
950    return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer);
951}
952
953LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator)
954{
955    const VkLayerDispatchTable *disp;
956
957    disp = loader_get_dispatch(device);
958
959    disp->DestroyFramebuffer(device, framebuffer, pAllocator);
960}
961
962LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass)
963{
964    const VkLayerDispatchTable *disp;
965
966    disp = loader_get_dispatch(device);
967
968    return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
969}
970
971LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator)
972{
973    const VkLayerDispatchTable *disp;
974
975    disp = loader_get_dispatch(device);
976
977    disp->DestroyRenderPass(device, renderPass, pAllocator);
978}
979
980LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
981{
982    const VkLayerDispatchTable *disp;
983
984    disp = loader_get_dispatch(device);
985
986    disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
987}
988
989LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool)
990{
991    const VkLayerDispatchTable *disp;
992
993    disp = loader_get_dispatch(device);
994
995    return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool);
996}
997
998LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator)
999{
1000    const VkLayerDispatchTable *disp;
1001
1002    disp = loader_get_dispatch(device);
1003
1004    disp->DestroyCommandPool(device, commandPool, pAllocator);
1005}
1006
1007LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags)
1008{
1009    const VkLayerDispatchTable *disp;
1010
1011    disp = loader_get_dispatch(device);
1012
1013    return disp->ResetCommandPool(device, commandPool, flags);
1014}
1015
1016LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers(
1017        VkDevice device,
1018        const VkCommandBufferAllocateInfo* pAllocateInfo,
1019        VkCommandBuffer* pCommandBuffers)
1020{
1021    const VkLayerDispatchTable *disp;
1022    VkResult res;
1023
1024    disp = loader_get_dispatch(device);
1025
1026    res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
1027    if (res == VK_SUCCESS) {
1028        for (uint32_t i =0; i < pAllocateInfo->commandBufferCount; i++) {
1029            if (pCommandBuffers[i]) {
1030                loader_init_dispatch(pCommandBuffers[i], disp);
1031            }
1032        }
1033    }
1034
1035    return res;
1036}
1037
1038LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers(
1039        VkDevice                                device,
1040        VkCommandPool                               commandPool,
1041        uint32_t                                commandBufferCount,
1042        const VkCommandBuffer*                      pCommandBuffers)
1043{
1044    const VkLayerDispatchTable *disp;
1045
1046    disp = loader_get_dispatch(device);
1047
1048    disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers);
1049}
1050
1051LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo)
1052{
1053    const VkLayerDispatchTable *disp;
1054
1055    disp = loader_get_dispatch(commandBuffer);
1056
1057    return disp->BeginCommandBuffer(commandBuffer, pBeginInfo);
1058}
1059
1060LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer)
1061{
1062    const VkLayerDispatchTable *disp;
1063
1064    disp = loader_get_dispatch(commandBuffer);
1065
1066    return disp->EndCommandBuffer(commandBuffer);
1067}
1068
1069LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags)
1070{
1071    const VkLayerDispatchTable *disp;
1072
1073    disp = loader_get_dispatch(commandBuffer);
1074
1075    return disp->ResetCommandBuffer(commandBuffer, flags);
1076}
1077
1078LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
1079{
1080    const VkLayerDispatchTable *disp;
1081
1082    disp = loader_get_dispatch(commandBuffer);
1083
1084    disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
1085}
1086
1087LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports)
1088{
1089    const VkLayerDispatchTable *disp;
1090
1091    disp = loader_get_dispatch(commandBuffer);
1092
1093    disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports);
1094}
1095
1096LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors)
1097{
1098    const VkLayerDispatchTable *disp;
1099
1100    disp = loader_get_dispatch(commandBuffer);
1101
1102    disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
1103}
1104
1105LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth)
1106{
1107    const VkLayerDispatchTable *disp;
1108
1109    disp = loader_get_dispatch(commandBuffer);
1110
1111    disp->CmdSetLineWidth(commandBuffer, lineWidth);
1112}
1113
1114LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor)
1115{
1116    const VkLayerDispatchTable *disp;
1117
1118    disp = loader_get_dispatch(commandBuffer);
1119
1120    disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor);
1121}
1122
1123LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4])
1124{
1125    const VkLayerDispatchTable *disp;
1126
1127    disp = loader_get_dispatch(commandBuffer);
1128
1129    disp->CmdSetBlendConstants(commandBuffer, blendConstants);
1130}
1131
1132LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds)
1133{
1134    const VkLayerDispatchTable *disp;
1135
1136    disp = loader_get_dispatch(commandBuffer);
1137
1138    disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
1139}
1140
1141LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask)
1142{
1143    const VkLayerDispatchTable *disp;
1144
1145    disp = loader_get_dispatch(commandBuffer);
1146
1147    disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
1148}
1149
1150LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask)
1151{
1152    const VkLayerDispatchTable *disp;
1153
1154    disp = loader_get_dispatch(commandBuffer);
1155
1156    disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
1157}
1158
1159LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference)
1160{
1161    const VkLayerDispatchTable *disp;
1162
1163    disp = loader_get_dispatch(commandBuffer);
1164
1165    disp->CmdSetStencilReference(commandBuffer, faceMask, reference);
1166}
1167
1168LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
1169{
1170    const VkLayerDispatchTable *disp;
1171
1172    disp = loader_get_dispatch(commandBuffer);
1173
1174    disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
1175}
1176
1177LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
1178{
1179    const VkLayerDispatchTable *disp;
1180
1181    disp = loader_get_dispatch(commandBuffer);
1182
1183    disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
1184}
1185
1186LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
1187{
1188    const VkLayerDispatchTable *disp;
1189
1190    disp = loader_get_dispatch(commandBuffer);
1191
1192    disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets);
1193}
1194
1195LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance)
1196{
1197    const VkLayerDispatchTable *disp;
1198
1199    disp = loader_get_dispatch(commandBuffer);
1200
1201    disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance);
1202}
1203
1204LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance)
1205{
1206    const VkLayerDispatchTable *disp;
1207
1208    disp = loader_get_dispatch(commandBuffer);
1209
1210    disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance);
1211}
1212
1213LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1214{
1215    const VkLayerDispatchTable *disp;
1216
1217    disp = loader_get_dispatch(commandBuffer);
1218
1219    disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
1220}
1221
1222LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride)
1223{
1224    const VkLayerDispatchTable *disp;
1225
1226    disp = loader_get_dispatch(commandBuffer);
1227
1228    disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride);
1229}
1230
1231LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z)
1232{
1233    const VkLayerDispatchTable *disp;
1234
1235    disp = loader_get_dispatch(commandBuffer);
1236
1237    disp->CmdDispatch(commandBuffer, x, y, z);
1238}
1239
1240LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset)
1241{
1242    const VkLayerDispatchTable *disp;
1243
1244    disp = loader_get_dispatch(commandBuffer);
1245
1246    disp->CmdDispatchIndirect(commandBuffer, buffer, offset);
1247}
1248
1249LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
1250{
1251    const VkLayerDispatchTable *disp;
1252
1253    disp = loader_get_dispatch(commandBuffer);
1254
1255    disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions);
1256}
1257
1258LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
1259{
1260    const VkLayerDispatchTable *disp;
1261
1262    disp = loader_get_dispatch(commandBuffer);
1263
1264    disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1265}
1266
1267LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter)
1268{
1269    const VkLayerDispatchTable *disp;
1270
1271    disp = loader_get_dispatch(commandBuffer);
1272
1273    disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter);
1274}
1275
1276LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
1277{
1278    const VkLayerDispatchTable *disp;
1279
1280    disp = loader_get_dispatch(commandBuffer);
1281
1282    disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions);
1283}
1284
1285LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
1286{
1287    const VkLayerDispatchTable *disp;
1288
1289    disp = loader_get_dispatch(commandBuffer);
1290
1291    disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions);
1292}
1293
1294LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData)
1295{
1296    const VkLayerDispatchTable *disp;
1297
1298    disp = loader_get_dispatch(commandBuffer);
1299
1300    disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
1301}
1302
1303LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data)
1304{
1305    const VkLayerDispatchTable *disp;
1306
1307    disp = loader_get_dispatch(commandBuffer);
1308
1309    disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
1310}
1311
1312LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
1313{
1314    const VkLayerDispatchTable *disp;
1315
1316    disp = loader_get_dispatch(commandBuffer);
1317
1318    disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges);
1319}
1320
1321LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
1322{
1323    const VkLayerDispatchTable *disp;
1324
1325    disp = loader_get_dispatch(commandBuffer);
1326
1327    disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges);
1328}
1329
1330LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects)
1331{
1332    const VkLayerDispatchTable *disp;
1333
1334    disp = loader_get_dispatch(commandBuffer);
1335
1336    disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects);
1337}
1338
1339LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
1340{
1341    const VkLayerDispatchTable *disp;
1342
1343    disp = loader_get_dispatch(commandBuffer);
1344
1345    disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions);
1346}
1347
1348LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1349{
1350    const VkLayerDispatchTable *disp;
1351
1352    disp = loader_get_dispatch(commandBuffer);
1353
1354    disp->CmdSetEvent(commandBuffer, event, stageMask);
1355}
1356
1357LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1358{
1359    const VkLayerDispatchTable *disp;
1360
1361    disp = loader_get_dispatch(commandBuffer);
1362
1363    disp->CmdResetEvent(commandBuffer, event, stageMask);
1364}
1365
1366LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(
1367                                VkCommandBuffer commandBuffer,
1368                                uint32_t eventCount,
1369                                const VkEvent* pEvents,
1370                                VkPipelineStageFlags sourceStageMask,
1371                                VkPipelineStageFlags dstStageMask,
1372                                uint32_t memoryBarrierCount,
1373                                const VkMemoryBarrier* pMemoryBarriers,
1374                                uint32_t bufferMemoryBarrierCount,
1375                                const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1376                                uint32_t imageMemoryBarrierCount,
1377                                const VkImageMemoryBarrier* pImageMemoryBarriers)
1378{
1379    const VkLayerDispatchTable *disp;
1380
1381    disp = loader_get_dispatch(commandBuffer);
1382
1383    disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask,
1384                        dstStageMask, memoryBarrierCount, pMemoryBarriers,
1385                        bufferMemoryBarrierCount, pBufferMemoryBarriers,
1386                        imageMemoryBarrierCount, pImageMemoryBarriers);
1387}
1388
1389LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
1390                                VkCommandBuffer commandBuffer,
1391                                VkPipelineStageFlags srcStageMask,
1392                                VkPipelineStageFlags dstStageMask,
1393                                VkDependencyFlags dependencyFlags,
1394                                uint32_t memoryBarrierCount,
1395                                const VkMemoryBarrier* pMemoryBarriers,
1396                                uint32_t bufferMemoryBarrierCount,
1397                                const VkBufferMemoryBarrier* pBufferMemoryBarriers,
1398                                uint32_t imageMemoryBarrierCount,
1399                                const VkImageMemoryBarrier* pImageMemoryBarriers)
1400{
1401    const VkLayerDispatchTable *disp;
1402
1403    disp = loader_get_dispatch(commandBuffer);
1404
1405    disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask,
1406                             dependencyFlags, memoryBarrierCount, pMemoryBarriers,
1407                             bufferMemoryBarrierCount, pBufferMemoryBarriers,
1408                             imageMemoryBarrierCount, pImageMemoryBarriers);
1409}
1410
1411LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
1412{
1413    const VkLayerDispatchTable *disp;
1414
1415    disp = loader_get_dispatch(commandBuffer);
1416
1417    disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
1418}
1419
1420LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot)
1421{
1422    const VkLayerDispatchTable *disp;
1423
1424    disp = loader_get_dispatch(commandBuffer);
1425
1426    disp->CmdEndQuery(commandBuffer, queryPool, slot);
1427}
1428
1429LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount)
1430{
1431    const VkLayerDispatchTable *disp;
1432
1433    disp = loader_get_dispatch(commandBuffer);
1434
1435    disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
1436}
1437
1438LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot)
1439{
1440    const VkLayerDispatchTable *disp;
1441
1442    disp = loader_get_dispatch(commandBuffer);
1443
1444    disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
1445}
1446
1447LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags)
1448{
1449    const VkLayerDispatchTable *disp;
1450
1451    disp = loader_get_dispatch(commandBuffer);
1452
1453    disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags);
1454}
1455
1456LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues)
1457{
1458    const VkLayerDispatchTable *disp;
1459
1460    disp = loader_get_dispatch(commandBuffer);
1461
1462    disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues);
1463}
1464
1465LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents)
1466{
1467    const VkLayerDispatchTable *disp;
1468
1469    disp = loader_get_dispatch(commandBuffer);
1470
1471    disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
1472}
1473
1474LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents)
1475{
1476    const VkLayerDispatchTable *disp;
1477
1478    disp = loader_get_dispatch(commandBuffer);
1479
1480    disp->CmdNextSubpass(commandBuffer, contents);
1481}
1482
1483LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer)
1484{
1485    const VkLayerDispatchTable *disp;
1486
1487    disp = loader_get_dispatch(commandBuffer);
1488
1489    disp->CmdEndRenderPass(commandBuffer);
1490}
1491
1492LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers)
1493{
1494    const VkLayerDispatchTable *disp;
1495
1496    disp = loader_get_dispatch(commandBuffer);
1497
1498    disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers);
1499}
1500