trampoline.c revision 67b42b7bde3163f662452cd8ed20e0b69e1afa4f 
1/*
2 * Vulkan
3 *
4 * Copyright (C) 2014 LunarG, 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#define _GNU_SOURCE
25#include <stdlib.h>
26#include <string.h>
27
28#include "vk_loader_platform.h"
29#include "loader.h"
30#include "debug_report.h"
31#include "wsi_swapchain.h"
32
33#if defined(WIN32)
34// On Windows need to disable global optimization for function entrypoints or
35//  else mhook will not be able to hook all of them
36#pragma optimize( "g", off )
37#endif
38
39/* Trampoline entrypoints */
40LOADER_EXPORT VkResult VKAPI vkCreateInstance(
41        const VkInstanceCreateInfo* pCreateInfo,
42        VkInstance* pInstance)
43{
44    struct loader_instance *ptr_instance = NULL;
45    VkResult res = VK_ERROR_INITIALIZATION_FAILED;
46
47    loader_platform_thread_once(&once_init, loader_initialize);
48
49    if (pCreateInfo->pAllocCb
50            && pCreateInfo->pAllocCb->pfnAlloc
51            && pCreateInfo->pAllocCb->pfnFree) {
52        ptr_instance = (struct loader_instance *) pCreateInfo->pAllocCb->pfnAlloc(
53                           pCreateInfo->pAllocCb->pUserData,
54                           sizeof(struct loader_instance),
55                           sizeof(VkInstance),
56                           VK_SYSTEM_ALLOC_TYPE_API_OBJECT);
57    } else {
58        ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance));
59    }
60    if (ptr_instance == NULL) {
61        return VK_ERROR_OUT_OF_HOST_MEMORY;
62    }
63
64    tls_instance = ptr_instance;
65    loader_platform_thread_lock_mutex(&loader_lock);
66    memset(ptr_instance, 0, sizeof(struct loader_instance));
67
68    if (pCreateInfo->pAllocCb
69            && pCreateInfo->pAllocCb->pfnAlloc
70            && pCreateInfo->pAllocCb->pfnFree) {
71        ptr_instance->alloc_callbacks.pUserData = pCreateInfo->pAllocCb->pUserData;
72        ptr_instance->alloc_callbacks.pfnAlloc = pCreateInfo->pAllocCb->pfnAlloc;
73        ptr_instance->alloc_callbacks.pfnFree = pCreateInfo->pAllocCb->pfnFree;
74    }
75
76    /* Due to implicit layers need to get layer list even if
77     * layerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
78     * get layer list (both instance and device) via loader_layer_scan(). */
79    memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list));
80    memset(&ptr_instance->device_layer_list, 0, sizeof(ptr_instance->device_layer_list));
81    loader_layer_scan(ptr_instance,
82
83
84                      &ptr_instance->instance_layer_list,
85                      &ptr_instance->device_layer_list);
86
87    /* validate the app requested layers to be enabled */
88    if (pCreateInfo->layerCount > 0) {
89        res = loader_validate_layers(pCreateInfo->layerCount,
90                                     pCreateInfo->ppEnabledLayerNames,
91                                     &ptr_instance->instance_layer_list);
92        if (res != VK_SUCCESS) {
93            return res;
94        }
95    }
96
97    /* Scan/discover all ICD libraries */
98    memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
99    loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
100
101    /* get extensions from all ICD's, merge so no duplicates, then validate */
102    loader_get_icd_loader_instance_extensions(ptr_instance,
103                                              &ptr_instance->icd_libs,
104                                              &ptr_instance->ext_list);
105    res = loader_validate_instance_extensions(&ptr_instance->ext_list,
106                                              &ptr_instance->instance_layer_list,
107                                              pCreateInfo);
108    if (res != VK_SUCCESS) {
109        loader_delete_layer_properties(ptr_instance,
110                                       &ptr_instance->device_layer_list);
111        loader_delete_layer_properties(ptr_instance,
112                                       &ptr_instance->instance_layer_list);
113        loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
114        loader_destroy_ext_list(ptr_instance, &ptr_instance->ext_list);
115        loader_platform_thread_unlock_mutex(&loader_lock);
116        loader_heap_free(ptr_instance, ptr_instance);
117        return res;
118    }
119
120    ptr_instance->disp = loader_heap_alloc(
121                             ptr_instance,
122                             sizeof(VkLayerInstanceDispatchTable),
123                             VK_SYSTEM_ALLOC_TYPE_INTERNAL);
124    if (ptr_instance->disp == NULL) {
125        loader_delete_layer_properties(ptr_instance,
126                                       &ptr_instance->device_layer_list);
127        loader_delete_layer_properties(ptr_instance,
128                                       &ptr_instance->instance_layer_list);
129        loader_scanned_icd_clear(ptr_instance,
130                                 &ptr_instance->icd_libs);
131        loader_destroy_ext_list(ptr_instance,
132                                &ptr_instance->ext_list);
133        loader_platform_thread_unlock_mutex(&loader_lock);
134        loader_heap_free(ptr_instance, ptr_instance);
135        return VK_ERROR_OUT_OF_HOST_MEMORY;
136    }
137    memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp));
138    ptr_instance->next = loader.instances;
139    loader.instances = ptr_instance;
140
141    /* activate any layers on instance chain */
142    res = loader_enable_instance_layers(ptr_instance,
143                                        pCreateInfo,
144                                        &ptr_instance->instance_layer_list);
145    if (res != VK_SUCCESS) {
146        loader_delete_layer_properties(ptr_instance,
147                                       &ptr_instance->device_layer_list);
148        loader_delete_layer_properties(ptr_instance,
149                                       &ptr_instance->instance_layer_list);
150        loader_scanned_icd_clear(ptr_instance,
151                                 &ptr_instance->icd_libs);
152        loader_destroy_ext_list(ptr_instance,
153                                &ptr_instance->ext_list);
154        loader.instances = ptr_instance->next;
155        loader_platform_thread_unlock_mutex(&loader_lock);
156        loader_heap_free(ptr_instance, ptr_instance->disp);
157        loader_heap_free(ptr_instance, ptr_instance);
158        return res;
159    }
160    loader_activate_instance_layers(ptr_instance);
161
162    wsi_swapchain_create_instance(ptr_instance, pCreateInfo);
163    debug_report_create_instance(ptr_instance, pCreateInfo);
164
165
166    *pInstance = (VkInstance) ptr_instance;
167
168    res = ptr_instance->disp->CreateInstance(pCreateInfo, pInstance);
169
170    /*
171     * Finally have the layers in place and everyone has seen
172     * the CreateInstance command go by. This allows the layer's
173     * GetInstanceProcAddr functions to return valid extension functions
174     * if enabled.
175     */
176    loader_activate_instance_layer_extensions(ptr_instance);
177
178    loader_platform_thread_unlock_mutex(&loader_lock);
179    return res;
180}
181
182LOADER_EXPORT void VKAPI vkDestroyInstance(
183                                            VkInstance instance)
184{
185    const VkLayerInstanceDispatchTable *disp;
186    disp = loader_get_instance_dispatch(instance);
187
188    loader_platform_thread_lock_mutex(&loader_lock);
189
190    disp->DestroyInstance(instance);
191
192    struct loader_instance *ptr_instance = loader_instance(instance);
193    loader_deactivate_instance_layers(ptr_instance);
194    loader_heap_free(ptr_instance, ptr_instance->disp);
195    loader_heap_free(ptr_instance, ptr_instance);
196    loader_platform_thread_unlock_mutex(&loader_lock);
197}
198
199LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
200                                            VkInstance instance,
201                                            uint32_t* pPhysicalDeviceCount,
202                                            VkPhysicalDevice* pPhysicalDevices)
203{
204    const VkLayerInstanceDispatchTable *disp;
205    VkResult res;
206    disp = loader_get_instance_dispatch(instance);
207
208    loader_platform_thread_lock_mutex(&loader_lock);
209    res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
210                                         pPhysicalDevices);
211    loader_platform_thread_unlock_mutex(&loader_lock);
212    return res;
213}
214
215
216
217
218
219
220LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures(
221                                            VkPhysicalDevice gpu,
222                                            VkPhysicalDeviceFeatures *pFeatures)
223{
224    const VkLayerInstanceDispatchTable *disp;
225    VkResult res;
226
227    disp = loader_get_instance_dispatch(gpu);
228    res = disp->GetPhysicalDeviceFeatures(gpu, pFeatures);
229    return res;
230}
231
232LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatProperties(
233                                            VkPhysicalDevice gpu,
234                                            VkFormat format,
235                                            VkFormatProperties *pFormatInfo)
236{
237    const VkLayerInstanceDispatchTable *disp;
238    VkResult res;
239
240    disp = loader_get_instance_dispatch(gpu);
241    res = disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo);
242    return res;
243}
244
245LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageFormatProperties* pImageFormatProperties)
246{
247    const VkLayerInstanceDispatchTable *disp;
248    VkResult res;
249
250    disp = loader_get_instance_dispatch(physicalDevice);
251    res = disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, pImageFormatProperties);
252    return res;
253}
254
255LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
256                                            VkPhysicalDevice gpu,
257                                            VkPhysicalDeviceProperties* pProperties)
258{
259    const VkLayerInstanceDispatchTable *disp;
260    VkResult res;
261
262    disp = loader_get_instance_dispatch(gpu);
263    res = disp->GetPhysicalDeviceProperties(gpu, pProperties);
264    return res;
265}
266
267LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
268                                            VkPhysicalDevice gpu,
269                                            uint32_t* pCount,
270                                            VkQueueFamilyProperties* pQueueProperties)
271{
272    const VkLayerInstanceDispatchTable *disp;
273    VkResult res;
274
275    disp = loader_get_instance_dispatch(gpu);
276    res = disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pQueueProperties);
277    return res;
278}
279
280LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties(
281                                            VkPhysicalDevice gpu,
282                                            VkPhysicalDeviceMemoryProperties* pMemoryProperties)
283{
284    const VkLayerInstanceDispatchTable *disp;
285    VkResult res;
286
287    disp = loader_get_instance_dispatch(gpu);
288    res = disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
289    return res;
290}
291
292LOADER_EXPORT VkResult VKAPI vkCreateDevice(
293        VkPhysicalDevice gpu,
294        const VkDeviceCreateInfo* pCreateInfo,
295        VkDevice* pDevice)
296{
297    VkResult res;
298
299    loader_platform_thread_lock_mutex(&loader_lock);
300
301    res = loader_CreateDevice(gpu, pCreateInfo, pDevice);
302
303    loader_platform_thread_unlock_mutex(&loader_lock);
304    return res;
305}
306
307LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
308{
309    const VkLayerDispatchTable *disp;
310    struct loader_device *dev;
311    struct loader_icd *icd = loader_get_icd_and_device(device, &dev);
312    const struct loader_instance *inst = icd->this_instance;
313    disp = loader_get_dispatch(device);
314
315    loader_platform_thread_lock_mutex(&loader_lock);
316    disp->DestroyDevice(device);
317    loader_remove_logical_device(inst, device);
318    loader_platform_thread_unlock_mutex(&loader_lock);
319}
320
321LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
322    VkPhysicalDevice                            physicalDevice,
323    const char*                                 pLayerName,
324    uint32_t*                                   pCount,
325    VkExtensionProperties*                      pProperties)
326{
327    VkResult res;
328
329    loader_platform_thread_lock_mutex(&loader_lock);
330    //TODO convert over to using instance chain dispatch
331    res = loader_GetPhysicalDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
332    loader_platform_thread_unlock_mutex(&loader_lock);
333    return res;
334}
335
336LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLayerProperties(
337    VkPhysicalDevice                            physicalDevice,
338    uint32_t*                                   pCount,
339    VkLayerProperties*                          pProperties)
340{
341    VkResult res;
342
343    loader_platform_thread_lock_mutex(&loader_lock);
344    //TODO convert over to using instance chain dispatch
345    res = loader_GetPhysicalDeviceLayerProperties(physicalDevice, pCount, pProperties);
346    loader_platform_thread_unlock_mutex(&loader_lock);
347    return res;
348}
349
350LOADER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue)
351{
352    const VkLayerDispatchTable *disp;
353    VkResult res;
354
355    disp = loader_get_dispatch(device);
356
357    res = disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
358    if (res == VK_SUCCESS) {
359        loader_set_dispatch(*pQueue, disp);
360    }
361
362    return res;
363}
364
365LOADER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence)
366{
367    const VkLayerDispatchTable *disp;
368
369    disp = loader_get_dispatch(queue);
370
371    return disp->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence);
372}
373
374LOADER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue)
375{
376    const VkLayerDispatchTable *disp;
377
378    disp = loader_get_dispatch(queue);
379
380    return disp->QueueWaitIdle(queue);
381}
382
383LOADER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device)
384{
385    const VkLayerDispatchTable *disp;
386
387    disp = loader_get_dispatch(device);
388
389    return disp->DeviceWaitIdle(device);
390}
391
392LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem)
393{
394    const VkLayerDispatchTable *disp;
395
396    disp = loader_get_dispatch(device);
397
398    return disp->AllocMemory(device, pAllocInfo, pMem);
399}
400
401LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem)
402{
403    const VkLayerDispatchTable *disp;
404
405    disp = loader_get_dispatch(device);
406
407    disp->FreeMemory(device, mem);
408}
409
410LOADER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData)
411{
412    const VkLayerDispatchTable *disp;
413
414    disp = loader_get_dispatch(device);
415
416    return disp->MapMemory(device, mem, offset, size, flags, ppData);
417}
418
419LOADER_EXPORT void VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem)
420{
421    const VkLayerDispatchTable *disp;
422
423    disp = loader_get_dispatch(device);
424
425    disp->UnmapMemory(device, mem);
426}
427
428LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges)
429{
430    const VkLayerDispatchTable *disp;
431
432    disp = loader_get_dispatch(device);
433
434    return disp->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges);
435}
436
437LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges)
438{
439    const VkLayerDispatchTable *disp;
440
441    disp = loader_get_dispatch(device);
442
443    return disp->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges);
444}
445
446LOADER_EXPORT VkResult VKAPI vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes)
447{
448    const VkLayerDispatchTable *disp;
449
450    disp = loader_get_dispatch(device);
451
452    return disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
453}
454
455LOADER_EXPORT VkResult VKAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset)
456{
457    const VkLayerDispatchTable *disp;
458
459    disp = loader_get_dispatch(device);
460
461    return disp->BindBufferMemory(device, buffer, mem, offset);
462}
463
464LOADER_EXPORT VkResult VKAPI vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize offset)
465{
466    const VkLayerDispatchTable *disp;
467
468    disp = loader_get_dispatch(device);
469
470    return disp->BindImageMemory(device, image, mem, offset);
471}
472
473LOADER_EXPORT VkResult VKAPI vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements)
474{
475    const VkLayerDispatchTable *disp;
476
477    disp = loader_get_dispatch(device);
478
479    return disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
480}
481
482LOADER_EXPORT VkResult VKAPI vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements)
483{
484    const VkLayerDispatchTable *disp;
485
486    disp = loader_get_dispatch(device);
487
488    return disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
489}
490
491LOADER_EXPORT VkResult VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
492{
493    const VkLayerDispatchTable *disp;
494
495    disp = loader_get_dispatch(device);
496
497    return disp->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
498}
499
500LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, uint32_t samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pNumProperties, VkSparseImageFormatProperties* pProperties)
501{
502    const VkLayerInstanceDispatchTable *disp;
503
504    disp = loader_get_instance_dispatch(physicalDevice);
505
506    return disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pNumProperties, pProperties);
507}
508
509LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
510{
511    const VkLayerDispatchTable *disp;
512
513    disp = loader_get_dispatch(queue);
514
515    return disp->QueueBindSparseBufferMemory(queue, buffer, numBindings, pBindInfo);
516}
517
518LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageOpaqueMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseMemoryBindInfo* pBindInfo)
519{
520    const VkLayerDispatchTable *disp;
521
522    disp = loader_get_dispatch(queue);
523
524    return disp->QueueBindSparseImageOpaqueMemory(queue, image, numBindings, pBindInfo);
525}
526
527LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, uint32_t numBindings, const VkSparseImageMemoryBindInfo* pBindInfo)
528{
529    const VkLayerDispatchTable *disp;
530
531    disp = loader_get_dispatch(queue);
532
533    return disp->QueueBindSparseImageMemory(queue, image, numBindings, pBindInfo);
534}
535
536LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence)
537{
538    const VkLayerDispatchTable *disp;
539
540    disp = loader_get_dispatch(device);
541
542    return disp->CreateFence(device, pCreateInfo, pFence);
543}
544
545LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
546{
547    const VkLayerDispatchTable *disp;
548
549    disp = loader_get_dispatch(device);
550
551    disp->DestroyFence(device, fence);
552}
553
554LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
555{
556    const VkLayerDispatchTable *disp;
557
558    disp = loader_get_dispatch(device);
559
560    return disp->ResetFences(device, fenceCount, pFences);
561}
562
563LOADER_EXPORT VkResult VKAPI vkGetFenceStatus(VkDevice device, VkFence fence)
564{
565    const VkLayerDispatchTable *disp;
566
567    disp = loader_get_dispatch(device);
568
569    return disp->GetFenceStatus(device, fence);
570}
571
572LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
573{
574    const VkLayerDispatchTable *disp;
575
576    disp = loader_get_dispatch(device);
577
578    return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
579}
580
581LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore)
582{
583    const VkLayerDispatchTable *disp;
584
585    disp = loader_get_dispatch(device);
586
587    return disp->CreateSemaphore(device, pCreateInfo, pSemaphore);
588}
589
590LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
591{
592    const VkLayerDispatchTable *disp;
593
594    disp = loader_get_dispatch(device);
595
596    disp->DestroySemaphore(device, semaphore);
597}
598
599LOADER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore)
600{
601    const VkLayerDispatchTable *disp;
602
603    disp = loader_get_dispatch(queue);
604
605    return disp->QueueSignalSemaphore(queue, semaphore);
606}
607
608LOADER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore)
609{
610    const VkLayerDispatchTable *disp;
611
612    disp = loader_get_dispatch(queue);
613
614    return disp->QueueWaitSemaphore(queue, semaphore);
615}
616
617LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent)
618{
619    const VkLayerDispatchTable *disp;
620
621    disp = loader_get_dispatch(device);
622
623    return disp->CreateEvent(device, pCreateInfo, pEvent);
624}
625
626LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
627{
628    const VkLayerDispatchTable *disp;
629
630    disp = loader_get_dispatch(device);
631
632    disp->DestroyEvent(device, event);
633}
634
635LOADER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event)
636{
637    const VkLayerDispatchTable *disp;
638
639    disp = loader_get_dispatch(device);
640
641    return disp->GetEventStatus(device, event);
642}
643
644LOADER_EXPORT VkResult VKAPI vkSetEvent(VkDevice device, VkEvent event)
645{
646    const VkLayerDispatchTable *disp;
647
648    disp = loader_get_dispatch(device);
649
650    return disp->SetEvent(device, event);
651}
652
653LOADER_EXPORT VkResult VKAPI vkResetEvent(VkDevice device, VkEvent event)
654{
655    const VkLayerDispatchTable *disp;
656
657    disp = loader_get_dispatch(device);
658
659    return disp->ResetEvent(device, event);
660}
661
662LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool)
663{
664    const VkLayerDispatchTable *disp;
665
666    disp = loader_get_dispatch(device);
667
668    return disp->CreateQueryPool(device, pCreateInfo, pQueryPool);
669}
670
671LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
672{
673    const VkLayerDispatchTable *disp;
674
675    disp = loader_get_dispatch(device);
676
677    disp->DestroyQueryPool(device, queryPool);
678}
679
680LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags)
681{
682    const VkLayerDispatchTable *disp;
683
684    disp = loader_get_dispatch(device);
685
686    return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags);
687}
688
689LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer)
690{
691    const VkLayerDispatchTable *disp;
692
693    disp = loader_get_dispatch(device);
694
695    return disp->CreateBuffer(device, pCreateInfo, pBuffer);
696}
697
698LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
699{
700    const VkLayerDispatchTable *disp;
701
702    disp = loader_get_dispatch(device);
703
704    disp->DestroyBuffer(device, buffer);
705}
706
707LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView)
708{
709    const VkLayerDispatchTable *disp;
710
711    disp = loader_get_dispatch(device);
712
713    return disp->CreateBufferView(device, pCreateInfo, pView);
714}
715
716LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
717{
718    const VkLayerDispatchTable *disp;
719
720    disp = loader_get_dispatch(device);
721
722    disp->DestroyBufferView(device, bufferView);
723}
724
725LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage)
726{
727    const VkLayerDispatchTable *disp;
728
729    disp = loader_get_dispatch(device);
730
731    return disp->CreateImage(device, pCreateInfo, pImage);
732}
733
734LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
735{
736    const VkLayerDispatchTable *disp;
737
738    disp = loader_get_dispatch(device);
739
740    disp->DestroyImage(device, image);
741}
742
743LOADER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
744{
745    const VkLayerDispatchTable *disp;
746
747    disp = loader_get_dispatch(device);
748
749    return disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
750}
751
752LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView)
753{
754    const VkLayerDispatchTable *disp;
755
756    disp = loader_get_dispatch(device);
757
758    return disp->CreateImageView(device, pCreateInfo, pView);
759}
760
761LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
762{
763    const VkLayerDispatchTable *disp;
764
765    disp = loader_get_dispatch(device);
766
767    disp->DestroyImageView(device, imageView);
768}
769
770LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShader)
771{
772    const VkLayerDispatchTable *disp;
773
774    disp = loader_get_dispatch(device);
775
776    return disp->CreateShaderModule(device, pCreateInfo, pShader);
777}
778
779LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
780{
781    const VkLayerDispatchTable *disp;
782
783    disp = loader_get_dispatch(device);
784
785    disp->DestroyShaderModule(device, shaderModule);
786}
787
788LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader)
789{
790    const VkLayerDispatchTable *disp;
791
792    disp = loader_get_dispatch(device);
793
794    return disp->CreateShader(device, pCreateInfo, pShader);
795}
796
797LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
798{
799    const VkLayerDispatchTable *disp;
800
801    disp = loader_get_dispatch(device);
802
803    disp->DestroyShader(device, shader);
804}
805
806LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache)
807{
808    const VkLayerDispatchTable *disp;
809
810    disp = loader_get_dispatch(device);
811
812    return disp->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
813}
814
815LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache)
816{
817    const VkLayerDispatchTable *disp;
818
819    disp = loader_get_dispatch(device);
820
821    disp->DestroyPipelineCache(device, pipelineCache);
822}
823
824LOADER_EXPORT size_t VKAPI vkGetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache)
825{
826    const VkLayerDispatchTable *disp;
827
828    disp = loader_get_dispatch(device);
829
830    return disp->GetPipelineCacheSize(device, pipelineCache);
831}
832
833LOADER_EXPORT VkResult VKAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData)
834{
835    const VkLayerDispatchTable *disp;
836
837    disp = loader_get_dispatch(device);
838
839    return disp->GetPipelineCacheData(device, pipelineCache, pData);
840}
841
842LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
843{
844    const VkLayerDispatchTable *disp;
845
846    disp = loader_get_dispatch(device);
847
848    return disp->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
849}
850
851LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
852{
853    const VkLayerDispatchTable *disp;
854
855    disp = loader_get_dispatch(device);
856
857    return disp->CreateGraphicsPipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
858}
859
860LOADER_EXPORT VkResult VKAPI vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkComputePipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
861{
862    const VkLayerDispatchTable *disp;
863
864    disp = loader_get_dispatch(device);
865
866    return disp->CreateComputePipelines(device, pipelineCache, count, pCreateInfos, pPipelines);
867}
868
869LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
870{
871    const VkLayerDispatchTable *disp;
872
873    disp = loader_get_dispatch(device);
874
875    disp->DestroyPipeline(device, pipeline);
876}
877
878LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout)
879{
880    const VkLayerDispatchTable *disp;
881
882    disp = loader_get_dispatch(device);
883
884    return disp->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout);
885}
886
887LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
888{
889    const VkLayerDispatchTable *disp;
890
891    disp = loader_get_dispatch(device);
892
893    disp->DestroyPipelineLayout(device, pipelineLayout);
894}
895
896LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler)
897{
898    const VkLayerDispatchTable *disp;
899
900    disp = loader_get_dispatch(device);
901
902    return disp->CreateSampler(device, pCreateInfo, pSampler);
903}
904
905LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
906{
907    const VkLayerDispatchTable *disp;
908
909    disp = loader_get_dispatch(device);
910
911    disp->DestroySampler(device, sampler);
912}
913
914
915LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout)
916{
917    const VkLayerDispatchTable *disp;
918
919    disp = loader_get_dispatch(device);
920
921    return disp->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout);
922}
923
924LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
925{
926    const VkLayerDispatchTable *disp;
927
928    disp = loader_get_dispatch(device);
929
930    disp->DestroyDescriptorSetLayout(device, descriptorSetLayout);
931}
932
933LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool)
934{
935    const VkLayerDispatchTable *disp;
936
937    disp = loader_get_dispatch(device);
938
939    return disp->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool);
940}
941
942LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
943{
944    const VkLayerDispatchTable *disp;
945
946    disp = loader_get_dispatch(device);
947
948    disp->DestroyDescriptorPool(device, descriptorPool);
949}
950
951
952LOADER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
953{
954    const VkLayerDispatchTable *disp;
955
956    disp = loader_get_dispatch(device);
957
958    return disp->ResetDescriptorPool(device, descriptorPool);
959}
960
961LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets)
962{
963    const VkLayerDispatchTable *disp;
964
965    disp = loader_get_dispatch(device);
966
967    return disp->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
968}
969
970LOADER_EXPORT VkResult VKAPI vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets)
971{
972    const VkLayerDispatchTable *disp;
973
974    disp = loader_get_dispatch(device);
975
976    return disp->FreeDescriptorSets(device, descriptorPool, count, pDescriptorSets);
977}
978
979LOADER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
980{
981    const VkLayerDispatchTable *disp;
982
983    disp = loader_get_dispatch(device);
984
985    disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
986}
987
988LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState)
989{
990    const VkLayerDispatchTable *disp;
991
992    disp = loader_get_dispatch(device);
993
994    return disp->CreateDynamicViewportState(device, pCreateInfo, pState);
995}
996
997LOADER_EXPORT void VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
998{
999    const VkLayerDispatchTable *disp;
1000
1001    disp = loader_get_dispatch(device);
1002
1003    disp->DestroyDynamicViewportState(device, dynamicViewportState);
1004}
1005
1006LOADER_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState(VkDevice device, const VkDynamicLineWidthStateCreateInfo* pCreateInfo, VkDynamicLineWidthState* pState)
1007{
1008    const VkLayerDispatchTable *disp;
1009
1010    disp = loader_get_dispatch(device);
1011
1012    return disp->CreateDynamicLineWidthState(device, pCreateInfo, pState);
1013}
1014
1015LOADER_EXPORT void VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState)
1016{
1017    const VkLayerDispatchTable *disp;
1018
1019    disp = loader_get_dispatch(device);
1020
1021    disp->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
1022}
1023
1024LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState(VkDevice device, const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, VkDynamicDepthBiasState* pState)
1025{
1026    const VkLayerDispatchTable *disp;
1027
1028    disp = loader_get_dispatch(device);
1029
1030    return disp->CreateDynamicDepthBiasState(device, pCreateInfo, pState);
1031}
1032
1033LOADER_EXPORT void VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState)
1034{
1035    const VkLayerDispatchTable *disp;
1036
1037    disp = loader_get_dispatch(device);
1038
1039    disp->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
1040}
1041
1042LOADER_EXPORT VkResult VKAPI vkCreateDynamicBlendState(VkDevice device, const VkDynamicBlendStateCreateInfo* pCreateInfo, VkDynamicBlendState* pState)
1043{
1044    const VkLayerDispatchTable *disp;
1045
1046    disp = loader_get_dispatch(device);
1047
1048    return disp->CreateDynamicBlendState(device, pCreateInfo, pState);
1049}
1050
1051LOADER_EXPORT void VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState)
1052{
1053    const VkLayerDispatchTable *disp;
1054
1055    disp = loader_get_dispatch(device);
1056
1057    disp->DestroyDynamicBlendState(device, dynamicBlendState);
1058}
1059
1060LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState(VkDevice device, const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, VkDynamicDepthBoundsState* pState)
1061{
1062    const VkLayerDispatchTable *disp;
1063
1064    disp = loader_get_dispatch(device);
1065
1066    return disp->CreateDynamicDepthBoundsState(device, pCreateInfo, pState);
1067}
1068
1069LOADER_EXPORT void VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState)
1070{
1071    const VkLayerDispatchTable *disp;
1072
1073    disp = loader_get_dispatch(device);
1074
1075    disp->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
1076}
1077
1078LOADER_EXPORT VkResult VKAPI vkCreateDynamicStencilState(VkDevice device, const VkDynamicStencilStateCreateInfo* pCreateInfoFront, const VkDynamicStencilStateCreateInfo* pCreateInfoBack, VkDynamicStencilState* pState)
1079{
1080    const VkLayerDispatchTable *disp;
1081
1082    disp = loader_get_dispatch(device);
1083
1084    return disp->CreateDynamicStencilState(device, pCreateInfoFront, pCreateInfoBack, pState);
1085}
1086
1087LOADER_EXPORT void VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
1088{
1089    const VkLayerDispatchTable *disp;
1090
1091    disp = loader_get_dispatch(device);
1092
1093    disp->DestroyDynamicStencilState(device, dynamicStencilState);
1094}
1095
1096LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer)
1097{
1098    const VkLayerDispatchTable *disp;
1099
1100    disp = loader_get_dispatch(device);
1101
1102    return disp->CreateFramebuffer(device, pCreateInfo, pFramebuffer);
1103}
1104
1105LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
1106{
1107    const VkLayerDispatchTable *disp;
1108
1109    disp = loader_get_dispatch(device);
1110
1111    disp->DestroyFramebuffer(device, framebuffer);
1112}
1113
1114LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass)
1115{
1116    const VkLayerDispatchTable *disp;
1117
1118    disp = loader_get_dispatch(device);
1119
1120    return disp->CreateRenderPass(device, pCreateInfo, pRenderPass);
1121}
1122
1123LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
1124{
1125    const VkLayerDispatchTable *disp;
1126
1127    disp = loader_get_dispatch(device);
1128
1129    disp->DestroyRenderPass(device, renderPass);
1130}
1131
1132LOADER_EXPORT VkResult VKAPI vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity)
1133{
1134    const VkLayerDispatchTable *disp;
1135
1136    disp = loader_get_dispatch(device);
1137
1138    return disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
1139}
1140
1141LOADER_EXPORT VkResult VKAPI vkCreateCommandPool(VkDevice device, const VkCmdPoolCreateInfo* pCreateInfo, VkCmdPool* pCmdPool)
1142{
1143    const VkLayerDispatchTable *disp;
1144
1145    disp = loader_get_dispatch(device);
1146
1147    return disp->CreateCommandPool(device, pCreateInfo, pCmdPool);
1148}
1149
1150LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool)
1151{
1152    const VkLayerDispatchTable *disp;
1153
1154    disp = loader_get_dispatch(device);
1155
1156    disp->DestroyCommandPool(device, cmdPool);
1157}
1158
1159LOADER_EXPORT VkResult VKAPI vkResetCommandPool(VkDevice device, VkCmdPool cmdPool, VkCmdPoolResetFlags flags)
1160{
1161    const VkLayerDispatchTable *disp;
1162
1163    disp = loader_get_dispatch(device);
1164
1165    return disp->ResetCommandPool(device, cmdPool, flags);
1166}
1167
1168LOADER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer)
1169{
1170    const VkLayerDispatchTable *disp;
1171    VkResult res;
1172
1173    disp = loader_get_dispatch(device);
1174
1175    res = disp->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer);
1176    if (res == VK_SUCCESS) {
1177        loader_init_dispatch(*pCmdBuffer, disp);
1178    }
1179
1180    return res;
1181}
1182
1183LOADER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdBuffer)
1184{
1185    const VkLayerDispatchTable *disp;
1186
1187    disp = loader_get_dispatch(device);
1188
1189    disp->DestroyCommandBuffer(device, cmdBuffer);
1190}
1191
1192LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo)
1193{
1194    const VkLayerDispatchTable *disp;
1195
1196    disp = loader_get_dispatch(cmdBuffer);
1197
1198    return disp->BeginCommandBuffer(cmdBuffer, pBeginInfo);
1199}
1200
1201LOADER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer)
1202{
1203    const VkLayerDispatchTable *disp;
1204
1205    disp = loader_get_dispatch(cmdBuffer);
1206
1207    return disp->EndCommandBuffer(cmdBuffer);
1208}
1209
1210LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
1211{
1212    const VkLayerDispatchTable *disp;
1213
1214    disp = loader_get_dispatch(cmdBuffer);
1215
1216    return disp->ResetCommandBuffer(cmdBuffer, flags);
1217}
1218
1219LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline)
1220{
1221    const VkLayerDispatchTable *disp;
1222
1223    disp = loader_get_dispatch(cmdBuffer);
1224
1225    disp->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline);
1226}
1227
1228LOADER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, VkDynamicViewportState state)
1229{
1230    const VkLayerDispatchTable *disp;
1231
1232    disp = loader_get_dispatch(cmdBuffer);
1233
1234    disp->CmdBindDynamicViewportState(cmdBuffer, state);
1235}
1236
1237LOADER_EXPORT void VKAPI vkCmdBindDynamicLineWidthState(VkCmdBuffer cmdBuffer, VkDynamicLineWidthState state)
1238{
1239    const VkLayerDispatchTable *disp;
1240
1241    disp = loader_get_dispatch(cmdBuffer);
1242
1243    disp->CmdBindDynamicLineWidthState(cmdBuffer, state);
1244}
1245
1246LOADER_EXPORT void VKAPI vkCmdBindDynamicDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicDepthBiasState state)
1247{
1248    const VkLayerDispatchTable *disp;
1249
1250    disp = loader_get_dispatch(cmdBuffer);
1251
1252    disp->CmdBindDynamicDepthBiasState(cmdBuffer, state);
1253}
1254
1255LOADER_EXPORT void VKAPI vkCmdBindDynamicBlendState(VkCmdBuffer cmdBuffer, VkDynamicBlendState state)
1256{
1257    const VkLayerDispatchTable *disp;
1258
1259    disp = loader_get_dispatch(cmdBuffer);
1260
1261    disp->CmdBindDynamicBlendState(cmdBuffer, state);
1262}
1263
1264LOADER_EXPORT void VKAPI vkCmdBindDynamicDepthBoundsState(VkCmdBuffer cmdBuffer, VkDynamicDepthBoundsState state)
1265{
1266    const VkLayerDispatchTable *disp;
1267
1268    disp = loader_get_dispatch(cmdBuffer);
1269
1270    disp->CmdBindDynamicDepthBoundsState(cmdBuffer, state);
1271}
1272
1273LOADER_EXPORT void VKAPI vkCmdBindDynamicStencilState(VkCmdBuffer cmdBuffer, VkDynamicStencilState state)
1274{
1275    const VkLayerDispatchTable *disp;
1276
1277    disp = loader_get_dispatch(cmdBuffer);
1278
1279    disp->CmdBindDynamicStencilState(cmdBuffer, state);
1280}
1281
1282LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets)
1283{
1284    const VkLayerDispatchTable *disp;
1285
1286    disp = loader_get_dispatch(cmdBuffer);
1287
1288    disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
1289}
1290
1291LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType)
1292{
1293    const VkLayerDispatchTable *disp;
1294
1295    disp = loader_get_dispatch(cmdBuffer);
1296
1297    disp->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType);
1298}
1299
1300LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets)
1301{
1302    const VkLayerDispatchTable *disp;
1303
1304    disp = loader_get_dispatch(cmdBuffer);
1305
1306    disp->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets);
1307}
1308
1309LOADER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount)
1310{
1311    const VkLayerDispatchTable *disp;
1312
1313    disp = loader_get_dispatch(cmdBuffer);
1314
1315    disp->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount);
1316}
1317
1318LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount)
1319{
1320    const VkLayerDispatchTable *disp;
1321
1322    disp = loader_get_dispatch(cmdBuffer);
1323
1324    disp->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount);
1325}
1326
1327LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
1328{
1329    const VkLayerDispatchTable *disp;
1330
1331    disp = loader_get_dispatch(cmdBuffer);
1332
1333    disp->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride);
1334}
1335
1336LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride)
1337{
1338    const VkLayerDispatchTable *disp;
1339
1340    disp = loader_get_dispatch(cmdBuffer);
1341
1342    disp->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride);
1343}
1344
1345LOADER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z)
1346{
1347    const VkLayerDispatchTable *disp;
1348
1349    disp = loader_get_dispatch(cmdBuffer);
1350
1351    disp->CmdDispatch(cmdBuffer, x, y, z);
1352}
1353
1354LOADER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset)
1355{
1356    const VkLayerDispatchTable *disp;
1357
1358    disp = loader_get_dispatch(cmdBuffer);
1359
1360    disp->CmdDispatchIndirect(cmdBuffer, buffer, offset);
1361}
1362
1363LOADER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions)
1364{
1365    const VkLayerDispatchTable *disp;
1366
1367    disp = loader_get_dispatch(cmdBuffer);
1368
1369    disp->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions);
1370}
1371
1372LOADER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions)
1373{
1374    const VkLayerDispatchTable *disp;
1375
1376    disp = loader_get_dispatch(cmdBuffer);
1377
1378    disp->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
1379}
1380
1381LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter)
1382{
1383    const VkLayerDispatchTable *disp;
1384
1385    disp = loader_get_dispatch(cmdBuffer);
1386
1387    disp->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
1388}
1389
1390LOADER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions)
1391{
1392    const VkLayerDispatchTable *disp;
1393
1394    disp = loader_get_dispatch(cmdBuffer);
1395
1396    disp->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions);
1397}
1398
1399LOADER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions)
1400{
1401    const VkLayerDispatchTable *disp;
1402
1403    disp = loader_get_dispatch(cmdBuffer);
1404
1405    disp->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions);
1406}
1407
1408LOADER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData)
1409{
1410    const VkLayerDispatchTable *disp;
1411
1412    disp = loader_get_dispatch(cmdBuffer);
1413
1414    disp->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData);
1415}
1416
1417LOADER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data)
1418{
1419    const VkLayerDispatchTable *disp;
1420
1421    disp = loader_get_dispatch(cmdBuffer);
1422
1423    disp->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data);
1424}
1425
1426LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
1427{
1428    const VkLayerDispatchTable *disp;
1429
1430    disp = loader_get_dispatch(cmdBuffer);
1431
1432    disp->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
1433}
1434
1435LOADER_EXPORT void VKAPI vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
1436{
1437    const VkLayerDispatchTable *disp;
1438
1439    disp = loader_get_dispatch(cmdBuffer);
1440
1441    disp->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
1442}
1443
1444LOADER_EXPORT void VKAPI vkCmdClearColorAttachment(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects)
1445{
1446    const VkLayerDispatchTable *disp;
1447
1448    disp = loader_get_dispatch(cmdBuffer);
1449
1450    disp->CmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects);
1451}
1452
1453LOADER_EXPORT void VKAPI vkCmdClearDepthStencilAttachment(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects)
1454{
1455    const VkLayerDispatchTable *disp;
1456
1457    disp = loader_get_dispatch(cmdBuffer);
1458
1459    disp->CmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects);
1460}
1461
1462LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions)
1463{
1464    const VkLayerDispatchTable *disp;
1465
1466    disp = loader_get_dispatch(cmdBuffer);
1467
1468    disp->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions);
1469}
1470
1471LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1472{
1473    const VkLayerDispatchTable *disp;
1474
1475    disp = loader_get_dispatch(cmdBuffer);
1476
1477    disp->CmdSetEvent(cmdBuffer, event, stageMask);
1478}
1479
1480LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
1481{
1482    const VkLayerDispatchTable *disp;
1483
1484    disp = loader_get_dispatch(cmdBuffer);
1485
1486    disp->CmdResetEvent(cmdBuffer, event, stageMask);
1487}
1488
1489LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers)
1490{
1491    const VkLayerDispatchTable *disp;
1492
1493    disp = loader_get_dispatch(cmdBuffer);
1494
1495    disp->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
1496}
1497
1498LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers)
1499{
1500    const VkLayerDispatchTable *disp;
1501
1502    disp = loader_get_dispatch(cmdBuffer);
1503
1504    disp->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
1505}
1506
1507LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags)
1508{
1509    const VkLayerDispatchTable *disp;
1510
1511    disp = loader_get_dispatch(cmdBuffer);
1512
1513    disp->CmdBeginQuery(cmdBuffer, queryPool, slot, flags);
1514}
1515
1516LOADER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot)
1517{
1518    const VkLayerDispatchTable *disp;
1519
1520    disp = loader_get_dispatch(cmdBuffer);
1521
1522    disp->CmdEndQuery(cmdBuffer, queryPool, slot);
1523}
1524
1525LOADER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount)
1526{
1527    const VkLayerDispatchTable *disp;
1528
1529    disp = loader_get_dispatch(cmdBuffer);
1530
1531    disp->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount);
1532}
1533
1534LOADER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset)
1535{
1536    const VkLayerDispatchTable *disp;
1537
1538    disp = loader_get_dispatch(cmdBuffer);
1539
1540    disp->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset);
1541}
1542
1543LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkFlags flags)
1544{
1545    const VkLayerDispatchTable *disp;
1546
1547    disp = loader_get_dispatch(cmdBuffer);
1548
1549    disp->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags);
1550}
1551
1552LOADER_EXPORT void VKAPI vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values)
1553{
1554    const VkLayerDispatchTable *disp;
1555
1556    disp = loader_get_dispatch(cmdBuffer);
1557
1558    disp->CmdPushConstants(cmdBuffer, layout, stageFlags, start, length, values);
1559}
1560
1561LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)
1562{
1563    const VkLayerDispatchTable *disp;
1564
1565    disp = loader_get_dispatch(cmdBuffer);
1566
1567    disp->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin, contents);
1568}
1569
1570LOADER_EXPORT void VKAPI vkCmdNextSubpass(VkCmdBuffer cmdBuffer, VkRenderPassContents contents)
1571{
1572    const VkLayerDispatchTable *disp;
1573
1574    disp = loader_get_dispatch(cmdBuffer);
1575
1576    disp->CmdNextSubpass(cmdBuffer, contents);
1577}
1578
1579LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
1580{
1581    const VkLayerDispatchTable *disp;
1582
1583    disp = loader_get_dispatch(cmdBuffer);
1584
1585    disp->CmdEndRenderPass(cmdBuffer);
1586}
1587
1588LOADER_EXPORT void VKAPI vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers)
1589{
1590    const VkLayerDispatchTable *disp;
1591
1592    disp = loader_get_dispatch(cmdBuffer);
1593
1594    disp->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers);
1595}
1596