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