blob: 0d13e66095448b77f0b70153bfe3c5092c37cbb1 [file] [log] [blame]
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001/*
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 */
Courtney Goeltzenleuchterb620ace2015-07-05 11:28:29 -060024#define _GNU_SOURCE
Jon Ashburnfce93d92015-05-12 17:26:48 -060025#include <stdlib.h>
26#include <string.h>
Jon Ashburn2139a3e2015-05-06 09:02:10 -060027
Tobin Ehlis7a51d902015-07-03 10:34:49 -060028#include "vk_loader_platform.h"
Jon Ashburn2139a3e2015-05-06 09:02:10 -060029#include "loader.h"
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -060030#include "debug_report.h"
Ian Elliott1d73e662015-07-06 14:36:13 -060031#include "wsi_swapchain.h"
Jon Ashburn2139a3e2015-05-06 09:02:10 -060032
Tobin Ehlis3126f012015-05-13 11:57:18 -060033#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
Jon Ashburn2139a3e2015-05-06 09:02:10 -060039/* Trampoline entrypoints */
Jon Ashburnfce93d92015-05-12 17:26:48 -060040LOADER_EXPORT VkResult VKAPI vkCreateInstance(
Courtney Goeltzenleuchter70c4ebc2015-06-08 15:13:50 -060041 const VkInstanceCreateInfo* pCreateInfo,
42 VkInstance* pInstance)
Jon Ashburnfce93d92015-05-12 17:26:48 -060043{
44 struct loader_instance *ptr_instance = NULL;
Jon Ashburnfce93d92015-05-12 17:26:48 -060045 VkResult res = VK_ERROR_INITIALIZATION_FAILED;
Jon Ashburnfce93d92015-05-12 17:26:48 -060046
Jon Ashburn754f1992015-08-18 18:04:47 -060047 loader_platform_thread_once(&once_init, loader_initialize);
Jon Ashburnfce93d92015-05-12 17:26:48 -060048
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -060049 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 }
Jon Ashburnfce93d92015-05-12 17:26:48 -060060 if (ptr_instance == NULL) {
61 return VK_ERROR_OUT_OF_HOST_MEMORY;
62 }
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -060063
Jon Ashburn413d6582015-08-28 15:19:27 -060064 tls_instance = ptr_instance;
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -060065 loader_platform_thread_lock_mutex(&loader_lock);
Jon Ashburn182b8302015-08-11 14:49:54 -060066 memset(ptr_instance, 0, sizeof(struct loader_instance));
Jon Ashburncedc15f2015-05-21 18:13:33 -060067
Courtney Goeltzenleuchterb620ace2015-07-05 11:28:29 -060068 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
Jon Ashburne9ca8fa2015-08-20 16:35:30 -060076 /* 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));
Jon Ashburne58f1a32015-08-28 13:38:21 -060081 loader_layer_scan(ptr_instance,
82
83
84 &ptr_instance->instance_layer_list,
85 &ptr_instance->device_layer_list);
Jon Ashburne9ca8fa2015-08-20 16:35:30 -060086
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
Jon Ashburn754f1992015-08-18 18:04:47 -060097 /* Scan/discover all ICD libraries */
98 memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
Jon Ashburne58f1a32015-08-28 13:38:21 -060099 loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
Jon Ashburn754f1992015-08-18 18:04:47 -0600100
Jon Ashburncfe4e682015-08-14 12:51:47 -0600101 /* get extensions from all ICD's, merge so no duplicates, then validate */
Jon Ashburne58f1a32015-08-28 13:38:21 -0600102 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);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600108 if (res != VK_SUCCESS) {
Jon Ashburne58f1a32015-08-28 13:38:21 -0600109 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);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600115 loader_platform_thread_unlock_mutex(&loader_lock);
116 loader_heap_free(ptr_instance, ptr_instance);
117 return res;
118 }
119
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600120 ptr_instance->disp = loader_heap_alloc(
121 ptr_instance,
122 sizeof(VkLayerInstanceDispatchTable),
123 VK_SYSTEM_ALLOC_TYPE_INTERNAL);
124 if (ptr_instance->disp == NULL) {
Jon Ashburne58f1a32015-08-28 13:38:21 -0600125 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);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600133 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600134 loader_heap_free(ptr_instance, ptr_instance);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600135 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
Jon Ashburn182b8302015-08-11 14:49:54 -0600141 /* activate any layers on instance chain */
Jon Ashburne58f1a32015-08-28 13:38:21 -0600142 res = loader_enable_instance_layers(ptr_instance,
143 pCreateInfo,
144 &ptr_instance->instance_layer_list);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600145 if (res != VK_SUCCESS) {
Jon Ashburne58f1a32015-08-28 13:38:21 -0600146 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);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600154 loader.instances = ptr_instance->next;
155 loader_platform_thread_unlock_mutex(&loader_lock);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600156 loader_heap_free(ptr_instance, ptr_instance->disp);
157 loader_heap_free(ptr_instance, ptr_instance);
158 return res;
159 }
Jon Ashburn182b8302015-08-11 14:49:54 -0600160 loader_activate_instance_layers(ptr_instance);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600161
Ian Elliott1d73e662015-07-06 14:36:13 -0600162 wsi_swapchain_create_instance(ptr_instance, pCreateInfo);
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600163 debug_report_create_instance(ptr_instance, pCreateInfo);
Jon Ashburncedc15f2015-05-21 18:13:33 -0600164
Jon Ashburnfce93d92015-05-12 17:26:48 -0600165
Jon Ashburnfce93d92015-05-12 17:26:48 -0600166 *pInstance = (VkInstance) ptr_instance;
Jon Ashburna179dcf2015-05-21 17:42:17 -0600167
168 res = ptr_instance->disp->CreateInstance(pCreateInfo, pInstance);
169
Courtney Goeltzenleuchter23b5f8d2015-06-17 20:51:59 -0600170 /*
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
Jon Ashburnb40f2562015-05-29 13:15:39 -0600178 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburnfce93d92015-05-12 17:26:48 -0600179 return res;
180}
181
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600182LOADER_EXPORT void VKAPI vkDestroyInstance(
Jon Ashburnfce93d92015-05-12 17:26:48 -0600183 VkInstance instance)
184{
185 const VkLayerInstanceDispatchTable *disp;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600186 disp = loader_get_instance_dispatch(instance);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600187
Jon Ashburnb40f2562015-05-29 13:15:39 -0600188 loader_platform_thread_lock_mutex(&loader_lock);
189
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600190 disp->DestroyInstance(instance);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600191
Courtney Goeltzenleuchter3d8dc1f2015-06-08 15:09:22 -0600192 struct loader_instance *ptr_instance = loader_instance(instance);
193 loader_deactivate_instance_layers(ptr_instance);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600194 loader_heap_free(ptr_instance, ptr_instance->disp);
195 loader_heap_free(ptr_instance, ptr_instance);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600196 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburnfce93d92015-05-12 17:26:48 -0600197}
Jon Ashburn2666e2f2015-05-15 15:09:35 -0600198
Jon Ashburnfce93d92015-05-12 17:26:48 -0600199LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices(
200 VkInstance instance,
201 uint32_t* pPhysicalDeviceCount,
202 VkPhysicalDevice* pPhysicalDevices)
203{
204 const VkLayerInstanceDispatchTable *disp;
Jon Ashburnb40f2562015-05-29 13:15:39 -0600205 VkResult res;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600206 disp = loader_get_instance_dispatch(instance);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600207
208 loader_platform_thread_lock_mutex(&loader_lock);
209 res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
Jon Ashburnfce93d92015-05-12 17:26:48 -0600210 pPhysicalDevices);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600211 loader_platform_thread_unlock_mutex(&loader_lock);
212 return res;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600213}
214
Jon Ashburn4e189562015-07-23 18:49:07 -0600215
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
Courtney Goeltzenleuchter83c95f82015-09-10 13:44:12 -0600245LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties)
Jon Ashburn4e189562015-07-23 18:49:07 -0600246{
247 const VkLayerInstanceDispatchTable *disp;
248 VkResult res;
249
250 disp = loader_get_instance_dispatch(physicalDevice);
Courtney Goeltzenleuchter83c95f82015-09-10 13:44:12 -0600251 res = disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties);
Jon Ashburn4e189562015-07-23 18:49:07 -0600252 return res;
253}
254
Tony Barbour426b9052015-06-24 16:06:58 -0600255LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties(
Jon Ashburnfce93d92015-05-12 17:26:48 -0600256 VkPhysicalDevice gpu,
Tony Barbour426b9052015-06-24 16:06:58 -0600257 VkPhysicalDeviceProperties* pProperties)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600258{
Jon Ashburn2666e2f2015-05-15 15:09:35 -0600259 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600260 VkResult res;
261
Jon Ashburn2666e2f2015-05-15 15:09:35 -0600262 disp = loader_get_instance_dispatch(gpu);
Tony Barbour426b9052015-06-24 16:06:58 -0600263 res = disp->GetPhysicalDeviceProperties(gpu, pProperties);
Tony Barbour426b9052015-06-24 16:06:58 -0600264 return res;
265}
266
Cody Northropef72e2a2015-08-03 17:04:53 -0600267LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueFamilyProperties(
Tony Barbour426b9052015-06-24 16:06:58 -0600268 VkPhysicalDevice gpu,
Cody Northropef72e2a2015-08-03 17:04:53 -0600269 uint32_t* pCount,
270 VkQueueFamilyProperties* pQueueProperties)
Tony Barbour426b9052015-06-24 16:06:58 -0600271{
272 const VkLayerInstanceDispatchTable *disp;
273 VkResult res;
274
275 disp = loader_get_instance_dispatch(gpu);
Cody Northropef72e2a2015-08-03 17:04:53 -0600276 res = disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pCount, pQueueProperties);
Tony Barbour426b9052015-06-24 16:06:58 -0600277 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);
Tony Barbour426b9052015-06-24 16:06:58 -0600288 res = disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600289 return res;
290}
291
Jon Ashburn2666e2f2015-05-15 15:09:35 -0600292LOADER_EXPORT VkResult VKAPI vkCreateDevice(
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600293 VkPhysicalDevice gpu,
294 const VkDeviceCreateInfo* pCreateInfo,
295 VkDevice* pDevice)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600296{
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600297 VkResult res;
298
Jon Ashburnb40f2562015-05-29 13:15:39 -0600299 loader_platform_thread_lock_mutex(&loader_lock);
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600300
301 res = loader_CreateDevice(gpu, pCreateInfo, pDevice);
302
Jon Ashburnb40f2562015-05-29 13:15:39 -0600303 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600304 return res;
305}
306
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600307LOADER_EXPORT void VKAPI vkDestroyDevice(VkDevice device)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600308{
309 const VkLayerDispatchTable *disp;
Jon Ashburne58f1a32015-08-28 13:38:21 -0600310 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;
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600313 disp = loader_get_dispatch(device);
314
Jon Ashburnb40f2562015-05-29 13:15:39 -0600315 loader_platform_thread_lock_mutex(&loader_lock);
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600316 disp->DestroyDevice(device);
Jon Ashburne58f1a32015-08-28 13:38:21 -0600317 loader_remove_logical_device(inst, device);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600318 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600319}
320
Tony Barbour426b9052015-06-24 16:06:58 -0600321LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties(
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600322 VkPhysicalDevice physicalDevice,
323 const char* pLayerName,
324 uint32_t* pCount,
325 VkExtensionProperties* pProperties)
Jon Ashburnb40f2562015-05-29 13:15:39 -0600326{
327 VkResult res;
328
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600329 loader_platform_thread_lock_mutex(&loader_lock);
Jon Ashburn0bf6a182015-07-16 17:19:31 -0600330 //TODO convert over to using instance chain dispatch
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600331 res = loader_GetPhysicalDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties);
332 loader_platform_thread_unlock_mutex(&loader_lock);
Tony Barbour426b9052015-06-24 16:06:58 -0600333 return res;
334}
335
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600336LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLayerProperties(
337 VkPhysicalDevice physicalDevice,
338 uint32_t* pCount,
339 VkLayerProperties* pProperties)
Tony Barbour426b9052015-06-24 16:06:58 -0600340{
341 VkResult res;
342
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600343 loader_platform_thread_lock_mutex(&loader_lock);
Jon Ashburn0bf6a182015-07-16 17:19:31 -0600344 //TODO convert over to using instance chain dispatch
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600345 res = loader_GetPhysicalDeviceLayerProperties(physicalDevice, pCount, pProperties);
346 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburnfce93d92015-05-12 17:26:48 -0600347 return res;
348}
349
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600350LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600401LOADER_EXPORT void VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600402{
403 const VkLayerDispatchTable *disp;
404
405 disp = loader_get_dispatch(device);
406
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600407 disp->FreeMemory(device, mem);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600408}
409
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600410LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600419LOADER_EXPORT void VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600420{
421 const VkLayerDispatchTable *disp;
422
423 disp = loader_get_dispatch(device);
424
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600425 disp->UnmapMemory(device, mem);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600426}
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
Courtney Goeltzenleuchterd040c5c2015-07-09 21:57:28 -0600446LOADER_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
Tony Barbourde4124d2015-07-03 10:33:54 -0600455LOADER_EXPORT VkResult VKAPI vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600456{
457 const VkLayerDispatchTable *disp;
458
Mark Lobodzinskifb9f5642015-05-11 17:21:15 -0500459 disp = loader_get_dispatch(device);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600460
Tony Barbourde4124d2015-07-03 10:33:54 -0600461 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);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600471}
472
Jon Ashburn4e189562015-07-23 18:49:07 -0600473LOADER_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
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600491LOADER_EXPORT VkResult VKAPI vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pNumRequirements, VkSparseImageMemoryRequirements* pSparseMemoryRequirements)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600492{
493 const VkLayerDispatchTable *disp;
494
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600495 disp = loader_get_dispatch(device);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600496
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600497 return disp->GetImageSparseMemoryRequirements(device, image, pNumRequirements, pSparseMemoryRequirements);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600498}
499
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600500LOADER_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
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600509LOADER_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
Jon Ashburn4e189562015-07-23 18:49:07 -0600518LOADER_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
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -0600527LOADER_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);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600534}
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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600545LOADER_EXPORT void VKAPI vkDestroyFence(VkDevice device, VkFence fence)
Tony Barbourde4124d2015-07-03 10:33:54 -0600546{
547 const VkLayerDispatchTable *disp;
548
549 disp = loader_get_dispatch(device);
550
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600551 disp->DestroyFence(device, fence);
Tony Barbourde4124d2015-07-03 10:33:54 -0600552}
553
Courtney Goeltzenleuchterf2e33ad2015-06-18 17:28:20 -0600554LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600555{
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
Courtney Goeltzenleuchter1f41f542015-07-09 11:44:38 -0600572LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600573{
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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600590LOADER_EXPORT void VKAPI vkDestroySemaphore(VkDevice device, VkSemaphore semaphore)
Tony Barbourde4124d2015-07-03 10:33:54 -0600591{
592 const VkLayerDispatchTable *disp;
593
594 disp = loader_get_dispatch(device);
595
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600596 disp->DestroySemaphore(device, semaphore);
Tony Barbourde4124d2015-07-03 10:33:54 -0600597}
598
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600599LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600626LOADER_EXPORT void VKAPI vkDestroyEvent(VkDevice device, VkEvent event)
Tony Barbourde4124d2015-07-03 10:33:54 -0600627{
628 const VkLayerDispatchTable *disp;
629
630 disp = loader_get_dispatch(device);
631
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600632 disp->DestroyEvent(device, event);
Tony Barbourde4124d2015-07-03 10:33:54 -0600633}
634
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600635LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600671LOADER_EXPORT void VKAPI vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool)
Tony Barbourde4124d2015-07-03 10:33:54 -0600672{
673 const VkLayerDispatchTable *disp;
674
675 disp = loader_get_dispatch(device);
676
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600677 disp->DestroyQueryPool(device, queryPool);
Tony Barbourde4124d2015-07-03 10:33:54 -0600678}
679
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600680LOADER_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
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600689LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600698LOADER_EXPORT void VKAPI vkDestroyBuffer(VkDevice device, VkBuffer buffer)
Tony Barbourde4124d2015-07-03 10:33:54 -0600699{
700 const VkLayerDispatchTable *disp;
701
702 disp = loader_get_dispatch(device);
703
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600704 disp->DestroyBuffer(device, buffer);
Tony Barbourde4124d2015-07-03 10:33:54 -0600705}
706
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600707LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600716LOADER_EXPORT void VKAPI vkDestroyBufferView(VkDevice device, VkBufferView bufferView)
Tony Barbourde4124d2015-07-03 10:33:54 -0600717{
718 const VkLayerDispatchTable *disp;
719
720 disp = loader_get_dispatch(device);
721
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600722 disp->DestroyBufferView(device, bufferView);
Tony Barbourde4124d2015-07-03 10:33:54 -0600723}
724
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600725LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600734LOADER_EXPORT void VKAPI vkDestroyImage(VkDevice device, VkImage image)
Tony Barbourde4124d2015-07-03 10:33:54 -0600735{
736 const VkLayerDispatchTable *disp;
737
738 disp = loader_get_dispatch(device);
739
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600740 disp->DestroyImage(device, image);
Tony Barbourde4124d2015-07-03 10:33:54 -0600741}
742
Tony Barbour426b9052015-06-24 16:06:58 -0600743LOADER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600744{
745 const VkLayerDispatchTable *disp;
746
747 disp = loader_get_dispatch(device);
748
Tony Barbour426b9052015-06-24 16:06:58 -0600749 return disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600750}
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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600761LOADER_EXPORT void VKAPI vkDestroyImageView(VkDevice device, VkImageView imageView)
Tony Barbourde4124d2015-07-03 10:33:54 -0600762{
763 const VkLayerDispatchTable *disp;
764
765 disp = loader_get_dispatch(device);
766
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600767 disp->DestroyImageView(device, imageView);
Tony Barbourde4124d2015-07-03 10:33:54 -0600768}
769
Courtney Goeltzenleuchter0b29b0d2015-06-24 18:24:19 -0600770LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600779LOADER_EXPORT void VKAPI vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule)
Tony Barbourde4124d2015-07-03 10:33:54 -0600780{
781 const VkLayerDispatchTable *disp;
782
783 disp = loader_get_dispatch(device);
784
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600785 disp->DestroyShaderModule(device, shaderModule);
Tony Barbourde4124d2015-07-03 10:33:54 -0600786}
787
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600788LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600797LOADER_EXPORT void VKAPI vkDestroyShader(VkDevice device, VkShader shader)
Tony Barbourde4124d2015-07-03 10:33:54 -0600798{
799 const VkLayerDispatchTable *disp;
800
801 disp = loader_get_dispatch(device);
802
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600803 disp->DestroyShader(device, shader);
Tony Barbourde4124d2015-07-03 10:33:54 -0600804}
805
Jon Ashburn0d60d272015-07-09 15:02:25 -0600806LOADER_EXPORT VkResult VKAPI vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, VkPipelineCache* pPipelineCache)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600807{
808 const VkLayerDispatchTable *disp;
809
810 disp = loader_get_dispatch(device);
811
Jon Ashburn0d60d272015-07-09 15:02:25 -0600812 return disp->CreatePipelineCache(device, pCreateInfo, pPipelineCache);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600813}
814
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600815LOADER_EXPORT void VKAPI vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600816{
817 const VkLayerDispatchTable *disp;
818
819 disp = loader_get_dispatch(device);
820
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600821 disp->DestroyPipelineCache(device, pipelineCache);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600822}
823
Jon Ashburn0d60d272015-07-09 15:02:25 -0600824LOADER_EXPORT size_t VKAPI vkGetPipelineCacheSize(VkDevice device, VkPipelineCache pipelineCache)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600825{
826 const VkLayerDispatchTable *disp;
827
828 disp = loader_get_dispatch(device);
829
Jon Ashburn0d60d272015-07-09 15:02:25 -0600830 return disp->GetPipelineCacheSize(device, pipelineCache);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600831}
832
Jon Ashburn0d60d272015-07-09 15:02:25 -0600833LOADER_EXPORT VkResult VKAPI vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, void* pData)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600834{
835 const VkLayerDispatchTable *disp;
836
837 disp = loader_get_dispatch(device);
838
Jon Ashburn0d60d272015-07-09 15:02:25 -0600839 return disp->GetPipelineCacheData(device, pipelineCache, pData);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600840}
841
Jon Ashburn0d60d272015-07-09 15:02:25 -0600842LOADER_EXPORT VkResult VKAPI vkMergePipelineCaches(VkDevice device, VkPipelineCache destCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600843{
844 const VkLayerDispatchTable *disp;
845
846 disp = loader_get_dispatch(device);
847
Jon Ashburn0d60d272015-07-09 15:02:25 -0600848 return disp->MergePipelineCaches(device, destCache, srcCacheCount, pSrcCaches);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600849}
850
Jon Ashburn0d60d272015-07-09 15:02:25 -0600851LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t count, const VkGraphicsPipelineCreateInfo* pCreateInfos, VkPipeline* pPipelines)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600852{
853 const VkLayerDispatchTable *disp;
854
855 disp = loader_get_dispatch(device);
856
Jon Ashburn0d60d272015-07-09 15:02:25 -0600857 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);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600867}
868
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600869LOADER_EXPORT void VKAPI vkDestroyPipeline(VkDevice device, VkPipeline pipeline)
Tony Barbourde4124d2015-07-03 10:33:54 -0600870{
871 const VkLayerDispatchTable *disp;
872
873 disp = loader_get_dispatch(device);
874
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600875 disp->DestroyPipeline(device, pipeline);
Tony Barbourde4124d2015-07-03 10:33:54 -0600876}
877
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600878LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600887LOADER_EXPORT void VKAPI vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout)
Tony Barbourde4124d2015-07-03 10:33:54 -0600888{
889 const VkLayerDispatchTable *disp;
890
891 disp = loader_get_dispatch(device);
892
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600893 disp->DestroyPipelineLayout(device, pipelineLayout);
Tony Barbourde4124d2015-07-03 10:33:54 -0600894}
895
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600896LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600905LOADER_EXPORT void VKAPI vkDestroySampler(VkDevice device, VkSampler sampler)
Tony Barbourde4124d2015-07-03 10:33:54 -0600906{
907 const VkLayerDispatchTable *disp;
908
909 disp = loader_get_dispatch(device);
910
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600911 disp->DestroySampler(device, sampler);
Tony Barbourde4124d2015-07-03 10:33:54 -0600912}
913
914
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600915LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600924LOADER_EXPORT void VKAPI vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout)
Tony Barbourde4124d2015-07-03 10:33:54 -0600925{
926 const VkLayerDispatchTable *disp;
927
928 disp = loader_get_dispatch(device);
929
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600930 disp->DestroyDescriptorSetLayout(device, descriptorSetLayout);
Tony Barbourde4124d2015-07-03 10:33:54 -0600931}
932
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600933LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600942LOADER_EXPORT void VKAPI vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool)
Tony Barbourde4124d2015-07-03 10:33:54 -0600943{
944 const VkLayerDispatchTable *disp;
945
946 disp = loader_get_dispatch(device);
947
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600948 disp->DestroyDescriptorPool(device, descriptorPool);
Tony Barbourde4124d2015-07-03 10:33:54 -0600949}
950
951
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600952LOADER_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
Cody Northropc8aa4a52015-08-03 12:47:29 -0600961LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600962{
963 const VkLayerDispatchTable *disp;
964
965 disp = loader_get_dispatch(device);
966
Cody Northropc8aa4a52015-08-03 12:47:29 -0600967 return disp->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600968}
969
Tony Barbourb857d312015-07-10 10:50:45 -0600970LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600979LOADER_EXPORT void VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600980{
981 const VkLayerDispatchTable *disp;
982
983 disp = loader_get_dispatch(device);
984
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600985 disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600986}
987
Tony Barbourde4124d2015-07-03 10:33:54 -0600988LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicViewportStateCreateInfo* pCreateInfo, VkDynamicViewportState* pState)
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600989{
990 const VkLayerDispatchTable *disp;
991
992 disp = loader_get_dispatch(device);
993
994 return disp->CreateDynamicViewportState(device, pCreateInfo, pState);
995}
996
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600997LOADER_EXPORT void VKAPI vkDestroyDynamicViewportState(VkDevice device, VkDynamicViewportState dynamicViewportState)
Tony Barbourde4124d2015-07-03 10:33:54 -0600998{
999 const VkLayerDispatchTable *disp;
1000
1001 disp = loader_get_dispatch(device);
1002
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001003 disp->DestroyDynamicViewportState(device, dynamicViewportState);
Tony Barbourde4124d2015-07-03 10:33:54 -06001004}
1005
Cody Northrope4bc6942015-08-26 10:01:32 -06001006LOADER_EXPORT VkResult VKAPI vkCreateDynamicLineWidthState(VkDevice device, const VkDynamicLineWidthStateCreateInfo* pCreateInfo, VkDynamicLineWidthState* pState)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001007{
1008 const VkLayerDispatchTable *disp;
1009
1010 disp = loader_get_dispatch(device);
1011
Cody Northrope4bc6942015-08-26 10:01:32 -06001012 return disp->CreateDynamicLineWidthState(device, pCreateInfo, pState);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001013}
1014
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001015LOADER_EXPORT void VKAPI vkDestroyDynamicLineWidthState(VkDevice device, VkDynamicLineWidthState dynamicLineWidthState)
Tony Barbourde4124d2015-07-03 10:33:54 -06001016{
1017 const VkLayerDispatchTable *disp;
1018
1019 disp = loader_get_dispatch(device);
1020
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001021 disp->DestroyDynamicLineWidthState(device, dynamicLineWidthState);
Cody Northropf5bd2252015-08-17 11:10:49 -06001022}
1023
Cody Northrope4bc6942015-08-26 10:01:32 -06001024LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthBiasState(VkDevice device, const VkDynamicDepthBiasStateCreateInfo* pCreateInfo, VkDynamicDepthBiasState* pState)
Cody Northropf5bd2252015-08-17 11:10:49 -06001025{
1026 const VkLayerDispatchTable *disp;
1027
1028 disp = loader_get_dispatch(device);
1029
Cody Northrope4bc6942015-08-26 10:01:32 -06001030 return disp->CreateDynamicDepthBiasState(device, pCreateInfo, pState);
Cody Northropf5bd2252015-08-17 11:10:49 -06001031}
1032
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001033LOADER_EXPORT void VKAPI vkDestroyDynamicDepthBiasState(VkDevice device, VkDynamicDepthBiasState dynamicDepthBiasState)
Cody Northropf5bd2252015-08-17 11:10:49 -06001034{
1035 const VkLayerDispatchTable *disp;
1036
1037 disp = loader_get_dispatch(device);
1038
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001039 disp->DestroyDynamicDepthBiasState(device, dynamicDepthBiasState);
Tony Barbourde4124d2015-07-03 10:33:54 -06001040}
1041
Cody Northrope4bc6942015-08-26 10:01:32 -06001042LOADER_EXPORT VkResult VKAPI vkCreateDynamicBlendState(VkDevice device, const VkDynamicBlendStateCreateInfo* pCreateInfo, VkDynamicBlendState* pState)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001043{
1044 const VkLayerDispatchTable *disp;
1045
1046 disp = loader_get_dispatch(device);
1047
Cody Northrope4bc6942015-08-26 10:01:32 -06001048 return disp->CreateDynamicBlendState(device, pCreateInfo, pState);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001049}
1050
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001051LOADER_EXPORT void VKAPI vkDestroyDynamicBlendState(VkDevice device, VkDynamicBlendState dynamicBlendState)
Tony Barbourde4124d2015-07-03 10:33:54 -06001052{
1053 const VkLayerDispatchTable *disp;
1054
1055 disp = loader_get_dispatch(device);
1056
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001057 disp->DestroyDynamicBlendState(device, dynamicBlendState);
Tony Barbourde4124d2015-07-03 10:33:54 -06001058}
1059
Cody Northrope4bc6942015-08-26 10:01:32 -06001060LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthBoundsState(VkDevice device, const VkDynamicDepthBoundsStateCreateInfo* pCreateInfo, VkDynamicDepthBoundsState* pState)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001061{
1062 const VkLayerDispatchTable *disp;
1063
1064 disp = loader_get_dispatch(device);
1065
Cody Northrope4bc6942015-08-26 10:01:32 -06001066 return disp->CreateDynamicDepthBoundsState(device, pCreateInfo, pState);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001067}
1068
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001069LOADER_EXPORT void VKAPI vkDestroyDynamicDepthBoundsState(VkDevice device, VkDynamicDepthBoundsState dynamicDepthBoundsState)
Tony Barbourde4124d2015-07-03 10:33:54 -06001070{
1071 const VkLayerDispatchTable *disp;
1072
1073 disp = loader_get_dispatch(device);
1074
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001075 disp->DestroyDynamicDepthBoundsState(device, dynamicDepthBoundsState);
Cody Northrop2605cb02015-08-18 15:21:16 -06001076}
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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001087LOADER_EXPORT void VKAPI vkDestroyDynamicStencilState(VkDevice device, VkDynamicStencilState dynamicStencilState)
Cody Northrop2605cb02015-08-18 15:21:16 -06001088{
1089 const VkLayerDispatchTable *disp;
1090
1091 disp = loader_get_dispatch(device);
1092
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001093 disp->DestroyDynamicStencilState(device, dynamicStencilState);
Tony Barbourde4124d2015-07-03 10:33:54 -06001094}
1095
Jon Ashburn4e189562015-07-23 18:49:07 -06001096LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001105LOADER_EXPORT void VKAPI vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer)
Jon Ashburn4e189562015-07-23 18:49:07 -06001106{
1107 const VkLayerDispatchTable *disp;
1108
1109 disp = loader_get_dispatch(device);
1110
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001111 disp->DestroyFramebuffer(device, framebuffer);
Jon Ashburn4e189562015-07-23 18:49:07 -06001112}
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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001123LOADER_EXPORT void VKAPI vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass)
Jon Ashburn4e189562015-07-23 18:49:07 -06001124{
1125 const VkLayerDispatchTable *disp;
1126
1127 disp = loader_get_dispatch(device);
1128
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001129 disp->DestroyRenderPass(device, renderPass);
Jon Ashburn4e189562015-07-23 18:49:07 -06001130}
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
Cody Northropf02f9f82015-07-09 18:08:05 -06001141LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001150LOADER_EXPORT void VKAPI vkDestroyCommandPool(VkDevice device, VkCmdPool cmdPool)
Cody Northropf02f9f82015-07-09 18:08:05 -06001151{
1152 const VkLayerDispatchTable *disp;
1153
1154 disp = loader_get_dispatch(device);
1155
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001156 disp->DestroyCommandPool(device, cmdPool);
Cody Northropf02f9f82015-07-09 18:08:05 -06001157}
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
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001168LOADER_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
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001183LOADER_EXPORT void VKAPI vkDestroyCommandBuffer(VkDevice device, VkCmdBuffer cmdBuffer)
Tony Barbourde4124d2015-07-03 10:33:54 -06001184{
1185 const VkLayerDispatchTable *disp;
1186
1187 disp = loader_get_dispatch(device);
1188
Mark Lobodzinski67b42b72015-09-07 13:59:43 -06001189 disp->DestroyCommandBuffer(device, cmdBuffer);
Tony Barbourde4124d2015-07-03 10:33:54 -06001190}
1191
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001192LOADER_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
Cody Northropf02f9f82015-07-09 18:08:05 -06001210LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer, VkCmdBufferResetFlags flags)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001211{
1212 const VkLayerDispatchTable *disp;
1213
1214 disp = loader_get_dispatch(cmdBuffer);
1215
Cody Northropf02f9f82015-07-09 18:08:05 -06001216 return disp->ResetCommandBuffer(cmdBuffer, flags);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001217}
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
Tony Barbourde4124d2015-07-03 10:33:54 -06001228LOADER_EXPORT void VKAPI vkCmdBindDynamicViewportState(VkCmdBuffer cmdBuffer, VkDynamicViewportState state)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001229{
1230 const VkLayerDispatchTable *disp;
1231
1232 disp = loader_get_dispatch(cmdBuffer);
1233
Tony Barbourde4124d2015-07-03 10:33:54 -06001234 disp->CmdBindDynamicViewportState(cmdBuffer, state);
1235}
1236
Cody Northrope4bc6942015-08-26 10:01:32 -06001237LOADER_EXPORT void VKAPI vkCmdBindDynamicLineWidthState(VkCmdBuffer cmdBuffer, VkDynamicLineWidthState state)
Tony Barbourde4124d2015-07-03 10:33:54 -06001238{
1239 const VkLayerDispatchTable *disp;
1240
1241 disp = loader_get_dispatch(cmdBuffer);
1242
Cody Northrope4bc6942015-08-26 10:01:32 -06001243 disp->CmdBindDynamicLineWidthState(cmdBuffer, state);
Cody Northropf5bd2252015-08-17 11:10:49 -06001244}
1245
Cody Northrope4bc6942015-08-26 10:01:32 -06001246LOADER_EXPORT void VKAPI vkCmdBindDynamicDepthBiasState(VkCmdBuffer cmdBuffer, VkDynamicDepthBiasState state)
Cody Northropf5bd2252015-08-17 11:10:49 -06001247{
1248 const VkLayerDispatchTable *disp;
1249
1250 disp = loader_get_dispatch(cmdBuffer);
1251
Cody Northrope4bc6942015-08-26 10:01:32 -06001252 disp->CmdBindDynamicDepthBiasState(cmdBuffer, state);
Tony Barbourde4124d2015-07-03 10:33:54 -06001253}
1254
Cody Northrope4bc6942015-08-26 10:01:32 -06001255LOADER_EXPORT void VKAPI vkCmdBindDynamicBlendState(VkCmdBuffer cmdBuffer, VkDynamicBlendState state)
Tony Barbourde4124d2015-07-03 10:33:54 -06001256{
1257 const VkLayerDispatchTable *disp;
1258
1259 disp = loader_get_dispatch(cmdBuffer);
1260
Cody Northrope4bc6942015-08-26 10:01:32 -06001261 disp->CmdBindDynamicBlendState(cmdBuffer, state);
Tony Barbourde4124d2015-07-03 10:33:54 -06001262}
1263
Cody Northrope4bc6942015-08-26 10:01:32 -06001264LOADER_EXPORT void VKAPI vkCmdBindDynamicDepthBoundsState(VkCmdBuffer cmdBuffer, VkDynamicDepthBoundsState state)
Tony Barbourde4124d2015-07-03 10:33:54 -06001265{
1266 const VkLayerDispatchTable *disp;
1267
1268 disp = loader_get_dispatch(cmdBuffer);
1269
Cody Northrope4bc6942015-08-26 10:01:32 -06001270 disp->CmdBindDynamicDepthBoundsState(cmdBuffer, state);
Cody Northrop2605cb02015-08-18 15:21:16 -06001271}
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);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001280}
1281
Mark Lobodzinskia65c4632015-06-15 13:21:21 -06001282LOADER_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)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001283{
1284 const VkLayerDispatchTable *disp;
1285
1286 disp = loader_get_dispatch(cmdBuffer);
1287
Mark Lobodzinskia65c4632015-06-15 13:21:21 -06001288 disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001289}
1290
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001291LOADER_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
Jon Ashburn4e189562015-07-23 18:49:07 -06001300LOADER_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
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001309LOADER_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
Mark Lobodzinski20f68592015-05-22 14:43:25 -05001381LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001382{
1383 const VkLayerDispatchTable *disp;
1384
1385 disp = loader_get_dispatch(cmdBuffer);
1386
Mark Lobodzinski20f68592015-05-22 14:43:25 -05001387 disp->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001388}
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
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001408LOADER_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
Chris Forbese3105972015-06-24 14:34:53 +12001426LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001427{
1428 const VkLayerDispatchTable *disp;
1429
1430 disp = loader_get_dispatch(cmdBuffer);
1431
1432 disp->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges);
1433}
1434
Chris Forbes2951d7d2015-06-22 17:21:59 +12001435LOADER_EXPORT void VKAPI vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001436{
1437 const VkLayerDispatchTable *disp;
1438
1439 disp = loader_get_dispatch(cmdBuffer);
1440
Chris Forbes2951d7d2015-06-22 17:21:59 +12001441 disp->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges);
1442}
1443
Chris Forbese3105972015-06-24 14:34:53 +12001444LOADER_EXPORT void VKAPI vkCmdClearColorAttachment(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects)
Chris Forbes2951d7d2015-06-22 17:21:59 +12001445{
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);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001460}
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
Tony Barbourc2e987e2015-06-29 16:20:35 -06001471LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001472{
1473 const VkLayerDispatchTable *disp;
1474
1475 disp = loader_get_dispatch(cmdBuffer);
1476
Tony Barbourc2e987e2015-06-29 16:20:35 -06001477 disp->CmdSetEvent(cmdBuffer, event, stageMask);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001478}
1479
Tony Barbourc2e987e2015-06-29 16:20:35 -06001480LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001481{
1482 const VkLayerDispatchTable *disp;
1483
1484 disp = loader_get_dispatch(cmdBuffer);
1485
Tony Barbourc2e987e2015-06-29 16:20:35 -06001486 disp->CmdResetEvent(cmdBuffer, event, stageMask);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001487}
1488
Courtney Goeltzenleuchterd9ba3422015-07-12 12:58:58 -06001489LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void* const* ppMemBarriers)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001490{
1491 const VkLayerDispatchTable *disp;
1492
1493 disp = loader_get_dispatch(cmdBuffer);
1494
Tony Barbourc2e987e2015-06-29 16:20:35 -06001495 disp->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001496}
1497
Courtney Goeltzenleuchter82b348f2015-07-12 13:07:46 -06001498LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags destStageMask, VkBool32 byRegion, uint32_t memBarrierCount, const void* const* ppMemBarriers)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001499{
1500 const VkLayerDispatchTable *disp;
1501
1502 disp = loader_get_dispatch(cmdBuffer);
1503
Courtney Goeltzenleuchter82b348f2015-07-12 13:07:46 -06001504 disp->CmdPipelineBarrier(cmdBuffer, srcStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001505}
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
Jon Ashburn4e189562015-07-23 18:49:07 -06001552LOADER_EXPORT void VKAPI vkCmdPushConstants(VkCmdBuffer cmdBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t start, uint32_t length, const void* values)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001553{
1554 const VkLayerDispatchTable *disp;
1555
Jon Ashburn4e189562015-07-23 18:49:07 -06001556 disp = loader_get_dispatch(cmdBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001557
Courtney Goeltzenleuchtera375b622015-07-27 14:04:01 -06001558 disp->CmdPushConstants(cmdBuffer, layout, stageFlags, start, length, values);
Tony Barbourde4124d2015-07-03 10:33:54 -06001559}
1560
Chia-I Wuc278df82015-07-07 11:50:03 +08001561LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkRenderPassContents contents)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001562{
1563 const VkLayerDispatchTable *disp;
1564
1565 disp = loader_get_dispatch(cmdBuffer);
1566
Chia-I Wuc278df82015-07-07 11:50:03 +08001567 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);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001577}
1578
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08001579LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer)
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001580{
1581 const VkLayerDispatchTable *disp;
1582
1583 disp = loader_get_dispatch(cmdBuffer);
1584
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08001585 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);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001595}