blob: a26d8c5a4d814983ef0f9fc5571d6779843b340a [file] [log] [blame]
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001/*
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002 *
Jon Ashburn44aed662016-02-02 17:47:28 -07003 * Copyright (c) 2015-2016 The Khronos Group Inc.
4 * Copyright (c) 2015-2016 Valve Corporation
5 * Copyright (c) 2015-2016 LunarG, Inc.
Courtney Goeltzenleuchterebbb96d2015-12-02 14:53:22 -07006 * Copyright (C) 2015 Google Inc.
Jon Ashburn2139a3e2015-05-06 09:02:10 -06007 *
Jon Ashburn44aed662016-02-02 17:47:28 -07008 * Permission is hereby granted, free of charge, to any person obtaining a copy
9 * of this software and/or associated documentation files (the "Materials"), to
10 * deal in the Materials without restriction, including without limitation the
11 * rights to use, copy, modify, merge, publish, distribute, sublicense, and/or
12 * sell copies of the Materials, and to permit persons to whom the Materials are
13 * furnished to do so, subject to the following conditions:
Jon Ashburn2139a3e2015-05-06 09:02:10 -060014 *
Jon Ashburn44aed662016-02-02 17:47:28 -070015 * The above copyright notice(s) and this permission notice shall be included in
16 * all copies or substantial portions of the Materials.
Jon Ashburn2139a3e2015-05-06 09:02:10 -060017 *
Jon Ashburn44aed662016-02-02 17:47:28 -070018 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
Jon Ashburn2139a3e2015-05-06 09:02:10 -060019 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
Jon Ashburn44aed662016-02-02 17:47:28 -070020 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT.
Courtney Goeltzenleuchter96cd7952015-10-30 11:14:30 -060021 *
Jon Ashburn44aed662016-02-02 17:47:28 -070022 * IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM,
23 * DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR
24 * OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE MATERIALS OR THE
25 * USE OR OTHER DEALINGS IN THE MATERIALS.
26 *
27 * Author: Courtney Goeltzenleuchter <courtney@lunarg.com>
Courtney Goeltzenleuchter96cd7952015-10-30 11:14:30 -060028 * Author: Jon Ashburn <jon@lunarg.com>
29 * Author: Tony Barbour <tony@LunarG.com>
Jon Ashburn44aed662016-02-02 17:47:28 -070030 * Author: Chia-I Wu <olv@lunarg.com>
Jon Ashburn2139a3e2015-05-06 09:02:10 -060031 */
Courtney Goeltzenleuchterb620ace2015-07-05 11:28:29 -060032#define _GNU_SOURCE
Jon Ashburnfce93d92015-05-12 17:26:48 -060033#include <stdlib.h>
34#include <string.h>
Jon Ashburn2139a3e2015-05-06 09:02:10 -060035
Tobin Ehlis7a51d902015-07-03 10:34:49 -060036#include "vk_loader_platform.h"
Jon Ashburn2139a3e2015-05-06 09:02:10 -060037#include "loader.h"
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -060038#include "debug_report.h"
Ian Elliotta81e8ac2015-10-30 15:28:23 -060039#include "wsi.h"
Jon Ashburna9c4a572016-02-26 13:14:27 -070040#include "gpa_helper.h"
41#include "table_ops.h"
Jon Ashburn2139a3e2015-05-06 09:02:10 -060042
Jon Ashburna9c4a572016-02-26 13:14:27 -070043/* Trampoline entrypoints are in this file for core Vulkan commands */
44/**
45 * Get an instance level or global level entry point address.
46 * @param instance
47 * @param pName
48 * @return
49 * If instance == NULL returns a global level functions only
50 * If instance is valid returns a trampoline entry point for all dispatchable
51 * Vulkan
52 * functions both core and extensions.
53 */
54LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
55vkGetInstanceProcAddr(VkInstance instance, const char *pName) {
56
57 void *addr;
58
59 addr = globalGetProcAddr(pName);
60 if (instance == VK_NULL_HANDLE) {
61 // get entrypoint addresses that are global (no dispatchable object)
62
63 return addr;
64 } else {
65 // if a global entrypoint return NULL
66 if (addr)
67 return NULL;
68 }
69
70 struct loader_instance *ptr_instance = loader_get_instance(instance);
71 if (ptr_instance == NULL)
72 return NULL;
73 // Return trampoline code for non-global entrypoints including any
74 // extensions.
75 // Device extensions are returned if a layer or ICD supports the extension.
76 // Instance extensions are returned if the extension is enabled and the
77 // loader
78 // or someone else supports the extension
79 return trampolineGetProcAddr(ptr_instance, pName);
80}
81
82/**
83 * Get a device level or global level entry point address.
84 * @param device
85 * @param pName
86 * @return
87 * If device is valid, returns a device relative entry point for device level
88 * entry points both core and extensions.
89 * Device relative means call down the device chain.
90 */
91LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL
92vkGetDeviceProcAddr(VkDevice device, const char *pName) {
93 void *addr;
94
95 /* for entrypoints that loader must handle (ie non-dispatchable or create
96 object)
97 make sure the loader entrypoint is returned */
98 addr = loader_non_passthrough_gdpa(pName);
99 if (addr) {
100 return addr;
101 }
102
103 /* Although CreateDevice is on device chain it's dispatchable object isn't
104 * a VkDevice or child of VkDevice so return NULL.
105 */
106 if (!strcmp(pName, "CreateDevice"))
107 return NULL;
108
109 /* return the dispatch table entrypoint for the fastest case */
110 const VkLayerDispatchTable *disp_table = *(VkLayerDispatchTable **)device;
111 if (disp_table == NULL)
112 return NULL;
113
114 addr = loader_lookup_device_dispatch_table(disp_table, pName);
115 if (addr)
116 return addr;
117
118 if (disp_table->GetDeviceProcAddr == NULL)
119 return NULL;
120 return disp_table->GetDeviceProcAddr(device, pName);
121}
122
123LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
124vkEnumerateInstanceExtensionProperties(const char *pLayerName,
125 uint32_t *pPropertyCount,
126 VkExtensionProperties *pProperties) {
127 struct loader_extension_list *global_ext_list = NULL;
128 struct loader_layer_list instance_layers;
129 struct loader_extension_list icd_extensions;
130 struct loader_icd_libs icd_libs;
131 uint32_t copy_size;
132
133 tls_instance = NULL;
134 memset(&icd_extensions, 0, sizeof(icd_extensions));
135 memset(&instance_layers, 0, sizeof(instance_layers));
136 loader_platform_thread_once(&once_init, loader_initialize);
137
138 /* get layer libraries if needed */
139 if (pLayerName && strlen(pLayerName) != 0) {
140 if (vk_string_validate(MaxLoaderStringLength, pLayerName) ==
141 VK_STRING_ERROR_NONE) {
142 loader_layer_scan(NULL, &instance_layers, NULL);
143 for (uint32_t i = 0; i < instance_layers.count; i++) {
144 struct loader_layer_properties *props =
145 &instance_layers.list[i];
146 if (strcmp(props->info.layerName, pLayerName) == 0) {
147 global_ext_list = &props->instance_extension_list;
148 }
149 }
150 } else {
151 assert(VK_FALSE && "vkEnumerateInstanceExtensionProperties: "
152 "pLayerName is too long or is badly formed");
153 return VK_ERROR_EXTENSION_NOT_PRESENT;
154 }
155 } else {
156 /* Scan/discover all ICD libraries */
157 memset(&icd_libs, 0, sizeof(struct loader_icd_libs));
158 loader_icd_scan(NULL, &icd_libs);
159 /* get extensions from all ICD's, merge so no duplicates */
160 loader_get_icd_loader_instance_extensions(NULL, &icd_libs,
161 &icd_extensions);
162 loader_scanned_icd_clear(NULL, &icd_libs);
163 global_ext_list = &icd_extensions;
164 }
165
166 if (global_ext_list == NULL) {
167 loader_destroy_layer_list(NULL, &instance_layers);
168 return VK_ERROR_LAYER_NOT_PRESENT;
169 }
170
171 if (pProperties == NULL) {
172 *pPropertyCount = global_ext_list->count;
173 loader_destroy_layer_list(NULL, &instance_layers);
174 loader_destroy_generic_list(
175 NULL, (struct loader_generic_list *)&icd_extensions);
176 return VK_SUCCESS;
177 }
178
179 copy_size = *pPropertyCount < global_ext_list->count
180 ? *pPropertyCount
181 : global_ext_list->count;
182 for (uint32_t i = 0; i < copy_size; i++) {
183 memcpy(&pProperties[i], &global_ext_list->list[i],
184 sizeof(VkExtensionProperties));
185 }
186 *pPropertyCount = copy_size;
187 loader_destroy_generic_list(NULL,
188 (struct loader_generic_list *)&icd_extensions);
189
190 if (copy_size < global_ext_list->count) {
191 loader_destroy_layer_list(NULL, &instance_layers);
192 return VK_INCOMPLETE;
193 }
194
195 loader_destroy_layer_list(NULL, &instance_layers);
196 return VK_SUCCESS;
197}
198
199LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
200vkEnumerateInstanceLayerProperties(uint32_t *pPropertyCount,
201 VkLayerProperties *pProperties) {
202
203 struct loader_layer_list instance_layer_list;
204 tls_instance = NULL;
205
206 loader_platform_thread_once(&once_init, loader_initialize);
207
208 uint32_t copy_size;
209
210 /* get layer libraries */
211 memset(&instance_layer_list, 0, sizeof(instance_layer_list));
212 loader_layer_scan(NULL, &instance_layer_list, NULL);
213
214 if (pProperties == NULL) {
215 *pPropertyCount = instance_layer_list.count;
216 loader_destroy_layer_list(NULL, &instance_layer_list);
217 return VK_SUCCESS;
218 }
219
220 copy_size = (*pPropertyCount < instance_layer_list.count)
221 ? *pPropertyCount
222 : instance_layer_list.count;
223 for (uint32_t i = 0; i < copy_size; i++) {
224 memcpy(&pProperties[i], &instance_layer_list.list[i].info,
225 sizeof(VkLayerProperties));
226 }
227
228 *pPropertyCount = copy_size;
229 loader_destroy_layer_list(NULL, &instance_layer_list);
230
231 if (copy_size < instance_layer_list.count) {
232 return VK_INCOMPLETE;
233 }
234
235 return VK_SUCCESS;
236}
237
Jon Ashburn44aed662016-02-02 17:47:28 -0700238LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
239vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo,
240 const VkAllocationCallbacks *pAllocator,
241 VkInstance *pInstance) {
Jon Ashburnfce93d92015-05-12 17:26:48 -0600242 struct loader_instance *ptr_instance = NULL;
Jon Ashburnebbfd5b2016-01-18 12:20:03 -0700243 VkInstance created_instance = VK_NULL_HANDLE;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600244 VkResult res = VK_ERROR_INITIALIZATION_FAILED;
Courtney Goeltzenleuchteracb13592015-12-09 15:48:16 -0700245 VkDebugReportCallbackEXT instance_callback = VK_NULL_HANDLE;
Jon Ashburn44aed662016-02-02 17:47:28 -0700246 void *pNext = (void *)pCreateInfo->pNext;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600247
Jon Ashburn754f1992015-08-18 18:04:47 -0600248 loader_platform_thread_once(&once_init, loader_initialize);
Jon Ashburnfce93d92015-05-12 17:26:48 -0600249
Jon Ashburnd13241a2016-01-25 14:51:47 -0700250#if 0
251 if (pAllocator) {
Chia-I Wu1f851912015-10-27 18:04:07 +0800252 ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation(
Chia-I Wu69f40122015-10-26 21:10:41 +0800253 pAllocator->pUserData,
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600254 sizeof(struct loader_instance),
Jon Ashburn9a3c2b42016-01-07 15:21:14 -0700255 sizeof(int *),
Chia-I Wu1f851912015-10-27 18:04:07 +0800256 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600257 } else {
Jon Ashburnd13241a2016-01-25 14:51:47 -0700258#endif
Jon Ashburn44aed662016-02-02 17:47:28 -0700259 ptr_instance =
260 (struct loader_instance *)malloc(sizeof(struct loader_instance));
Jon Ashburnd13241a2016-01-25 14:51:47 -0700261 //}
Jon Ashburnfce93d92015-05-12 17:26:48 -0600262 if (ptr_instance == NULL) {
263 return VK_ERROR_OUT_OF_HOST_MEMORY;
264 }
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600265
Jon Ashburn413d6582015-08-28 15:19:27 -0600266 tls_instance = ptr_instance;
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600267 loader_platform_thread_lock_mutex(&loader_lock);
Jon Ashburn182b8302015-08-11 14:49:54 -0600268 memset(ptr_instance, 0, sizeof(struct loader_instance));
Jon Ashburnd13241a2016-01-25 14:51:47 -0700269#if 0
Chia-I Wu69f40122015-10-26 21:10:41 +0800270 if (pAllocator) {
271 ptr_instance->alloc_callbacks = *pAllocator;
Courtney Goeltzenleuchterb620ace2015-07-05 11:28:29 -0600272 }
Jon Ashburnd13241a2016-01-25 14:51:47 -0700273#endif
Courtney Goeltzenleuchterb620ace2015-07-05 11:28:29 -0600274
Courtney Goeltzenleuchter6d8be2d2015-12-03 13:45:51 -0700275 /*
276 * Look for a debug report create info structure
277 * and setup a callback if found.
278 */
279 while (pNext) {
Jon Ashburn44aed662016-02-02 17:47:28 -0700280 if (((VkInstanceCreateInfo *)pNext)->sType ==
281 VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) {
282 instance_callback = (VkDebugReportCallbackEXT)ptr_instance;
283 if (util_CreateDebugReportCallback(ptr_instance, pNext, NULL,
284 instance_callback)) {
Courtney Goeltzenleuchter6d8be2d2015-12-03 13:45:51 -0700285 loader_heap_free(ptr_instance, ptr_instance);
Courtney Goeltzenleuchter15436c12015-12-02 15:29:33 -0700286 loader_platform_thread_unlock_mutex(&loader_lock);
287 return VK_ERROR_OUT_OF_HOST_MEMORY;
288 }
289 }
Jon Ashburn44aed662016-02-02 17:47:28 -0700290 pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext;
Courtney Goeltzenleuchter15436c12015-12-02 15:29:33 -0700291 }
292
Jon Ashburne9ca8fa2015-08-20 16:35:30 -0600293 /* Due to implicit layers need to get layer list even if
Jon Ashburna4ae48b2016-01-11 13:12:43 -0700294 * enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always
Jon Ashburne9ca8fa2015-08-20 16:35:30 -0600295 * get layer list (both instance and device) via loader_layer_scan(). */
Jon Ashburn44aed662016-02-02 17:47:28 -0700296 memset(&ptr_instance->instance_layer_list, 0,
297 sizeof(ptr_instance->instance_layer_list));
298 memset(&ptr_instance->device_layer_list, 0,
299 sizeof(ptr_instance->device_layer_list));
300 loader_layer_scan(ptr_instance, &ptr_instance->instance_layer_list,
Jon Ashburne58f1a32015-08-28 13:38:21 -0600301 &ptr_instance->device_layer_list);
Jon Ashburne9ca8fa2015-08-20 16:35:30 -0600302
303 /* validate the app requested layers to be enabled */
Jon Ashburna4ae48b2016-01-11 13:12:43 -0700304 if (pCreateInfo->enabledLayerCount > 0) {
Jon Ashburn7ec85cd2016-02-10 20:50:19 -0700305 res =
306 loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount,
307 pCreateInfo->ppEnabledLayerNames,
308 &ptr_instance->instance_layer_list);
Jon Ashburne9ca8fa2015-08-20 16:35:30 -0600309 if (res != VK_SUCCESS) {
Jon Ashburn44aed662016-02-02 17:47:28 -0700310 util_DestroyDebugReportCallback(ptr_instance, instance_callback,
311 NULL);
Courtney Goeltzenleuchter6d8be2d2015-12-03 13:45:51 -0700312 loader_heap_free(ptr_instance, ptr_instance);
Jon Ashburn19d11ea2015-10-09 09:40:30 -0600313 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburne9ca8fa2015-08-20 16:35:30 -0600314 return res;
315 }
316 }
317
Jon Ashburn715de582016-02-10 20:59:26 -0700318 /* convert any meta layers to the actual layers makes a copy of layer name*/
319 uint32_t saved_layer_count = pCreateInfo->enabledLayerCount;
Jon Ashburna0eecb22016-02-11 18:59:43 -0700320 char **saved_layer_names;
321 char **saved_layer_ptr;
322 saved_layer_names =
323 loader_stack_alloc(sizeof(char *) * pCreateInfo->enabledLayerCount);
Jon Ashburn715de582016-02-10 20:59:26 -0700324 for (uint32_t i = 0; i < saved_layer_count; i++) {
325 saved_layer_names[i] = (char *)pCreateInfo->ppEnabledLayerNames[i];
326 }
Jon Ashburna0eecb22016-02-11 18:59:43 -0700327 saved_layer_ptr = (char **)pCreateInfo->ppEnabledLayerNames;
Jon Ashburn715de582016-02-10 20:59:26 -0700328
329 loader_expand_layer_names(
330 ptr_instance, std_validation_str,
331 sizeof(std_validation_names) / sizeof(std_validation_names[0]),
332 std_validation_names, (uint32_t *)&pCreateInfo->enabledLayerCount,
333 (char ***)&pCreateInfo->ppEnabledLayerNames);
334
Jon Ashburn754f1992015-08-18 18:04:47 -0600335 /* Scan/discover all ICD libraries */
336 memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs));
Jon Ashburne58f1a32015-08-28 13:38:21 -0600337 loader_icd_scan(ptr_instance, &ptr_instance->icd_libs);
Jon Ashburn754f1992015-08-18 18:04:47 -0600338
Jon Ashburncfe4e682015-08-14 12:51:47 -0600339 /* get extensions from all ICD's, merge so no duplicates, then validate */
Jon Ashburn44aed662016-02-02 17:47:28 -0700340 loader_get_icd_loader_instance_extensions(
341 ptr_instance, &ptr_instance->icd_libs, &ptr_instance->ext_list);
342 res = loader_validate_instance_extensions(
Jon Ashburn7ec85cd2016-02-10 20:50:19 -0700343 ptr_instance, &ptr_instance->ext_list,
344 &ptr_instance->instance_layer_list, pCreateInfo);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600345 if (res != VK_SUCCESS) {
Jon Ashburna0eecb22016-02-11 18:59:43 -0700346 loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count,
347 saved_layer_names, saved_layer_ptr,
Jon Ashburn715de582016-02-10 20:59:26 -0700348 pCreateInfo);
Jon Ashburne58f1a32015-08-28 13:38:21 -0600349 loader_delete_layer_properties(ptr_instance,
350 &ptr_instance->device_layer_list);
351 loader_delete_layer_properties(ptr_instance,
352 &ptr_instance->instance_layer_list);
353 loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
Jon Ashburn44aed662016-02-02 17:47:28 -0700354 loader_destroy_generic_list(
355 ptr_instance,
356 (struct loader_generic_list *)&ptr_instance->ext_list);
Jon Ashburnd13241a2016-01-25 14:51:47 -0700357 util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600358 loader_platform_thread_unlock_mutex(&loader_lock);
359 loader_heap_free(ptr_instance, ptr_instance);
360 return res;
361 }
362
Jon Ashburn44aed662016-02-02 17:47:28 -0700363 ptr_instance->disp =
364 loader_heap_alloc(ptr_instance, sizeof(VkLayerInstanceDispatchTable),
365 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600366 if (ptr_instance->disp == NULL) {
Jon Ashburna0eecb22016-02-11 18:59:43 -0700367 loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count,
368 saved_layer_names, saved_layer_ptr,
Jon Ashburn715de582016-02-10 20:59:26 -0700369 pCreateInfo);
Jon Ashburne58f1a32015-08-28 13:38:21 -0600370 loader_delete_layer_properties(ptr_instance,
371 &ptr_instance->device_layer_list);
372 loader_delete_layer_properties(ptr_instance,
373 &ptr_instance->instance_layer_list);
Jon Ashburn44aed662016-02-02 17:47:28 -0700374 loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
375 loader_destroy_generic_list(
376 ptr_instance,
377 (struct loader_generic_list *)&ptr_instance->ext_list);
Jon Ashburnd13241a2016-01-25 14:51:47 -0700378 util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600379 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600380 loader_heap_free(ptr_instance, ptr_instance);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600381 return VK_ERROR_OUT_OF_HOST_MEMORY;
382 }
383 memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp));
384 ptr_instance->next = loader.instances;
385 loader.instances = ptr_instance;
386
Jon Ashburn182b8302015-08-11 14:49:54 -0600387 /* activate any layers on instance chain */
Jon Ashburn44aed662016-02-02 17:47:28 -0700388 res = loader_enable_instance_layers(ptr_instance, pCreateInfo,
Jon Ashburne58f1a32015-08-28 13:38:21 -0600389 &ptr_instance->instance_layer_list);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600390 if (res != VK_SUCCESS) {
Jon Ashburna0eecb22016-02-11 18:59:43 -0700391 loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count,
392 saved_layer_names, saved_layer_ptr,
Jon Ashburn715de582016-02-10 20:59:26 -0700393 pCreateInfo);
Jon Ashburne58f1a32015-08-28 13:38:21 -0600394 loader_delete_layer_properties(ptr_instance,
395 &ptr_instance->device_layer_list);
396 loader_delete_layer_properties(ptr_instance,
397 &ptr_instance->instance_layer_list);
Jon Ashburn44aed662016-02-02 17:47:28 -0700398 loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs);
399 loader_destroy_generic_list(
400 ptr_instance,
401 (struct loader_generic_list *)&ptr_instance->ext_list);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600402 loader.instances = ptr_instance->next;
Jon Ashburnd13241a2016-01-25 14:51:47 -0700403 util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600404 loader_platform_thread_unlock_mutex(&loader_lock);
Courtney Goeltzenleuchter1381cd12015-07-06 09:08:37 -0600405 loader_heap_free(ptr_instance, ptr_instance->disp);
406 loader_heap_free(ptr_instance, ptr_instance);
407 return res;
408 }
Jon Ashburncedc15f2015-05-21 18:13:33 -0600409
Jon Ashburn44aed662016-02-02 17:47:28 -0700410 created_instance = (VkInstance)ptr_instance;
411 res = loader_create_instance_chain(pCreateInfo, pAllocator, ptr_instance,
Jon Ashburna4b34942016-02-03 12:37:30 -0700412 &created_instance);
Jon Ashburna179dcf2015-05-21 17:42:17 -0600413
Jon Ashburn7da19ee2016-01-14 13:51:55 -0700414 if (res == VK_SUCCESS) {
Courtney Goeltzenleuchter2bdf6da2016-01-08 12:18:43 -0700415 wsi_create_instance(ptr_instance, pCreateInfo);
416 debug_report_create_instance(ptr_instance, pCreateInfo);
417
Jon Ashburnebbfd5b2016-01-18 12:20:03 -0700418 *pInstance = created_instance;
Courtney Goeltzenleuchter2bdf6da2016-01-08 12:18:43 -0700419
Jon Ashburn7da19ee2016-01-14 13:51:55 -0700420 /*
421 * Finally have the layers in place and everyone has seen
422 * the CreateInstance command go by. This allows the layer's
423 * GetInstanceProcAddr functions to return valid extension functions
424 * if enabled.
425 */
426 loader_activate_instance_layer_extensions(ptr_instance, *pInstance);
Courtney Goeltzenleuchter2bdf6da2016-01-08 12:18:43 -0700427 } else {
428 // TODO: cleanup here.
Jon Ashburn7da19ee2016-01-14 13:51:55 -0700429 }
Courtney Goeltzenleuchter2bdf6da2016-01-08 12:18:43 -0700430
Courtney Goeltzenleuchter6d8be2d2015-12-03 13:45:51 -0700431 /* Remove temporary debug_report callback */
Jon Ashburnd13241a2016-01-25 14:51:47 -0700432 util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL);
Jon Ashburna0eecb22016-02-11 18:59:43 -0700433 loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count,
434 saved_layer_names, saved_layer_ptr,
Jon Ashburn715de582016-02-10 20:59:26 -0700435 pCreateInfo);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600436 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburnfce93d92015-05-12 17:26:48 -0600437 return res;
438}
439
Jon Ashburn44aed662016-02-02 17:47:28 -0700440LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
441vkDestroyInstance(VkInstance instance,
442 const VkAllocationCallbacks *pAllocator) {
Jon Ashburnfce93d92015-05-12 17:26:48 -0600443 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn0c5eea22015-09-30 12:56:42 -0600444 struct loader_instance *ptr_instance = NULL;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600445 disp = loader_get_instance_dispatch(instance);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600446
Jon Ashburnb40f2562015-05-29 13:15:39 -0600447 loader_platform_thread_lock_mutex(&loader_lock);
448
Courtney Goeltzenleuchter6d8be2d2015-12-03 13:45:51 -0700449 /* TODO: Do we need a temporary callback here to catch cleanup issues? */
450
Jon Ashburn0c5eea22015-09-30 12:56:42 -0600451 ptr_instance = loader_get_instance(instance);
Chia-I Wu69f40122015-10-26 21:10:41 +0800452 disp->DestroyInstance(instance, pAllocator);
Courtney Goeltzenleuchter1c7c65d2015-06-10 17:39:03 -0600453
Courtney Goeltzenleuchter3d8dc1f2015-06-08 15:09:22 -0600454 loader_deactivate_instance_layers(ptr_instance);
Jon Ashburn87660432016-03-01 19:51:07 -0700455 if (ptr_instance->phys_devs)
456 loader_heap_free(ptr_instance, ptr_instance->phys_devs);
Jon Ashburncfe4e682015-08-14 12:51:47 -0600457 loader_heap_free(ptr_instance, ptr_instance->disp);
458 loader_heap_free(ptr_instance, ptr_instance);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600459 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburnfce93d92015-05-12 17:26:48 -0600460}
Jon Ashburn2666e2f2015-05-15 15:09:35 -0600461
Jon Ashburn44aed662016-02-02 17:47:28 -0700462LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
463vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount,
464 VkPhysicalDevice *pPhysicalDevices) {
Jon Ashburnfce93d92015-05-12 17:26:48 -0600465 const VkLayerInstanceDispatchTable *disp;
Jon Ashburnb40f2562015-05-29 13:15:39 -0600466 VkResult res;
Jon Ashburn87660432016-03-01 19:51:07 -0700467 uint32_t count, i;
468 struct loader_instance *inst;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600469 disp = loader_get_instance_dispatch(instance);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600470
471 loader_platform_thread_lock_mutex(&loader_lock);
472 res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount,
Jon Ashburnfce93d92015-05-12 17:26:48 -0600473 pPhysicalDevices);
Jon Ashburn87660432016-03-01 19:51:07 -0700474
475 if (res != VK_SUCCESS && res != VK_INCOMPLETE) {
476 loader_platform_thread_unlock_mutex(&loader_lock);
477 return res;
478 }
479
480 if (!pPhysicalDevices) {
481 loader_platform_thread_unlock_mutex(&loader_lock);
482 return res;
483 }
484
485 // wrap the PhysDev object for loader usage, return wrapped objects
486 inst = loader_get_instance(instance);
487 if (!inst) {
488 loader_platform_thread_unlock_mutex(&loader_lock);
489 return VK_ERROR_INITIALIZATION_FAILED;
490 }
491 if (inst->phys_devs)
492 loader_heap_free(inst, inst->phys_devs);
493 count = inst->total_gpu_count;
494 inst->phys_devs = (struct loader_physical_device *)loader_heap_alloc(
495 inst, count * sizeof(struct loader_physical_device),
496 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE);
497 if (!inst->phys_devs) {
498 loader_platform_thread_unlock_mutex(&loader_lock);
499 return VK_ERROR_OUT_OF_HOST_MEMORY;
500 }
501
502 for (i = 0; i < count; i++) {
503
504 // initialize the loader's physicalDevice object
505 loader_set_dispatch((void *)&inst->phys_devs[i], inst->disp);
506 inst->phys_devs[i].this_icd = inst->phys_devs_term[i].this_icd;
507 inst->phys_devs[i].phys_dev = pPhysicalDevices[i];
508
509 // copy wrapped object into Application provided array
510 pPhysicalDevices[i] = (VkPhysicalDevice)&inst->phys_devs[i];
511 }
Jon Ashburnb40f2562015-05-29 13:15:39 -0600512 loader_platform_thread_unlock_mutex(&loader_lock);
513 return res;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600514}
515
Jon Ashburn44aed662016-02-02 17:47:28 -0700516LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
Jon Ashburn87660432016-03-01 19:51:07 -0700517vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice,
Jon Ashburn44aed662016-02-02 17:47:28 -0700518 VkPhysicalDeviceFeatures *pFeatures) {
Jon Ashburn4e189562015-07-23 18:49:07 -0600519 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn87660432016-03-01 19:51:07 -0700520 VkPhysicalDevice unwrapped_phys_dev =
521 loader_unwrap_physical_device(physicalDevice);
522 disp = loader_get_instance_dispatch(physicalDevice);
523 disp->GetPhysicalDeviceFeatures(unwrapped_phys_dev, pFeatures);
Jon Ashburn4e189562015-07-23 18:49:07 -0600524}
525
Jon Ashburn44aed662016-02-02 17:47:28 -0700526LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
Jon Ashburn87660432016-03-01 19:51:07 -0700527vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice,
528 VkFormat format,
Jon Ashburn44aed662016-02-02 17:47:28 -0700529 VkFormatProperties *pFormatInfo) {
Jon Ashburn4e189562015-07-23 18:49:07 -0600530 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn87660432016-03-01 19:51:07 -0700531 VkPhysicalDevice unwrapped_pd =
532 loader_unwrap_physical_device(physicalDevice);
533 disp = loader_get_instance_dispatch(physicalDevice);
534 disp->GetPhysicalDeviceFormatProperties(unwrapped_pd, format, pFormatInfo);
Jon Ashburn4e189562015-07-23 18:49:07 -0600535}
536
Jon Ashburn44aed662016-02-02 17:47:28 -0700537LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
538vkGetPhysicalDeviceImageFormatProperties(
539 VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
540 VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags,
541 VkImageFormatProperties *pImageFormatProperties) {
Jon Ashburn4e189562015-07-23 18:49:07 -0600542 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn87660432016-03-01 19:51:07 -0700543 VkPhysicalDevice unwrapped_phys_dev =
544 loader_unwrap_physical_device(physicalDevice);
Jon Ashburn4e189562015-07-23 18:49:07 -0600545 disp = loader_get_instance_dispatch(physicalDevice);
Jon Ashburn44aed662016-02-02 17:47:28 -0700546 return disp->GetPhysicalDeviceImageFormatProperties(
Jon Ashburn87660432016-03-01 19:51:07 -0700547 unwrapped_phys_dev, format, type, tiling, usage, flags,
Jon Ashburn44aed662016-02-02 17:47:28 -0700548 pImageFormatProperties);
Jon Ashburn4e189562015-07-23 18:49:07 -0600549}
550
Jon Ashburn44aed662016-02-02 17:47:28 -0700551LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
Jon Ashburn87660432016-03-01 19:51:07 -0700552vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice,
Jon Ashburn44aed662016-02-02 17:47:28 -0700553 VkPhysicalDeviceProperties *pProperties) {
Jon Ashburn2666e2f2015-05-15 15:09:35 -0600554 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn87660432016-03-01 19:51:07 -0700555 VkPhysicalDevice unwrapped_phys_dev =
556 loader_unwrap_physical_device(physicalDevice);
557 disp = loader_get_instance_dispatch(physicalDevice);
558 disp->GetPhysicalDeviceProperties(unwrapped_phys_dev, pProperties);
Tony Barbour426b9052015-06-24 16:06:58 -0600559}
560
Jon Ashburn44aed662016-02-02 17:47:28 -0700561LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
562vkGetPhysicalDeviceQueueFamilyProperties(
Jon Ashburn87660432016-03-01 19:51:07 -0700563 VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount,
Jon Ashburn44aed662016-02-02 17:47:28 -0700564 VkQueueFamilyProperties *pQueueProperties) {
Tony Barbour426b9052015-06-24 16:06:58 -0600565 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn87660432016-03-01 19:51:07 -0700566 VkPhysicalDevice unwrapped_phys_dev =
567 loader_unwrap_physical_device(physicalDevice);
568 disp = loader_get_instance_dispatch(physicalDevice);
569 disp->GetPhysicalDeviceQueueFamilyProperties(
570 unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueProperties);
Tony Barbour426b9052015-06-24 16:06:58 -0600571}
572
Chia-I Wuaf9e4fd2015-11-06 06:42:02 +0800573LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties(
Jon Ashburn87660432016-03-01 19:51:07 -0700574 VkPhysicalDevice physicalDevice,
575 VkPhysicalDeviceMemoryProperties *pMemoryProperties) {
Tony Barbour426b9052015-06-24 16:06:58 -0600576 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn87660432016-03-01 19:51:07 -0700577 VkPhysicalDevice unwrapped_phys_dev =
578 loader_unwrap_physical_device(physicalDevice);
579 disp = loader_get_instance_dispatch(physicalDevice);
580 disp->GetPhysicalDeviceMemoryProperties(unwrapped_phys_dev,
581 pMemoryProperties);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600582}
583
Jon Ashburn44aed662016-02-02 17:47:28 -0700584LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
Jon Ashburna9c4a572016-02-26 13:14:27 -0700585vkCreateDevice(VkPhysicalDevice physicalDevice,
586 const VkDeviceCreateInfo *pCreateInfo,
Jon Ashburn44aed662016-02-02 17:47:28 -0700587 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600588 VkResult res;
Jon Ashburna9c4a572016-02-26 13:14:27 -0700589 struct loader_physical_device *phys_dev;
590 struct loader_icd *icd;
591 struct loader_device *dev;
592 struct loader_instance *inst;
593 struct loader_layer_list activated_layer_list = {0};
594
595 assert(pCreateInfo->queueCreateInfoCount >= 1);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600596
Jon Ashburnb40f2562015-05-29 13:15:39 -0600597 loader_platform_thread_lock_mutex(&loader_lock);
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600598
Jon Ashburn87660432016-03-01 19:51:07 -0700599 phys_dev = (struct loader_physical_device *)physicalDevice;
Jon Ashburna9c4a572016-02-26 13:14:27 -0700600 icd = phys_dev->this_icd;
601 if (!icd) {
602 loader_platform_thread_unlock_mutex(&loader_lock);
603 return VK_ERROR_INITIALIZATION_FAILED;
604 }
605
Jon Ashburn87660432016-03-01 19:51:07 -0700606 inst = (struct loader_instance *)phys_dev->this_icd->this_instance;
Jon Ashburna9c4a572016-02-26 13:14:27 -0700607
608 if (!icd->CreateDevice) {
609 loader_platform_thread_unlock_mutex(&loader_lock);
610 return VK_ERROR_INITIALIZATION_FAILED;
611 }
612
613 /* validate any app enabled layers are available */
614 if (pCreateInfo->enabledLayerCount > 0) {
615 res = loader_validate_layers(inst, pCreateInfo->enabledLayerCount,
616 pCreateInfo->ppEnabledLayerNames,
617 &inst->device_layer_list);
618 if (res != VK_SUCCESS) {
619 loader_platform_thread_unlock_mutex(&loader_lock);
620 return res;
621 }
622 }
623
Jon Ashburn87660432016-03-01 19:51:07 -0700624 /* Get the physical device (ICD) extensions */
625 struct loader_extension_list icd_exts;
626 if (!loader_init_generic_list(inst, (struct loader_generic_list *)&icd_exts,
627 sizeof(VkExtensionProperties))) {
628 loader_platform_thread_unlock_mutex(&loader_lock);
629 return VK_ERROR_OUT_OF_HOST_MEMORY;
630 }
Jon Ashburna9c4a572016-02-26 13:14:27 -0700631
Jon Ashburnfc53d902016-03-11 14:43:57 -0700632 //TODO handle more than one phys dev per icd (icd->phys_devs[0])
Jon Ashburn87660432016-03-01 19:51:07 -0700633 res = loader_add_device_extensions(
Jon Ashburnfc53d902016-03-11 14:43:57 -0700634 inst, icd, icd->phys_devs[0],
Jon Ashburn87660432016-03-01 19:51:07 -0700635 phys_dev->this_icd->this_icd_lib->lib_name, &icd_exts);
636 if (res != VK_SUCCESS) {
637 loader_platform_thread_unlock_mutex(&loader_lock);
638 return res;
Jon Ashburna9c4a572016-02-26 13:14:27 -0700639 }
640
641 /* convert any meta layers to the actual layers makes a copy of layer name*/
642 uint32_t saved_layer_count = pCreateInfo->enabledLayerCount;
643 char **saved_layer_names;
644 char **saved_layer_ptr;
645 saved_layer_names =
646 loader_stack_alloc(sizeof(char *) * pCreateInfo->enabledLayerCount);
647 for (uint32_t i = 0; i < saved_layer_count; i++) {
648 saved_layer_names[i] = (char *)pCreateInfo->ppEnabledLayerNames[i];
649 }
650 saved_layer_ptr = (char **)pCreateInfo->ppEnabledLayerNames;
651
652 loader_expand_layer_names(
653 inst, std_validation_str,
654 sizeof(std_validation_names) / sizeof(std_validation_names[0]),
655 std_validation_names, (uint32_t *)&pCreateInfo->enabledLayerCount,
656 (char ***)&pCreateInfo->ppEnabledLayerNames);
657
658 /* fetch a list of all layers activated, explicit and implicit */
659 res = loader_enable_device_layers(inst, icd, &activated_layer_list,
660 pCreateInfo, &inst->device_layer_list);
661 if (res != VK_SUCCESS) {
662 loader_unexpand_dev_layer_names(inst, saved_layer_count,
663 saved_layer_names, saved_layer_ptr,
664 pCreateInfo);
665 loader_platform_thread_unlock_mutex(&loader_lock);
666 return res;
667 }
668
669 /* make sure requested extensions to be enabled are supported */
670 res = loader_validate_device_extensions(phys_dev, &activated_layer_list,
Jon Ashburn87660432016-03-01 19:51:07 -0700671 &icd_exts, pCreateInfo);
Jon Ashburna9c4a572016-02-26 13:14:27 -0700672 if (res != VK_SUCCESS) {
673 loader_unexpand_dev_layer_names(inst, saved_layer_count,
674 saved_layer_names, saved_layer_ptr,
675 pCreateInfo);
676 loader_destroy_generic_list(
677 inst, (struct loader_generic_list *)&activated_layer_list);
678 loader_platform_thread_unlock_mutex(&loader_lock);
679 return res;
680 }
681
682 dev = loader_add_logical_device(inst, &icd->logical_device_list);
683 if (dev == NULL) {
684 loader_unexpand_dev_layer_names(inst, saved_layer_count,
685 saved_layer_names, saved_layer_ptr,
686 pCreateInfo);
687 loader_destroy_generic_list(
688 inst, (struct loader_generic_list *)&activated_layer_list);
689 loader_platform_thread_unlock_mutex(&loader_lock);
690 return VK_ERROR_OUT_OF_HOST_MEMORY;
691 }
692
693 /* move the locally filled layer list into the device, and pass ownership of
694 * the memory */
695 dev->activated_layer_list.capacity = activated_layer_list.capacity;
696 dev->activated_layer_list.count = activated_layer_list.count;
697 dev->activated_layer_list.list = activated_layer_list.list;
698 memset(&activated_layer_list, 0, sizeof(activated_layer_list));
699
700 /* activate any layers on device chain which terminates with device*/
701 res = loader_enable_device_layers(inst, icd, &dev->activated_layer_list,
702 pCreateInfo, &inst->device_layer_list);
703 if (res != VK_SUCCESS) {
704 loader_unexpand_dev_layer_names(inst, saved_layer_count,
705 saved_layer_names, saved_layer_ptr,
706 pCreateInfo);
707 loader_remove_logical_device(inst, icd, dev);
708 loader_platform_thread_unlock_mutex(&loader_lock);
709 return res;
710 }
711
Jon Ashburn87660432016-03-01 19:51:07 -0700712 res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst,
713 icd, dev);
Jon Ashburna9c4a572016-02-26 13:14:27 -0700714 if (res != VK_SUCCESS) {
715 loader_unexpand_dev_layer_names(inst, saved_layer_count,
716 saved_layer_names, saved_layer_ptr,
717 pCreateInfo);
718 loader_remove_logical_device(inst, icd, dev);
719 loader_platform_thread_unlock_mutex(&loader_lock);
720 return res;
721 }
722
723 *pDevice = dev->device;
724
725 /* initialize any device extension dispatch entry's from the instance list*/
726 loader_init_dispatch_dev_ext(inst, dev);
727
728 /* initialize WSI device extensions as part of core dispatch since loader
729 * has
730 * dedicated trampoline code for these*/
731 loader_init_device_extension_dispatch_table(
732 &dev->loader_dispatch,
733 dev->loader_dispatch.core_dispatch.GetDeviceProcAddr, *pDevice);
734
735 loader_unexpand_dev_layer_names(inst, saved_layer_count, saved_layer_names,
736 saved_layer_ptr, pCreateInfo);
Courtney Goeltzenleuchterbe637992015-06-25 18:01:43 -0600737
Jon Ashburnb40f2562015-05-29 13:15:39 -0600738 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600739 return res;
740}
741
Jon Ashburn44aed662016-02-02 17:47:28 -0700742LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
743vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600744 const VkLayerDispatchTable *disp;
Jon Ashburne58f1a32015-08-28 13:38:21 -0600745 struct loader_device *dev;
Andrzej Kotlowski4a54a742016-02-03 09:41:53 +0100746
747 loader_platform_thread_lock_mutex(&loader_lock);
748
Jon Ashburne58f1a32015-08-28 13:38:21 -0600749 struct loader_icd *icd = loader_get_icd_and_device(device, &dev);
750 const struct loader_instance *inst = icd->this_instance;
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600751 disp = loader_get_dispatch(device);
752
Chia-I Wu69f40122015-10-26 21:10:41 +0800753 disp->DestroyDevice(device, pAllocator);
Jon Ashburndbf8cee2015-11-19 15:43:26 -0700754 dev->device = NULL;
755 loader_remove_logical_device(inst, icd, dev);
756
Jon Ashburnb40f2562015-05-29 13:15:39 -0600757 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburnb40f2562015-05-29 13:15:39 -0600758}
759
Jon Ashburn44aed662016-02-02 17:47:28 -0700760LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
761vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice,
762 const char *pLayerName,
763 uint32_t *pPropertyCount,
764 VkExtensionProperties *pProperties) {
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700765 VkResult res = VK_SUCCESS;
Jon Ashburn87660432016-03-01 19:51:07 -0700766 struct loader_physical_device *phys_dev;
767 phys_dev = (struct loader_physical_device *)physicalDevice;
Jon Ashburnb40f2562015-05-29 13:15:39 -0600768
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600769 loader_platform_thread_lock_mutex(&loader_lock);
Jon Ashburndb5a5bc2015-11-02 17:40:01 -0700770
771 /* If pLayerName == NULL, then querying ICD extensions, pass this call
772 down the instance chain which will terminate in the ICD. This allows
773 layers to filter the extensions coming back up the chain.
774 If pLayerName != NULL then get layer extensions from manifest file. */
Jon Ashburn44aed662016-02-02 17:47:28 -0700775 if (pLayerName == NULL || strlen(pLayerName) == 0) {
Jon Ashburndb5a5bc2015-11-02 17:40:01 -0700776 const VkLayerInstanceDispatchTable *disp;
777
778 disp = loader_get_instance_dispatch(physicalDevice);
Jon Ashburn44aed662016-02-02 17:47:28 -0700779 res = disp->EnumerateDeviceExtensionProperties(
Jon Ashburn87660432016-03-01 19:51:07 -0700780 phys_dev->phys_dev, NULL, pPropertyCount, pProperties);
Jon Ashburndb5a5bc2015-11-02 17:40:01 -0700781 } else {
Jon Ashburn87660432016-03-01 19:51:07 -0700782
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700783 uint32_t count;
784 uint32_t copy_size;
Jon Ashburn87660432016-03-01 19:51:07 -0700785 const struct loader_instance *inst = phys_dev->this_icd->this_instance;
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700786 if (vk_string_validate(MaxLoaderStringLength, pLayerName) ==
Jon Ashburn87660432016-03-01 19:51:07 -0700787 VK_STRING_ERROR_NONE) {
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700788
789 struct loader_device_extension_list *dev_ext_list = NULL;
Jon Ashburn87660432016-03-01 19:51:07 -0700790 for (uint32_t i = 0; i < inst->device_layer_list.count; i++) {
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700791 struct loader_layer_properties *props =
Jon Ashburn87660432016-03-01 19:51:07 -0700792 &inst->device_layer_list.list[i];
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700793 if (strcmp(props->info.layerName, pLayerName) == 0) {
794 dev_ext_list = &props->device_extension_list;
795 }
796 }
797 count = (dev_ext_list == NULL) ? 0 : dev_ext_list->count;
798 if (pProperties == NULL) {
799 *pPropertyCount = count;
800 loader_platform_thread_unlock_mutex(&loader_lock);
801 return VK_SUCCESS;
802 }
803
804 copy_size = *pPropertyCount < count ? *pPropertyCount : count;
805 for (uint32_t i = 0; i < copy_size; i++) {
806 memcpy(&pProperties[i], &dev_ext_list->list[i].props,
Jon Ashburn87660432016-03-01 19:51:07 -0700807 sizeof(VkExtensionProperties));
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700808 }
809 *pPropertyCount = copy_size;
810
811 if (copy_size < count) {
812 loader_platform_thread_unlock_mutex(&loader_lock);
813 return VK_INCOMPLETE;
814 }
815 } else {
Jon Ashburn87660432016-03-01 19:51:07 -0700816 loader_log(inst, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0,
817 "vkEnumerateDeviceExtensionProperties: pLayerName "
818 "is too long or is badly formed");
819 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700820 return VK_ERROR_EXTENSION_NOT_PRESENT;
821 }
Jon Ashburndb5a5bc2015-11-02 17:40:01 -0700822 }
823
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600824 loader_platform_thread_unlock_mutex(&loader_lock);
Tony Barbour426b9052015-06-24 16:06:58 -0600825 return res;
826}
827
Jon Ashburn44aed662016-02-02 17:47:28 -0700828LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
829vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice,
830 uint32_t *pPropertyCount,
831 VkLayerProperties *pProperties) {
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700832 uint32_t copy_size;
833 struct loader_physical_device *phys_dev;
Tony Barbour426b9052015-06-24 16:06:58 -0600834
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600835 loader_platform_thread_lock_mutex(&loader_lock);
Jon Ashburndb5a5bc2015-11-02 17:40:01 -0700836
837 /* Don't dispatch this call down the instance chain, want all device layers
838 enumerated and instance chain may not contain all device layers */
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700839
Jon Ashburn87660432016-03-01 19:51:07 -0700840 phys_dev = (struct loader_physical_device *)physicalDevice;
841 const struct loader_instance *inst = phys_dev->this_icd->this_instance;
842 uint32_t count = inst->device_layer_list.count;
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700843
844 if (pProperties == NULL) {
845 *pPropertyCount = count;
846 loader_platform_thread_unlock_mutex(&loader_lock);
847 return VK_SUCCESS;
848 }
849
850 copy_size = (*pPropertyCount < count) ? *pPropertyCount : count;
851 for (uint32_t i = 0; i < copy_size; i++) {
Jon Ashburn87660432016-03-01 19:51:07 -0700852 memcpy(&pProperties[i], &(inst->device_layer_list.list[i].info),
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700853 sizeof(VkLayerProperties));
854 }
855 *pPropertyCount = copy_size;
856
857 if (copy_size < count) {
858 loader_platform_thread_unlock_mutex(&loader_lock);
859 return VK_INCOMPLETE;
860 }
861
Courtney Goeltzenleuchter18061cd2015-06-29 15:39:26 -0600862 loader_platform_thread_unlock_mutex(&loader_lock);
Jon Ashburn6c2c0612016-02-29 13:00:51 -0700863 return VK_SUCCESS;
Jon Ashburnfce93d92015-05-12 17:26:48 -0600864}
865
Jon Ashburn44aed662016-02-02 17:47:28 -0700866LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
867vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex,
868 VkQueue *pQueue) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600869 const VkLayerDispatchTable *disp;
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600870
871 disp = loader_get_dispatch(device);
872
Courtney Goeltzenleuchter01d2ae12015-10-20 16:40:38 -0600873 disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue);
874 loader_set_dispatch(*pQueue, disp);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600875}
876
Jon Ashburn44aed662016-02-02 17:47:28 -0700877LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
878vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits,
879 VkFence fence) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600880 const VkLayerDispatchTable *disp;
881
882 disp = loader_get_dispatch(queue);
883
Chia-I Wu483e7702015-10-26 17:20:32 +0800884 return disp->QueueSubmit(queue, submitCount, pSubmits, fence);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600885}
886
Jon Ashburn44aed662016-02-02 17:47:28 -0700887LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600888 const VkLayerDispatchTable *disp;
889
890 disp = loader_get_dispatch(queue);
891
892 return disp->QueueWaitIdle(queue);
893}
894
Jon Ashburn44aed662016-02-02 17:47:28 -0700895LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600896 const VkLayerDispatchTable *disp;
897
898 disp = loader_get_dispatch(device);
899
900 return disp->DeviceWaitIdle(device);
901}
902
Jon Ashburn44aed662016-02-02 17:47:28 -0700903LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
904vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo,
905 const VkAllocationCallbacks *pAllocator,
906 VkDeviceMemory *pMemory) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600907 const VkLayerDispatchTable *disp;
908
909 disp = loader_get_dispatch(device);
910
Chia-I Wu1f851912015-10-27 18:04:07 +0800911 return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600912}
913
Jon Ashburn44aed662016-02-02 17:47:28 -0700914LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
915vkFreeMemory(VkDevice device, VkDeviceMemory mem,
916 const VkAllocationCallbacks *pAllocator) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600917 const VkLayerDispatchTable *disp;
918
919 disp = loader_get_dispatch(device);
920
Chia-I Wu69f40122015-10-26 21:10:41 +0800921 disp->FreeMemory(device, mem, pAllocator);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600922}
923
Jon Ashburn44aed662016-02-02 17:47:28 -0700924LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
925vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset,
926 VkDeviceSize size, VkFlags flags, void **ppData) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600927 const VkLayerDispatchTable *disp;
928
929 disp = loader_get_dispatch(device);
930
931 return disp->MapMemory(device, mem, offset, size, flags, ppData);
932}
933
Jon Ashburn44aed662016-02-02 17:47:28 -0700934LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
935vkUnmapMemory(VkDevice device, VkDeviceMemory mem) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600936 const VkLayerDispatchTable *disp;
937
938 disp = loader_get_dispatch(device);
939
Mark Lobodzinski67b42b72015-09-07 13:59:43 -0600940 disp->UnmapMemory(device, mem);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600941}
942
Jon Ashburn44aed662016-02-02 17:47:28 -0700943LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
944vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
945 const VkMappedMemoryRange *pMemoryRanges) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600946 const VkLayerDispatchTable *disp;
947
948 disp = loader_get_dispatch(device);
949
Jon Ashburn44aed662016-02-02 17:47:28 -0700950 return disp->FlushMappedMemoryRanges(device, memoryRangeCount,
951 pMemoryRanges);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600952}
953
Jon Ashburn44aed662016-02-02 17:47:28 -0700954LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
955vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount,
956 const VkMappedMemoryRange *pMemoryRanges) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600957 const VkLayerDispatchTable *disp;
958
959 disp = loader_get_dispatch(device);
960
Jon Ashburn44aed662016-02-02 17:47:28 -0700961 return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount,
962 pMemoryRanges);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600963}
964
Jon Ashburn44aed662016-02-02 17:47:28 -0700965LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
966vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory,
967 VkDeviceSize *pCommittedMemoryInBytes) {
Courtney Goeltzenleuchterd040c5c2015-07-09 21:57:28 -0600968 const VkLayerDispatchTable *disp;
969
970 disp = loader_get_dispatch(device);
971
Courtney Goeltzenleuchter01d2ae12015-10-20 16:40:38 -0600972 disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes);
Courtney Goeltzenleuchterd040c5c2015-07-09 21:57:28 -0600973}
974
Jon Ashburn44aed662016-02-02 17:47:28 -0700975LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
976vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem,
977 VkDeviceSize offset) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600978 const VkLayerDispatchTable *disp;
979
Mark Lobodzinskifb9f5642015-05-11 17:21:15 -0500980 disp = loader_get_dispatch(device);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600981
Tony Barbourde4124d2015-07-03 10:33:54 -0600982 return disp->BindBufferMemory(device, buffer, mem, offset);
983}
984
Jon Ashburn44aed662016-02-02 17:47:28 -0700985LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
986vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem,
987 VkDeviceSize offset) {
Tony Barbourde4124d2015-07-03 10:33:54 -0600988 const VkLayerDispatchTable *disp;
989
990 disp = loader_get_dispatch(device);
991
992 return disp->BindImageMemory(device, image, mem, offset);
Jon Ashburn2139a3e2015-05-06 09:02:10 -0600993}
994
Jon Ashburn44aed662016-02-02 17:47:28 -0700995LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
996vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer,
997 VkMemoryRequirements *pMemoryRequirements) {
Jon Ashburn4e189562015-07-23 18:49:07 -0600998 const VkLayerDispatchTable *disp;
999
1000 disp = loader_get_dispatch(device);
1001
Courtney Goeltzenleuchter01d2ae12015-10-20 16:40:38 -06001002 disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements);
Jon Ashburn4e189562015-07-23 18:49:07 -06001003}
1004
Jon Ashburn44aed662016-02-02 17:47:28 -07001005LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1006vkGetImageMemoryRequirements(VkDevice device, VkImage image,
1007 VkMemoryRequirements *pMemoryRequirements) {
Jon Ashburn4e189562015-07-23 18:49:07 -06001008 const VkLayerDispatchTable *disp;
1009
1010 disp = loader_get_dispatch(device);
1011
Courtney Goeltzenleuchter01d2ae12015-10-20 16:40:38 -06001012 disp->GetImageMemoryRequirements(device, image, pMemoryRequirements);
Jon Ashburn4e189562015-07-23 18:49:07 -06001013}
1014
Jon Ashburn44aed662016-02-02 17:47:28 -07001015LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(
1016 VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount,
1017 VkSparseImageMemoryRequirements *pSparseMemoryRequirements) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001018 const VkLayerDispatchTable *disp;
1019
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -06001020 disp = loader_get_dispatch(device);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001021
Jon Ashburn44aed662016-02-02 17:47:28 -07001022 disp->GetImageSparseMemoryRequirements(device, image,
1023 pSparseMemoryRequirementCount,
1024 pSparseMemoryRequirements);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001025}
1026
Jon Ashburn44aed662016-02-02 17:47:28 -07001027LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1028vkGetPhysicalDeviceSparseImageFormatProperties(
1029 VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type,
1030 VkSampleCountFlagBits samples, VkImageUsageFlags usage,
1031 VkImageTiling tiling, uint32_t *pPropertyCount,
1032 VkSparseImageFormatProperties *pProperties) {
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -06001033 const VkLayerInstanceDispatchTable *disp;
Jon Ashburn87660432016-03-01 19:51:07 -07001034 VkPhysicalDevice unwrapped_phys_dev =
1035 loader_unwrap_physical_device(physicalDevice);
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -06001036 disp = loader_get_instance_dispatch(physicalDevice);
1037
Jon Ashburn44aed662016-02-02 17:47:28 -07001038 disp->GetPhysicalDeviceSparseImageFormatProperties(
Jon Ashburn87660432016-03-01 19:51:07 -07001039 unwrapped_phys_dev, format, type, samples, usage, tiling,
1040 pPropertyCount, pProperties);
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -06001041}
1042
Jon Ashburn44aed662016-02-02 17:47:28 -07001043LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1044vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount,
1045 const VkBindSparseInfo *pBindInfo, VkFence fence) {
Mark Lobodzinski83d4e6a2015-07-03 15:58:09 -06001046 const VkLayerDispatchTable *disp;
1047
1048 disp = loader_get_dispatch(queue);
1049
Chia-I Wu06809d52015-10-26 16:55:27 +08001050 return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001051}
1052
Jon Ashburn44aed662016-02-02 17:47:28 -07001053LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1054vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo,
1055 const VkAllocationCallbacks *pAllocator, VkFence *pFence) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001056 const VkLayerDispatchTable *disp;
1057
1058 disp = loader_get_dispatch(device);
1059
Chia-I Wu69f40122015-10-26 21:10:41 +08001060 return disp->CreateFence(device, pCreateInfo, pAllocator, pFence);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001061}
1062
Jon Ashburn44aed662016-02-02 17:47:28 -07001063LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1064vkDestroyFence(VkDevice device, VkFence fence,
1065 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001066 const VkLayerDispatchTable *disp;
1067
1068 disp = loader_get_dispatch(device);
1069
Chia-I Wu69f40122015-10-26 21:10:41 +08001070 disp->DestroyFence(device, fence, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001071}
1072
Jon Ashburn44aed662016-02-02 17:47:28 -07001073LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1074vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001075 const VkLayerDispatchTable *disp;
1076
1077 disp = loader_get_dispatch(device);
1078
1079 return disp->ResetFences(device, fenceCount, pFences);
1080}
1081
Jon Ashburn44aed662016-02-02 17:47:28 -07001082LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1083vkGetFenceStatus(VkDevice device, VkFence fence) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001084 const VkLayerDispatchTable *disp;
1085
1086 disp = loader_get_dispatch(device);
1087
1088 return disp->GetFenceStatus(device, fence);
1089}
1090
Jon Ashburn44aed662016-02-02 17:47:28 -07001091LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1092vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences,
1093 VkBool32 waitAll, uint64_t timeout) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001094 const VkLayerDispatchTable *disp;
1095
1096 disp = loader_get_dispatch(device);
1097
1098 return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout);
1099}
1100
Jon Ashburn44aed662016-02-02 17:47:28 -07001101LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1102vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo,
1103 const VkAllocationCallbacks *pAllocator,
1104 VkSemaphore *pSemaphore) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001105 const VkLayerDispatchTable *disp;
1106
1107 disp = loader_get_dispatch(device);
1108
Chia-I Wu69f40122015-10-26 21:10:41 +08001109 return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001110}
1111
Jon Ashburn44aed662016-02-02 17:47:28 -07001112LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1113vkDestroySemaphore(VkDevice device, VkSemaphore semaphore,
1114 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001115 const VkLayerDispatchTable *disp;
1116
1117 disp = loader_get_dispatch(device);
1118
Chia-I Wu69f40122015-10-26 21:10:41 +08001119 disp->DestroySemaphore(device, semaphore, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001120}
1121
Jon Ashburn44aed662016-02-02 17:47:28 -07001122LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1123vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo,
1124 const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001125 const VkLayerDispatchTable *disp;
1126
1127 disp = loader_get_dispatch(device);
1128
Chia-I Wu69f40122015-10-26 21:10:41 +08001129 return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001130}
1131
Jon Ashburn44aed662016-02-02 17:47:28 -07001132LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1133vkDestroyEvent(VkDevice device, VkEvent event,
1134 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001135 const VkLayerDispatchTable *disp;
1136
1137 disp = loader_get_dispatch(device);
1138
Chia-I Wu69f40122015-10-26 21:10:41 +08001139 disp->DestroyEvent(device, event, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001140}
1141
Jon Ashburn44aed662016-02-02 17:47:28 -07001142LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1143vkGetEventStatus(VkDevice device, VkEvent event) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001144 const VkLayerDispatchTable *disp;
1145
1146 disp = loader_get_dispatch(device);
1147
1148 return disp->GetEventStatus(device, event);
1149}
1150
Jon Ashburn44aed662016-02-02 17:47:28 -07001151LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1152vkSetEvent(VkDevice device, VkEvent event) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001153 const VkLayerDispatchTable *disp;
1154
1155 disp = loader_get_dispatch(device);
1156
1157 return disp->SetEvent(device, event);
1158}
1159
Jon Ashburn44aed662016-02-02 17:47:28 -07001160LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1161vkResetEvent(VkDevice device, VkEvent event) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001162 const VkLayerDispatchTable *disp;
1163
1164 disp = loader_get_dispatch(device);
1165
1166 return disp->ResetEvent(device, event);
1167}
1168
Jon Ashburn44aed662016-02-02 17:47:28 -07001169LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1170vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo,
1171 const VkAllocationCallbacks *pAllocator,
1172 VkQueryPool *pQueryPool) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001173 const VkLayerDispatchTable *disp;
1174
1175 disp = loader_get_dispatch(device);
1176
Chia-I Wu69f40122015-10-26 21:10:41 +08001177 return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001178}
1179
Jon Ashburn44aed662016-02-02 17:47:28 -07001180LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1181vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool,
1182 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001183 const VkLayerDispatchTable *disp;
1184
1185 disp = loader_get_dispatch(device);
1186
Chia-I Wu69f40122015-10-26 21:10:41 +08001187 disp->DestroyQueryPool(device, queryPool, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001188}
1189
Jon Ashburn44aed662016-02-02 17:47:28 -07001190LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1191vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool,
1192 uint32_t firstQuery, uint32_t queryCount, size_t dataSize,
1193 void *pData, VkDeviceSize stride,
1194 VkQueryResultFlags flags) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001195 const VkLayerDispatchTable *disp;
1196
1197 disp = loader_get_dispatch(device);
1198
Jon Ashburn44aed662016-02-02 17:47:28 -07001199 return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount,
1200 dataSize, pData, stride, flags);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001201}
1202
Jon Ashburn44aed662016-02-02 17:47:28 -07001203LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1204vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo,
1205 const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001206 const VkLayerDispatchTable *disp;
1207
1208 disp = loader_get_dispatch(device);
1209
Chia-I Wu69f40122015-10-26 21:10:41 +08001210 return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001211}
1212
Jon Ashburn44aed662016-02-02 17:47:28 -07001213LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1214vkDestroyBuffer(VkDevice device, VkBuffer buffer,
1215 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001216 const VkLayerDispatchTable *disp;
1217
1218 disp = loader_get_dispatch(device);
1219
Chia-I Wu69f40122015-10-26 21:10:41 +08001220 disp->DestroyBuffer(device, buffer, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001221}
1222
Jon Ashburn44aed662016-02-02 17:47:28 -07001223LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1224vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo,
1225 const VkAllocationCallbacks *pAllocator,
1226 VkBufferView *pView) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001227 const VkLayerDispatchTable *disp;
1228
1229 disp = loader_get_dispatch(device);
1230
Chia-I Wu69f40122015-10-26 21:10:41 +08001231 return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001232}
1233
Jon Ashburn44aed662016-02-02 17:47:28 -07001234LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1235vkDestroyBufferView(VkDevice device, VkBufferView bufferView,
1236 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001237 const VkLayerDispatchTable *disp;
1238
1239 disp = loader_get_dispatch(device);
1240
Chia-I Wu69f40122015-10-26 21:10:41 +08001241 disp->DestroyBufferView(device, bufferView, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001242}
1243
Jon Ashburn44aed662016-02-02 17:47:28 -07001244LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1245vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo,
1246 const VkAllocationCallbacks *pAllocator, VkImage *pImage) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001247 const VkLayerDispatchTable *disp;
1248
1249 disp = loader_get_dispatch(device);
1250
Chia-I Wu69f40122015-10-26 21:10:41 +08001251 return disp->CreateImage(device, pCreateInfo, pAllocator, pImage);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001252}
1253
Jon Ashburn44aed662016-02-02 17:47:28 -07001254LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1255vkDestroyImage(VkDevice device, VkImage image,
1256 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001257 const VkLayerDispatchTable *disp;
1258
1259 disp = loader_get_dispatch(device);
1260
Chia-I Wu69f40122015-10-26 21:10:41 +08001261 disp->DestroyImage(device, image, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001262}
1263
Jon Ashburn44aed662016-02-02 17:47:28 -07001264LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1265vkGetImageSubresourceLayout(VkDevice device, VkImage image,
1266 const VkImageSubresource *pSubresource,
1267 VkSubresourceLayout *pLayout) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001268 const VkLayerDispatchTable *disp;
1269
1270 disp = loader_get_dispatch(device);
1271
Courtney Goeltzenleuchter01d2ae12015-10-20 16:40:38 -06001272 disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001273}
1274
Jon Ashburn44aed662016-02-02 17:47:28 -07001275LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1276vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo,
1277 const VkAllocationCallbacks *pAllocator, VkImageView *pView) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001278 const VkLayerDispatchTable *disp;
1279
1280 disp = loader_get_dispatch(device);
1281
Chia-I Wu69f40122015-10-26 21:10:41 +08001282 return disp->CreateImageView(device, pCreateInfo, pAllocator, pView);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001283}
1284
Jon Ashburn44aed662016-02-02 17:47:28 -07001285LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1286vkDestroyImageView(VkDevice device, VkImageView imageView,
1287 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001288 const VkLayerDispatchTable *disp;
1289
1290 disp = loader_get_dispatch(device);
1291
Chia-I Wu69f40122015-10-26 21:10:41 +08001292 disp->DestroyImageView(device, imageView, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001293}
1294
Jon Ashburn44aed662016-02-02 17:47:28 -07001295LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1296vkCreateShaderModule(VkDevice device,
1297 const VkShaderModuleCreateInfo *pCreateInfo,
1298 const VkAllocationCallbacks *pAllocator,
1299 VkShaderModule *pShader) {
Courtney Goeltzenleuchter0b29b0d2015-06-24 18:24:19 -06001300 const VkLayerDispatchTable *disp;
1301
1302 disp = loader_get_dispatch(device);
1303
Chia-I Wu69f40122015-10-26 21:10:41 +08001304 return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader);
Courtney Goeltzenleuchter0b29b0d2015-06-24 18:24:19 -06001305}
1306
Jon Ashburn44aed662016-02-02 17:47:28 -07001307LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1308vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule,
1309 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001310 const VkLayerDispatchTable *disp;
1311
1312 disp = loader_get_dispatch(device);
1313
Chia-I Wu69f40122015-10-26 21:10:41 +08001314 disp->DestroyShaderModule(device, shaderModule, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001315}
1316
Jon Ashburn44aed662016-02-02 17:47:28 -07001317LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1318vkCreatePipelineCache(VkDevice device,
1319 const VkPipelineCacheCreateInfo *pCreateInfo,
1320 const VkAllocationCallbacks *pAllocator,
1321 VkPipelineCache *pPipelineCache) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001322 const VkLayerDispatchTable *disp;
1323
1324 disp = loader_get_dispatch(device);
1325
Jon Ashburn44aed662016-02-02 17:47:28 -07001326 return disp->CreatePipelineCache(device, pCreateInfo, pAllocator,
1327 pPipelineCache);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001328}
1329
Jon Ashburn44aed662016-02-02 17:47:28 -07001330LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1331vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache,
1332 const VkAllocationCallbacks *pAllocator) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001333 const VkLayerDispatchTable *disp;
1334
1335 disp = loader_get_dispatch(device);
1336
Chia-I Wu69f40122015-10-26 21:10:41 +08001337 disp->DestroyPipelineCache(device, pipelineCache, pAllocator);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001338}
1339
Jon Ashburn44aed662016-02-02 17:47:28 -07001340LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1341vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache,
1342 size_t *pDataSize, void *pData) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001343 const VkLayerDispatchTable *disp;
1344
1345 disp = loader_get_dispatch(device);
1346
Chia-I Wu28c3c432015-10-26 19:17:06 +08001347 return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001348}
1349
Jon Ashburn44aed662016-02-02 17:47:28 -07001350LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1351vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache,
1352 uint32_t srcCacheCount,
1353 const VkPipelineCache *pSrcCaches) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001354 const VkLayerDispatchTable *disp;
1355
1356 disp = loader_get_dispatch(device);
1357
Jon Ashburn44aed662016-02-02 17:47:28 -07001358 return disp->MergePipelineCaches(device, dstCache, srcCacheCount,
1359 pSrcCaches);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001360}
1361
Jon Ashburn44aed662016-02-02 17:47:28 -07001362LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1363vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache,
1364 uint32_t createInfoCount,
1365 const VkGraphicsPipelineCreateInfo *pCreateInfos,
1366 const VkAllocationCallbacks *pAllocator,
1367 VkPipeline *pPipelines) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001368 const VkLayerDispatchTable *disp;
1369
1370 disp = loader_get_dispatch(device);
1371
Jon Ashburn44aed662016-02-02 17:47:28 -07001372 return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount,
1373 pCreateInfos, pAllocator, pPipelines);
Jon Ashburn0d60d272015-07-09 15:02:25 -06001374}
1375
Jon Ashburn44aed662016-02-02 17:47:28 -07001376LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1377vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache,
1378 uint32_t createInfoCount,
1379 const VkComputePipelineCreateInfo *pCreateInfos,
1380 const VkAllocationCallbacks *pAllocator,
1381 VkPipeline *pPipelines) {
Jon Ashburn0d60d272015-07-09 15:02:25 -06001382 const VkLayerDispatchTable *disp;
1383
1384 disp = loader_get_dispatch(device);
1385
Jon Ashburn44aed662016-02-02 17:47:28 -07001386 return disp->CreateComputePipelines(device, pipelineCache, createInfoCount,
1387 pCreateInfos, pAllocator, pPipelines);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001388}
1389
Jon Ashburn44aed662016-02-02 17:47:28 -07001390LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1391vkDestroyPipeline(VkDevice device, VkPipeline pipeline,
1392 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001393 const VkLayerDispatchTable *disp;
1394
1395 disp = loader_get_dispatch(device);
1396
Chia-I Wu69f40122015-10-26 21:10:41 +08001397 disp->DestroyPipeline(device, pipeline, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001398}
1399
Jon Ashburn44aed662016-02-02 17:47:28 -07001400LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1401vkCreatePipelineLayout(VkDevice device,
1402 const VkPipelineLayoutCreateInfo *pCreateInfo,
1403 const VkAllocationCallbacks *pAllocator,
1404 VkPipelineLayout *pPipelineLayout) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001405 const VkLayerDispatchTable *disp;
1406
1407 disp = loader_get_dispatch(device);
1408
Jon Ashburn44aed662016-02-02 17:47:28 -07001409 return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator,
1410 pPipelineLayout);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001411}
1412
Jon Ashburn44aed662016-02-02 17:47:28 -07001413LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1414vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout,
1415 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001416 const VkLayerDispatchTable *disp;
1417
1418 disp = loader_get_dispatch(device);
1419
Chia-I Wu69f40122015-10-26 21:10:41 +08001420 disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001421}
1422
Jon Ashburn44aed662016-02-02 17:47:28 -07001423LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1424vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo,
1425 const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001426 const VkLayerDispatchTable *disp;
1427
1428 disp = loader_get_dispatch(device);
1429
Chia-I Wu69f40122015-10-26 21:10:41 +08001430 return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001431}
1432
Jon Ashburn44aed662016-02-02 17:47:28 -07001433LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1434vkDestroySampler(VkDevice device, VkSampler sampler,
1435 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001436 const VkLayerDispatchTable *disp;
1437
1438 disp = loader_get_dispatch(device);
1439
Chia-I Wu69f40122015-10-26 21:10:41 +08001440 disp->DestroySampler(device, sampler, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001441}
1442
Jon Ashburn44aed662016-02-02 17:47:28 -07001443LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1444vkCreateDescriptorSetLayout(VkDevice device,
1445 const VkDescriptorSetLayoutCreateInfo *pCreateInfo,
1446 const VkAllocationCallbacks *pAllocator,
1447 VkDescriptorSetLayout *pSetLayout) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001448 const VkLayerDispatchTable *disp;
1449
1450 disp = loader_get_dispatch(device);
1451
Jon Ashburn44aed662016-02-02 17:47:28 -07001452 return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator,
1453 pSetLayout);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001454}
1455
Jon Ashburn44aed662016-02-02 17:47:28 -07001456LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1457vkDestroyDescriptorSetLayout(VkDevice device,
1458 VkDescriptorSetLayout descriptorSetLayout,
1459 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001460 const VkLayerDispatchTable *disp;
1461
1462 disp = loader_get_dispatch(device);
1463
Chia-I Wu69f40122015-10-26 21:10:41 +08001464 disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001465}
1466
Jon Ashburn44aed662016-02-02 17:47:28 -07001467LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1468vkCreateDescriptorPool(VkDevice device,
1469 const VkDescriptorPoolCreateInfo *pCreateInfo,
1470 const VkAllocationCallbacks *pAllocator,
1471 VkDescriptorPool *pDescriptorPool) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001472 const VkLayerDispatchTable *disp;
1473
1474 disp = loader_get_dispatch(device);
1475
Jon Ashburn44aed662016-02-02 17:47:28 -07001476 return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator,
1477 pDescriptorPool);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001478}
1479
Jon Ashburn44aed662016-02-02 17:47:28 -07001480LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1481vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
1482 const VkAllocationCallbacks *pAllocator) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001483 const VkLayerDispatchTable *disp;
1484
1485 disp = loader_get_dispatch(device);
1486
Chia-I Wu69f40122015-10-26 21:10:41 +08001487 disp->DestroyDescriptorPool(device, descriptorPool, pAllocator);
Tony Barbourde4124d2015-07-03 10:33:54 -06001488}
1489
Jon Ashburn44aed662016-02-02 17:47:28 -07001490LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1491vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool,
1492 VkDescriptorPoolResetFlags flags) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001493 const VkLayerDispatchTable *disp;
1494
1495 disp = loader_get_dispatch(device);
1496
Courtney Goeltzenleuchter831c1832015-10-23 14:21:05 -06001497 return disp->ResetDescriptorPool(device, descriptorPool, flags);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001498}
1499
Jon Ashburn44aed662016-02-02 17:47:28 -07001500LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1501vkAllocateDescriptorSets(VkDevice device,
1502 const VkDescriptorSetAllocateInfo *pAllocateInfo,
1503 VkDescriptorSet *pDescriptorSets) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001504 const VkLayerDispatchTable *disp;
1505
1506 disp = loader_get_dispatch(device);
1507
Chia-I Wu1f851912015-10-27 18:04:07 +08001508 return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001509}
1510
Jon Ashburn44aed662016-02-02 17:47:28 -07001511LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1512vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool,
1513 uint32_t descriptorSetCount,
1514 const VkDescriptorSet *pDescriptorSets) {
Tony Barbourb857d312015-07-10 10:50:45 -06001515 const VkLayerDispatchTable *disp;
1516
1517 disp = loader_get_dispatch(device);
1518
Jon Ashburn44aed662016-02-02 17:47:28 -07001519 return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount,
1520 pDescriptorSets);
Tony Barbourb857d312015-07-10 10:50:45 -06001521}
1522
Jon Ashburn44aed662016-02-02 17:47:28 -07001523LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1524vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount,
1525 const VkWriteDescriptorSet *pDescriptorWrites,
1526 uint32_t descriptorCopyCount,
1527 const VkCopyDescriptorSet *pDescriptorCopies) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001528 const VkLayerDispatchTable *disp;
1529
1530 disp = loader_get_dispatch(device);
1531
Jon Ashburn44aed662016-02-02 17:47:28 -07001532 disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites,
1533 descriptorCopyCount, pDescriptorCopies);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001534}
1535
Jon Ashburn44aed662016-02-02 17:47:28 -07001536LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1537vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo,
1538 const VkAllocationCallbacks *pAllocator,
1539 VkFramebuffer *pFramebuffer) {
Jon Ashburn4e189562015-07-23 18:49:07 -06001540 const VkLayerDispatchTable *disp;
1541
1542 disp = loader_get_dispatch(device);
1543
Jon Ashburn44aed662016-02-02 17:47:28 -07001544 return disp->CreateFramebuffer(device, pCreateInfo, pAllocator,
1545 pFramebuffer);
Jon Ashburn4e189562015-07-23 18:49:07 -06001546}
1547
Jon Ashburn44aed662016-02-02 17:47:28 -07001548LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1549vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer,
1550 const VkAllocationCallbacks *pAllocator) {
Jon Ashburn4e189562015-07-23 18:49:07 -06001551 const VkLayerDispatchTable *disp;
1552
1553 disp = loader_get_dispatch(device);
1554
Chia-I Wu69f40122015-10-26 21:10:41 +08001555 disp->DestroyFramebuffer(device, framebuffer, pAllocator);
Jon Ashburn4e189562015-07-23 18:49:07 -06001556}
1557
Jon Ashburn44aed662016-02-02 17:47:28 -07001558LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1559vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo,
1560 const VkAllocationCallbacks *pAllocator,
1561 VkRenderPass *pRenderPass) {
Jon Ashburn4e189562015-07-23 18:49:07 -06001562 const VkLayerDispatchTable *disp;
1563
1564 disp = loader_get_dispatch(device);
1565
Chia-I Wu69f40122015-10-26 21:10:41 +08001566 return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass);
Jon Ashburn4e189562015-07-23 18:49:07 -06001567}
1568
Jon Ashburn44aed662016-02-02 17:47:28 -07001569LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1570vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass,
1571 const VkAllocationCallbacks *pAllocator) {
Jon Ashburn4e189562015-07-23 18:49:07 -06001572 const VkLayerDispatchTable *disp;
1573
1574 disp = loader_get_dispatch(device);
1575
Chia-I Wu69f40122015-10-26 21:10:41 +08001576 disp->DestroyRenderPass(device, renderPass, pAllocator);
Jon Ashburn4e189562015-07-23 18:49:07 -06001577}
1578
Jon Ashburn44aed662016-02-02 17:47:28 -07001579LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1580vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass,
1581 VkExtent2D *pGranularity) {
Jon Ashburn4e189562015-07-23 18:49:07 -06001582 const VkLayerDispatchTable *disp;
1583
1584 disp = loader_get_dispatch(device);
1585
Courtney Goeltzenleuchter01d2ae12015-10-20 16:40:38 -06001586 disp->GetRenderAreaGranularity(device, renderPass, pGranularity);
Jon Ashburn4e189562015-07-23 18:49:07 -06001587}
1588
Jon Ashburn44aed662016-02-02 17:47:28 -07001589LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1590vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo,
1591 const VkAllocationCallbacks *pAllocator,
1592 VkCommandPool *pCommandPool) {
Cody Northropf02f9f82015-07-09 18:08:05 -06001593 const VkLayerDispatchTable *disp;
1594
1595 disp = loader_get_dispatch(device);
1596
Jon Ashburn44aed662016-02-02 17:47:28 -07001597 return disp->CreateCommandPool(device, pCreateInfo, pAllocator,
1598 pCommandPool);
Cody Northropf02f9f82015-07-09 18:08:05 -06001599}
1600
Jon Ashburn44aed662016-02-02 17:47:28 -07001601LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1602vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool,
1603 const VkAllocationCallbacks *pAllocator) {
Cody Northropf02f9f82015-07-09 18:08:05 -06001604 const VkLayerDispatchTable *disp;
1605
1606 disp = loader_get_dispatch(device);
1607
Chia-I Wu1f851912015-10-27 18:04:07 +08001608 disp->DestroyCommandPool(device, commandPool, pAllocator);
Cody Northropf02f9f82015-07-09 18:08:05 -06001609}
1610
Jon Ashburn44aed662016-02-02 17:47:28 -07001611LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1612vkResetCommandPool(VkDevice device, VkCommandPool commandPool,
1613 VkCommandPoolResetFlags flags) {
Cody Northropf02f9f82015-07-09 18:08:05 -06001614 const VkLayerDispatchTable *disp;
1615
1616 disp = loader_get_dispatch(device);
1617
Chia-I Wu1f851912015-10-27 18:04:07 +08001618 return disp->ResetCommandPool(device, commandPool, flags);
Cody Northropf02f9f82015-07-09 18:08:05 -06001619}
1620
Jon Ashburn44aed662016-02-02 17:47:28 -07001621LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1622vkAllocateCommandBuffers(VkDevice device,
1623 const VkCommandBufferAllocateInfo *pAllocateInfo,
1624 VkCommandBuffer *pCommandBuffers) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001625 const VkLayerDispatchTable *disp;
1626 VkResult res;
1627
1628 disp = loader_get_dispatch(device);
1629
Chia-I Wu1f851912015-10-27 18:04:07 +08001630 res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001631 if (res == VK_SUCCESS) {
Jon Ashburn44aed662016-02-02 17:47:28 -07001632 for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) {
Chia-I Wu1f851912015-10-27 18:04:07 +08001633 if (pCommandBuffers[i]) {
1634 loader_init_dispatch(pCommandBuffers[i], disp);
Courtney Goeltzenleuchter831c1832015-10-23 14:21:05 -06001635 }
1636 }
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001637 }
1638
1639 return res;
1640}
1641
Jon Ashburn44aed662016-02-02 17:47:28 -07001642LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1643vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool,
1644 uint32_t commandBufferCount,
1645 const VkCommandBuffer *pCommandBuffers) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001646 const VkLayerDispatchTable *disp;
1647
1648 disp = loader_get_dispatch(device);
1649
Jon Ashburn44aed662016-02-02 17:47:28 -07001650 disp->FreeCommandBuffers(device, commandPool, commandBufferCount,
1651 pCommandBuffers);
Tony Barbourde4124d2015-07-03 10:33:54 -06001652}
1653
Jon Ashburn44aed662016-02-02 17:47:28 -07001654LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1655vkBeginCommandBuffer(VkCommandBuffer commandBuffer,
1656 const VkCommandBufferBeginInfo *pBeginInfo) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001657 const VkLayerDispatchTable *disp;
1658
Chia-I Wu1f851912015-10-27 18:04:07 +08001659 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001660
Chia-I Wu1f851912015-10-27 18:04:07 +08001661 return disp->BeginCommandBuffer(commandBuffer, pBeginInfo);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001662}
1663
Jon Ashburn44aed662016-02-02 17:47:28 -07001664LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1665vkEndCommandBuffer(VkCommandBuffer commandBuffer) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001666 const VkLayerDispatchTable *disp;
1667
Chia-I Wu1f851912015-10-27 18:04:07 +08001668 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001669
Chia-I Wu1f851912015-10-27 18:04:07 +08001670 return disp->EndCommandBuffer(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001671}
1672
Jon Ashburn44aed662016-02-02 17:47:28 -07001673LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL
1674vkResetCommandBuffer(VkCommandBuffer commandBuffer,
1675 VkCommandBufferResetFlags flags) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001676 const VkLayerDispatchTable *disp;
1677
Chia-I Wu1f851912015-10-27 18:04:07 +08001678 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001679
Chia-I Wu1f851912015-10-27 18:04:07 +08001680 return disp->ResetCommandBuffer(commandBuffer, flags);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001681}
1682
Jon Ashburn44aed662016-02-02 17:47:28 -07001683LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1684vkCmdBindPipeline(VkCommandBuffer commandBuffer,
1685 VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001686 const VkLayerDispatchTable *disp;
1687
Chia-I Wu1f851912015-10-27 18:04:07 +08001688 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001689
Chia-I Wu1f851912015-10-27 18:04:07 +08001690 disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001691}
1692
Jon Ashburn44aed662016-02-02 17:47:28 -07001693LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1694vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport,
1695 uint32_t viewportCount, const VkViewport *pViewports) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001696 const VkLayerDispatchTable *disp;
1697
Chia-I Wu1f851912015-10-27 18:04:07 +08001698 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001699
Jon Ashburn44aed662016-02-02 17:47:28 -07001700 disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount,
1701 pViewports);
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06001702}
1703
Jon Ashburn44aed662016-02-02 17:47:28 -07001704LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1705vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor,
1706 uint32_t scissorCount, const VkRect2D *pScissors) {
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06001707 const VkLayerDispatchTable *disp;
1708
Chia-I Wu1f851912015-10-27 18:04:07 +08001709 disp = loader_get_dispatch(commandBuffer);
Courtney Goeltzenleuchter932cdb52015-09-21 11:44:06 -06001710
Jon Ashburnf2516522015-12-30 14:06:55 -07001711 disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors);
Tony Barbourde4124d2015-07-03 10:33:54 -06001712}
1713
Jon Ashburn44aed662016-02-02 17:47:28 -07001714LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1715vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001716 const VkLayerDispatchTable *disp;
1717
Chia-I Wu1f851912015-10-27 18:04:07 +08001718 disp = loader_get_dispatch(commandBuffer);
Tony Barbourde4124d2015-07-03 10:33:54 -06001719
Chia-I Wu1f851912015-10-27 18:04:07 +08001720 disp->CmdSetLineWidth(commandBuffer, lineWidth);
Cody Northropf5bd2252015-08-17 11:10:49 -06001721}
1722
Jon Ashburn44aed662016-02-02 17:47:28 -07001723LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1724vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor,
1725 float depthBiasClamp, float depthBiasSlopeFactor) {
Cody Northropf5bd2252015-08-17 11:10:49 -06001726 const VkLayerDispatchTable *disp;
1727
Chia-I Wu1f851912015-10-27 18:04:07 +08001728 disp = loader_get_dispatch(commandBuffer);
Cody Northropf5bd2252015-08-17 11:10:49 -06001729
Jon Ashburn44aed662016-02-02 17:47:28 -07001730 disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor,
1731 depthBiasClamp, depthBiasSlopeFactor);
Tony Barbourde4124d2015-07-03 10:33:54 -06001732}
1733
Jon Ashburn44aed662016-02-02 17:47:28 -07001734LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1735vkCmdSetBlendConstants(VkCommandBuffer commandBuffer,
1736 const float blendConstants[4]) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001737 const VkLayerDispatchTable *disp;
1738
Chia-I Wu1f851912015-10-27 18:04:07 +08001739 disp = loader_get_dispatch(commandBuffer);
Tony Barbourde4124d2015-07-03 10:33:54 -06001740
Chia-I Wu1f851912015-10-27 18:04:07 +08001741 disp->CmdSetBlendConstants(commandBuffer, blendConstants);
Tony Barbourde4124d2015-07-03 10:33:54 -06001742}
1743
Jon Ashburn44aed662016-02-02 17:47:28 -07001744LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1745vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds,
1746 float maxDepthBounds) {
Tony Barbourde4124d2015-07-03 10:33:54 -06001747 const VkLayerDispatchTable *disp;
1748
Chia-I Wu1f851912015-10-27 18:04:07 +08001749 disp = loader_get_dispatch(commandBuffer);
Tony Barbourde4124d2015-07-03 10:33:54 -06001750
Chia-I Wu1f851912015-10-27 18:04:07 +08001751 disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds);
Cody Northrop2605cb02015-08-18 15:21:16 -06001752}
1753
Jon Ashburn44aed662016-02-02 17:47:28 -07001754LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1755vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer,
1756 VkStencilFaceFlags faceMask, uint32_t compareMask) {
Cody Northrop2605cb02015-08-18 15:21:16 -06001757 const VkLayerDispatchTable *disp;
1758
Chia-I Wu1f851912015-10-27 18:04:07 +08001759 disp = loader_get_dispatch(commandBuffer);
Cody Northrop2605cb02015-08-18 15:21:16 -06001760
Chia-I Wuc51b1212015-10-27 19:25:11 +08001761 disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06001762}
1763
Jon Ashburn44aed662016-02-02 17:47:28 -07001764LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1765vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer,
1766 VkStencilFaceFlags faceMask, uint32_t writeMask) {
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06001767 const VkLayerDispatchTable *disp;
1768
Chia-I Wu1f851912015-10-27 18:04:07 +08001769 disp = loader_get_dispatch(commandBuffer);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06001770
Chia-I Wuc51b1212015-10-27 19:25:11 +08001771 disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06001772}
1773
Jon Ashburn44aed662016-02-02 17:47:28 -07001774LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1775vkCmdSetStencilReference(VkCommandBuffer commandBuffer,
1776 VkStencilFaceFlags faceMask, uint32_t reference) {
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06001777 const VkLayerDispatchTable *disp;
1778
Chia-I Wu1f851912015-10-27 18:04:07 +08001779 disp = loader_get_dispatch(commandBuffer);
Courtney Goeltzenleuchter09772bb2015-09-17 15:06:17 -06001780
Chia-I Wuc51b1212015-10-27 19:25:11 +08001781 disp->CmdSetStencilReference(commandBuffer, faceMask, reference);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001782}
1783
Jon Ashburn44aed662016-02-02 17:47:28 -07001784LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(
1785 VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint,
1786 VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount,
1787 const VkDescriptorSet *pDescriptorSets, uint32_t dynamicOffsetCount,
1788 const uint32_t *pDynamicOffsets) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001789 const VkLayerDispatchTable *disp;
1790
Chia-I Wu1f851912015-10-27 18:04:07 +08001791 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001792
Jon Ashburn44aed662016-02-02 17:47:28 -07001793 disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout,
1794 firstSet, descriptorSetCount, pDescriptorSets,
1795 dynamicOffsetCount, pDynamicOffsets);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001796}
1797
Jon Ashburn44aed662016-02-02 17:47:28 -07001798LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1799vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer,
1800 VkDeviceSize offset, VkIndexType indexType) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001801 const VkLayerDispatchTable *disp;
1802
Chia-I Wu1f851912015-10-27 18:04:07 +08001803 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001804
Chia-I Wu1f851912015-10-27 18:04:07 +08001805 disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001806}
1807
Jon Ashburn44aed662016-02-02 17:47:28 -07001808LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1809vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding,
1810 uint32_t bindingCount, const VkBuffer *pBuffers,
1811 const VkDeviceSize *pOffsets) {
Jon Ashburn4e189562015-07-23 18:49:07 -06001812 const VkLayerDispatchTable *disp;
1813
Chia-I Wu1f851912015-10-27 18:04:07 +08001814 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn4e189562015-07-23 18:49:07 -06001815
Jon Ashburn44aed662016-02-02 17:47:28 -07001816 disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount,
1817 pBuffers, pOffsets);
Jon Ashburn4e189562015-07-23 18:49:07 -06001818}
1819
Jon Ashburn44aed662016-02-02 17:47:28 -07001820LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1821vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount,
1822 uint32_t instanceCount, uint32_t firstVertex,
1823 uint32_t firstInstance) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001824 const VkLayerDispatchTable *disp;
1825
Chia-I Wu1f851912015-10-27 18:04:07 +08001826 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001827
Jon Ashburn44aed662016-02-02 17:47:28 -07001828 disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex,
1829 firstInstance);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001830}
1831
Jon Ashburn44aed662016-02-02 17:47:28 -07001832LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1833vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount,
1834 uint32_t instanceCount, uint32_t firstIndex,
1835 int32_t vertexOffset, uint32_t firstInstance) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001836 const VkLayerDispatchTable *disp;
1837
Chia-I Wu1f851912015-10-27 18:04:07 +08001838 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001839
Jon Ashburn44aed662016-02-02 17:47:28 -07001840 disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex,
1841 vertexOffset, firstInstance);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001842}
1843
Jon Ashburn44aed662016-02-02 17:47:28 -07001844LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1845vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
1846 VkDeviceSize offset, uint32_t drawCount, uint32_t stride) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001847 const VkLayerDispatchTable *disp;
1848
Chia-I Wu1f851912015-10-27 18:04:07 +08001849 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001850
Chia-I Wu1f851912015-10-27 18:04:07 +08001851 disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001852}
1853
Jon Ashburn44aed662016-02-02 17:47:28 -07001854LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1855vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
1856 VkDeviceSize offset, uint32_t drawCount,
1857 uint32_t stride) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001858 const VkLayerDispatchTable *disp;
1859
Chia-I Wu1f851912015-10-27 18:04:07 +08001860 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001861
Jon Ashburn44aed662016-02-02 17:47:28 -07001862 disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount,
1863 stride);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001864}
1865
Jon Ashburn44aed662016-02-02 17:47:28 -07001866LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1867vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y,
1868 uint32_t z) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001869 const VkLayerDispatchTable *disp;
1870
Chia-I Wu1f851912015-10-27 18:04:07 +08001871 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001872
Chia-I Wu1f851912015-10-27 18:04:07 +08001873 disp->CmdDispatch(commandBuffer, x, y, z);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001874}
1875
Jon Ashburn44aed662016-02-02 17:47:28 -07001876LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1877vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer,
1878 VkDeviceSize offset) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001879 const VkLayerDispatchTable *disp;
1880
Chia-I Wu1f851912015-10-27 18:04:07 +08001881 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001882
Chia-I Wu1f851912015-10-27 18:04:07 +08001883 disp->CmdDispatchIndirect(commandBuffer, buffer, offset);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001884}
1885
Jon Ashburn44aed662016-02-02 17:47:28 -07001886LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1887vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
1888 VkBuffer dstBuffer, uint32_t regionCount,
1889 const VkBufferCopy *pRegions) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001890 const VkLayerDispatchTable *disp;
1891
Chia-I Wu1f851912015-10-27 18:04:07 +08001892 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001893
Jon Ashburn44aed662016-02-02 17:47:28 -07001894 disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount,
1895 pRegions);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001896}
1897
Jon Ashburn44aed662016-02-02 17:47:28 -07001898LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1899vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage,
1900 VkImageLayout srcImageLayout, VkImage dstImage,
1901 VkImageLayout dstImageLayout, uint32_t regionCount,
1902 const VkImageCopy *pRegions) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001903 const VkLayerDispatchTable *disp;
1904
Chia-I Wu1f851912015-10-27 18:04:07 +08001905 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001906
Jon Ashburn44aed662016-02-02 17:47:28 -07001907 disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage,
1908 dstImageLayout, regionCount, pRegions);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001909}
1910
Jon Ashburn44aed662016-02-02 17:47:28 -07001911LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1912vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage,
1913 VkImageLayout srcImageLayout, VkImage dstImage,
1914 VkImageLayout dstImageLayout, uint32_t regionCount,
1915 const VkImageBlit *pRegions, VkFilter filter) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001916 const VkLayerDispatchTable *disp;
1917
Chia-I Wu1f851912015-10-27 18:04:07 +08001918 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001919
Jon Ashburn44aed662016-02-02 17:47:28 -07001920 disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage,
1921 dstImageLayout, regionCount, pRegions, filter);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001922}
1923
Jon Ashburn44aed662016-02-02 17:47:28 -07001924LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1925vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer,
1926 VkImage dstImage, VkImageLayout dstImageLayout,
1927 uint32_t regionCount,
1928 const VkBufferImageCopy *pRegions) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001929 const VkLayerDispatchTable *disp;
1930
Chia-I Wu1f851912015-10-27 18:04:07 +08001931 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001932
Jon Ashburn44aed662016-02-02 17:47:28 -07001933 disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage,
1934 dstImageLayout, regionCount, pRegions);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001935}
1936
Jon Ashburn44aed662016-02-02 17:47:28 -07001937LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1938vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage,
1939 VkImageLayout srcImageLayout, VkBuffer dstBuffer,
1940 uint32_t regionCount,
1941 const VkBufferImageCopy *pRegions) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001942 const VkLayerDispatchTable *disp;
1943
Chia-I Wu1f851912015-10-27 18:04:07 +08001944 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001945
Jon Ashburn44aed662016-02-02 17:47:28 -07001946 disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout,
1947 dstBuffer, regionCount, pRegions);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001948}
1949
Jon Ashburn44aed662016-02-02 17:47:28 -07001950LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1951vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
1952 VkDeviceSize dstOffset, VkDeviceSize dataSize,
1953 const uint32_t *pData) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001954 const VkLayerDispatchTable *disp;
1955
Chia-I Wu1f851912015-10-27 18:04:07 +08001956 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001957
Chia-I Wu1f851912015-10-27 18:04:07 +08001958 disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001959}
1960
Jon Ashburn44aed662016-02-02 17:47:28 -07001961LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1962vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer,
1963 VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001964 const VkLayerDispatchTable *disp;
1965
Chia-I Wu1f851912015-10-27 18:04:07 +08001966 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001967
Chia-I Wu1f851912015-10-27 18:04:07 +08001968 disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001969}
1970
Jon Ashburn44aed662016-02-02 17:47:28 -07001971LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1972vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image,
1973 VkImageLayout imageLayout, const VkClearColorValue *pColor,
1974 uint32_t rangeCount,
1975 const VkImageSubresourceRange *pRanges) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001976 const VkLayerDispatchTable *disp;
1977
Chia-I Wu1f851912015-10-27 18:04:07 +08001978 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001979
Jon Ashburn44aed662016-02-02 17:47:28 -07001980 disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor,
1981 rangeCount, pRanges);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001982}
1983
Jon Ashburn44aed662016-02-02 17:47:28 -07001984LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1985vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image,
1986 VkImageLayout imageLayout,
1987 const VkClearDepthStencilValue *pDepthStencil,
1988 uint32_t rangeCount,
1989 const VkImageSubresourceRange *pRanges) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001990 const VkLayerDispatchTable *disp;
1991
Chia-I Wu1f851912015-10-27 18:04:07 +08001992 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06001993
Jon Ashburn44aed662016-02-02 17:47:28 -07001994 disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout,
1995 pDepthStencil, rangeCount, pRanges);
Chris Forbes2951d7d2015-06-22 17:21:59 +12001996}
1997
Jon Ashburn44aed662016-02-02 17:47:28 -07001998LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
1999vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount,
2000 const VkClearAttachment *pAttachments, uint32_t rectCount,
2001 const VkClearRect *pRects) {
Chris Forbes2951d7d2015-06-22 17:21:59 +12002002 const VkLayerDispatchTable *disp;
2003
Chia-I Wu1f851912015-10-27 18:04:07 +08002004 disp = loader_get_dispatch(commandBuffer);
Chris Forbes2951d7d2015-06-22 17:21:59 +12002005
Jon Ashburn44aed662016-02-02 17:47:28 -07002006 disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments,
2007 rectCount, pRects);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002008}
2009
Jon Ashburn44aed662016-02-02 17:47:28 -07002010LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2011vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage,
2012 VkImageLayout srcImageLayout, VkImage dstImage,
2013 VkImageLayout dstImageLayout, uint32_t regionCount,
2014 const VkImageResolve *pRegions) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002015 const VkLayerDispatchTable *disp;
2016
Chia-I Wu1f851912015-10-27 18:04:07 +08002017 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002018
Jon Ashburn44aed662016-02-02 17:47:28 -07002019 disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage,
2020 dstImageLayout, regionCount, pRegions);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002021}
2022
Jon Ashburn44aed662016-02-02 17:47:28 -07002023LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2024vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event,
2025 VkPipelineStageFlags stageMask) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002026 const VkLayerDispatchTable *disp;
2027
Chia-I Wu1f851912015-10-27 18:04:07 +08002028 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002029
Chia-I Wu1f851912015-10-27 18:04:07 +08002030 disp->CmdSetEvent(commandBuffer, event, stageMask);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002031}
2032
Jon Ashburn44aed662016-02-02 17:47:28 -07002033LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2034vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event,
2035 VkPipelineStageFlags stageMask) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002036 const VkLayerDispatchTable *disp;
2037
Chia-I Wu1f851912015-10-27 18:04:07 +08002038 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002039
Chia-I Wu1f851912015-10-27 18:04:07 +08002040 disp->CmdResetEvent(commandBuffer, event, stageMask);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002041}
2042
Jon Ashburn44aed662016-02-02 17:47:28 -07002043LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2044vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount,
2045 const VkEvent *pEvents, VkPipelineStageFlags sourceStageMask,
2046 VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount,
2047 const VkMemoryBarrier *pMemoryBarriers,
2048 uint32_t bufferMemoryBarrierCount,
2049 const VkBufferMemoryBarrier *pBufferMemoryBarriers,
2050 uint32_t imageMemoryBarrierCount,
2051 const VkImageMemoryBarrier *pImageMemoryBarriers) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002052 const VkLayerDispatchTable *disp;
2053
Chia-I Wu1f851912015-10-27 18:04:07 +08002054 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002055
Jon Ashburna4ae48b2016-01-11 13:12:43 -07002056 disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask,
2057 dstStageMask, memoryBarrierCount, pMemoryBarriers,
2058 bufferMemoryBarrierCount, pBufferMemoryBarriers,
2059 imageMemoryBarrierCount, pImageMemoryBarriers);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002060}
2061
Jon Ashburna4ae48b2016-01-11 13:12:43 -07002062LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(
Jon Ashburn44aed662016-02-02 17:47:28 -07002063 VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask,
2064 VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags,
2065 uint32_t memoryBarrierCount, const VkMemoryBarrier *pMemoryBarriers,
2066 uint32_t bufferMemoryBarrierCount,
2067 const VkBufferMemoryBarrier *pBufferMemoryBarriers,
2068 uint32_t imageMemoryBarrierCount,
2069 const VkImageMemoryBarrier *pImageMemoryBarriers) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002070 const VkLayerDispatchTable *disp;
2071
Chia-I Wu1f851912015-10-27 18:04:07 +08002072 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002073
Jon Ashburn44aed662016-02-02 17:47:28 -07002074 disp->CmdPipelineBarrier(
2075 commandBuffer, srcStageMask, dstStageMask, dependencyFlags,
2076 memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount,
2077 pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002078}
2079
Jon Ashburn44aed662016-02-02 17:47:28 -07002080LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2081vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
2082 uint32_t slot, VkFlags flags) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002083 const VkLayerDispatchTable *disp;
2084
Chia-I Wu1f851912015-10-27 18:04:07 +08002085 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002086
Chia-I Wu1f851912015-10-27 18:04:07 +08002087 disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002088}
2089
Jon Ashburn44aed662016-02-02 17:47:28 -07002090LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2091vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
2092 uint32_t slot) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002093 const VkLayerDispatchTable *disp;
2094
Chia-I Wu1f851912015-10-27 18:04:07 +08002095 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002096
Chia-I Wu1f851912015-10-27 18:04:07 +08002097 disp->CmdEndQuery(commandBuffer, queryPool, slot);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002098}
2099
Jon Ashburn44aed662016-02-02 17:47:28 -07002100LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2101vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
2102 uint32_t firstQuery, uint32_t queryCount) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002103 const VkLayerDispatchTable *disp;
2104
Chia-I Wu1f851912015-10-27 18:04:07 +08002105 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002106
Jon Ashburnf2516522015-12-30 14:06:55 -07002107 disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002108}
2109
Jon Ashburn44aed662016-02-02 17:47:28 -07002110LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2111vkCmdWriteTimestamp(VkCommandBuffer commandBuffer,
2112 VkPipelineStageFlagBits pipelineStage,
2113 VkQueryPool queryPool, uint32_t slot) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002114 const VkLayerDispatchTable *disp;
2115
Chia-I Wu1f851912015-10-27 18:04:07 +08002116 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002117
Chia-I Wu1f851912015-10-27 18:04:07 +08002118 disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002119}
2120
Jon Ashburn44aed662016-02-02 17:47:28 -07002121LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2122vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool,
2123 uint32_t firstQuery, uint32_t queryCount,
2124 VkBuffer dstBuffer, VkDeviceSize dstOffset,
2125 VkDeviceSize stride, VkFlags flags) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002126 const VkLayerDispatchTable *disp;
2127
Chia-I Wu1f851912015-10-27 18:04:07 +08002128 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002129
Jon Ashburn44aed662016-02-02 17:47:28 -07002130 disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery,
2131 queryCount, dstBuffer, dstOffset, stride,
2132 flags);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002133}
2134
Jon Ashburn44aed662016-02-02 17:47:28 -07002135LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2136vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout,
2137 VkShaderStageFlags stageFlags, uint32_t offset,
2138 uint32_t size, const void *pValues) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002139 const VkLayerDispatchTable *disp;
2140
Chia-I Wu1f851912015-10-27 18:04:07 +08002141 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002142
Jon Ashburn44aed662016-02-02 17:47:28 -07002143 disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size,
2144 pValues);
Tony Barbourde4124d2015-07-03 10:33:54 -06002145}
2146
Jon Ashburn44aed662016-02-02 17:47:28 -07002147LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2148vkCmdBeginRenderPass(VkCommandBuffer commandBuffer,
2149 const VkRenderPassBeginInfo *pRenderPassBegin,
2150 VkSubpassContents contents) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002151 const VkLayerDispatchTable *disp;
2152
Chia-I Wu1f851912015-10-27 18:04:07 +08002153 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002154
Chia-I Wu1f851912015-10-27 18:04:07 +08002155 disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents);
Chia-I Wuc278df82015-07-07 11:50:03 +08002156}
2157
Jon Ashburn44aed662016-02-02 17:47:28 -07002158LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2159vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) {
Chia-I Wuc278df82015-07-07 11:50:03 +08002160 const VkLayerDispatchTable *disp;
2161
Chia-I Wu1f851912015-10-27 18:04:07 +08002162 disp = loader_get_dispatch(commandBuffer);
Chia-I Wuc278df82015-07-07 11:50:03 +08002163
Chia-I Wu1f851912015-10-27 18:04:07 +08002164 disp->CmdNextSubpass(commandBuffer, contents);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002165}
2166
Jon Ashburn44aed662016-02-02 17:47:28 -07002167LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2168vkCmdEndRenderPass(VkCommandBuffer commandBuffer) {
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002169 const VkLayerDispatchTable *disp;
2170
Chia-I Wu1f851912015-10-27 18:04:07 +08002171 disp = loader_get_dispatch(commandBuffer);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002172
Chia-I Wu1f851912015-10-27 18:04:07 +08002173 disp->CmdEndRenderPass(commandBuffer);
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08002174}
2175
Jon Ashburn44aed662016-02-02 17:47:28 -07002176LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL
2177vkCmdExecuteCommands(VkCommandBuffer commandBuffer,
2178 uint32_t commandBuffersCount,
2179 const VkCommandBuffer *pCommandBuffers) {
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08002180 const VkLayerDispatchTable *disp;
2181
Chia-I Wu1f851912015-10-27 18:04:07 +08002182 disp = loader_get_dispatch(commandBuffer);
Chia-I Wu88eaa3b2015-06-26 15:34:39 +08002183
Jon Ashburn44aed662016-02-02 17:47:28 -07002184 disp->CmdExecuteCommands(commandBuffer, commandBuffersCount,
2185 pCommandBuffers);
Jon Ashburn2139a3e2015-05-06 09:02:10 -06002186}