1 /* 2 * 3 * Copyright (c) 2015-2016 The Khronos Group Inc. 4 * Copyright (c) 2015-2016 Valve Corporation 5 * Copyright (c) 2015-2016 LunarG, Inc. 6 * Copyright (C) 2015 Google Inc. 7 * 8 * 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: 14 * 15 * The above copyright notice(s) and this permission notice shall be included in 16 * all copies or substantial portions of the Materials. 17 * 18 * THE MATERIALS ARE PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 19 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 20 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. 21 * 22 * 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 (at) lunarg.com> 28 * Author: Jon Ashburn <jon (at) lunarg.com> 29 * Author: Tony Barbour <tony (at) LunarG.com> 30 * Author: Chia-I Wu <olv (at) lunarg.com> 31 */ 32 #define _GNU_SOURCE 33 #include <stdlib.h> 34 #include <string.h> 35 36 #include "vk_loader_platform.h" 37 #include "loader.h" 38 #include "debug_report.h" 39 #include "wsi.h" 40 #include "gpa_helper.h" 41 #include "table_ops.h" 42 43 /* 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 */ 54 LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL 55 vkGetInstanceProcAddr(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 */ 91 LOADER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL 92 vkGetDeviceProcAddr(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 123 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 124 vkEnumerateInstanceExtensionProperties(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 199 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 200 vkEnumerateInstanceLayerProperties(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 238 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 239 vkCreateInstance(const VkInstanceCreateInfo *pCreateInfo, 240 const VkAllocationCallbacks *pAllocator, 241 VkInstance *pInstance) { 242 struct loader_instance *ptr_instance = NULL; 243 VkInstance created_instance = VK_NULL_HANDLE; 244 VkResult res = VK_ERROR_INITIALIZATION_FAILED; 245 VkDebugReportCallbackEXT instance_callback = VK_NULL_HANDLE; 246 void *pNext = (void *)pCreateInfo->pNext; 247 248 loader_platform_thread_once(&once_init, loader_initialize); 249 250 #if 0 251 if (pAllocator) { 252 ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation( 253 pAllocator->pUserData, 254 sizeof(struct loader_instance), 255 sizeof(int *), 256 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); 257 } else { 258 #endif 259 ptr_instance = 260 (struct loader_instance *)malloc(sizeof(struct loader_instance)); 261 //} 262 if (ptr_instance == NULL) { 263 return VK_ERROR_OUT_OF_HOST_MEMORY; 264 } 265 266 tls_instance = ptr_instance; 267 loader_platform_thread_lock_mutex(&loader_lock); 268 memset(ptr_instance, 0, sizeof(struct loader_instance)); 269 #if 0 270 if (pAllocator) { 271 ptr_instance->alloc_callbacks = *pAllocator; 272 } 273 #endif 274 275 /* 276 * Look for a debug report create info structure 277 * and setup a callback if found. 278 */ 279 while (pNext) { 280 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)) { 285 loader_heap_free(ptr_instance, ptr_instance); 286 loader_platform_thread_unlock_mutex(&loader_lock); 287 return VK_ERROR_OUT_OF_HOST_MEMORY; 288 } 289 } 290 pNext = (void *)((VkInstanceCreateInfo *)pNext)->pNext; 291 } 292 293 /* Due to implicit layers need to get layer list even if 294 * enabledLayerCount == 0 and VK_INSTANCE_LAYERS is unset. For now always 295 * get layer list (both instance and device) via loader_layer_scan(). */ 296 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, 301 &ptr_instance->device_layer_list); 302 303 /* validate the app requested layers to be enabled */ 304 if (pCreateInfo->enabledLayerCount > 0) { 305 res = 306 loader_validate_layers(ptr_instance, pCreateInfo->enabledLayerCount, 307 pCreateInfo->ppEnabledLayerNames, 308 &ptr_instance->instance_layer_list); 309 if (res != VK_SUCCESS) { 310 util_DestroyDebugReportCallback(ptr_instance, instance_callback, 311 NULL); 312 loader_heap_free(ptr_instance, ptr_instance); 313 loader_platform_thread_unlock_mutex(&loader_lock); 314 return res; 315 } 316 } 317 318 /* convert any meta layers to the actual layers makes a copy of layer name*/ 319 uint32_t saved_layer_count = pCreateInfo->enabledLayerCount; 320 char **saved_layer_names; 321 char **saved_layer_ptr; 322 saved_layer_names = 323 loader_stack_alloc(sizeof(char *) * pCreateInfo->enabledLayerCount); 324 for (uint32_t i = 0; i < saved_layer_count; i++) { 325 saved_layer_names[i] = (char *)pCreateInfo->ppEnabledLayerNames[i]; 326 } 327 saved_layer_ptr = (char **)pCreateInfo->ppEnabledLayerNames; 328 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 335 /* Scan/discover all ICD libraries */ 336 memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs)); 337 loader_icd_scan(ptr_instance, &ptr_instance->icd_libs); 338 339 /* get extensions from all ICD's, merge so no duplicates, then validate */ 340 loader_get_icd_loader_instance_extensions( 341 ptr_instance, &ptr_instance->icd_libs, &ptr_instance->ext_list); 342 res = loader_validate_instance_extensions( 343 ptr_instance, &ptr_instance->ext_list, 344 &ptr_instance->instance_layer_list, pCreateInfo); 345 if (res != VK_SUCCESS) { 346 loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count, 347 saved_layer_names, saved_layer_ptr, 348 pCreateInfo); 349 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); 354 loader_destroy_generic_list( 355 ptr_instance, 356 (struct loader_generic_list *)&ptr_instance->ext_list); 357 util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL); 358 loader_platform_thread_unlock_mutex(&loader_lock); 359 loader_heap_free(ptr_instance, ptr_instance); 360 return res; 361 } 362 363 ptr_instance->disp = 364 loader_heap_alloc(ptr_instance, sizeof(VkLayerInstanceDispatchTable), 365 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); 366 if (ptr_instance->disp == NULL) { 367 loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count, 368 saved_layer_names, saved_layer_ptr, 369 pCreateInfo); 370 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); 374 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); 378 util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL); 379 loader_platform_thread_unlock_mutex(&loader_lock); 380 loader_heap_free(ptr_instance, ptr_instance); 381 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 387 /* activate any layers on instance chain */ 388 res = loader_enable_instance_layers(ptr_instance, pCreateInfo, 389 &ptr_instance->instance_layer_list); 390 if (res != VK_SUCCESS) { 391 loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count, 392 saved_layer_names, saved_layer_ptr, 393 pCreateInfo); 394 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); 398 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); 402 loader.instances = ptr_instance->next; 403 util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL); 404 loader_platform_thread_unlock_mutex(&loader_lock); 405 loader_heap_free(ptr_instance, ptr_instance->disp); 406 loader_heap_free(ptr_instance, ptr_instance); 407 return res; 408 } 409 410 created_instance = (VkInstance)ptr_instance; 411 res = loader_create_instance_chain(pCreateInfo, pAllocator, ptr_instance, 412 &created_instance); 413 414 if (res == VK_SUCCESS) { 415 wsi_create_instance(ptr_instance, pCreateInfo); 416 debug_report_create_instance(ptr_instance, pCreateInfo); 417 418 *pInstance = created_instance; 419 420 /* 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); 427 } else { 428 // TODO: cleanup here. 429 } 430 431 /* Remove temporary debug_report callback */ 432 util_DestroyDebugReportCallback(ptr_instance, instance_callback, NULL); 433 loader_unexpand_inst_layer_names(ptr_instance, saved_layer_count, 434 saved_layer_names, saved_layer_ptr, 435 pCreateInfo); 436 loader_platform_thread_unlock_mutex(&loader_lock); 437 return res; 438 } 439 440 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 441 vkDestroyInstance(VkInstance instance, 442 const VkAllocationCallbacks *pAllocator) { 443 const VkLayerInstanceDispatchTable *disp; 444 struct loader_instance *ptr_instance = NULL; 445 disp = loader_get_instance_dispatch(instance); 446 447 loader_platform_thread_lock_mutex(&loader_lock); 448 449 /* TODO: Do we need a temporary callback here to catch cleanup issues? */ 450 451 ptr_instance = loader_get_instance(instance); 452 disp->DestroyInstance(instance, pAllocator); 453 454 loader_deactivate_instance_layers(ptr_instance); 455 if (ptr_instance->phys_devs) 456 loader_heap_free(ptr_instance, ptr_instance->phys_devs); 457 loader_heap_free(ptr_instance, ptr_instance->disp); 458 loader_heap_free(ptr_instance, ptr_instance); 459 loader_platform_thread_unlock_mutex(&loader_lock); 460 } 461 462 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 463 vkEnumeratePhysicalDevices(VkInstance instance, uint32_t *pPhysicalDeviceCount, 464 VkPhysicalDevice *pPhysicalDevices) { 465 const VkLayerInstanceDispatchTable *disp; 466 VkResult res; 467 uint32_t count, i; 468 struct loader_instance *inst; 469 disp = loader_get_instance_dispatch(instance); 470 471 loader_platform_thread_lock_mutex(&loader_lock); 472 res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, 473 pPhysicalDevices); 474 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 } 512 loader_platform_thread_unlock_mutex(&loader_lock); 513 return res; 514 } 515 516 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 517 vkGetPhysicalDeviceFeatures(VkPhysicalDevice physicalDevice, 518 VkPhysicalDeviceFeatures *pFeatures) { 519 const VkLayerInstanceDispatchTable *disp; 520 VkPhysicalDevice unwrapped_phys_dev = 521 loader_unwrap_physical_device(physicalDevice); 522 disp = loader_get_instance_dispatch(physicalDevice); 523 disp->GetPhysicalDeviceFeatures(unwrapped_phys_dev, pFeatures); 524 } 525 526 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 527 vkGetPhysicalDeviceFormatProperties(VkPhysicalDevice physicalDevice, 528 VkFormat format, 529 VkFormatProperties *pFormatInfo) { 530 const VkLayerInstanceDispatchTable *disp; 531 VkPhysicalDevice unwrapped_pd = 532 loader_unwrap_physical_device(physicalDevice); 533 disp = loader_get_instance_dispatch(physicalDevice); 534 disp->GetPhysicalDeviceFormatProperties(unwrapped_pd, format, pFormatInfo); 535 } 536 537 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 538 vkGetPhysicalDeviceImageFormatProperties( 539 VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, 540 VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, 541 VkImageFormatProperties *pImageFormatProperties) { 542 const VkLayerInstanceDispatchTable *disp; 543 VkPhysicalDevice unwrapped_phys_dev = 544 loader_unwrap_physical_device(physicalDevice); 545 disp = loader_get_instance_dispatch(physicalDevice); 546 return disp->GetPhysicalDeviceImageFormatProperties( 547 unwrapped_phys_dev, format, type, tiling, usage, flags, 548 pImageFormatProperties); 549 } 550 551 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 552 vkGetPhysicalDeviceProperties(VkPhysicalDevice physicalDevice, 553 VkPhysicalDeviceProperties *pProperties) { 554 const VkLayerInstanceDispatchTable *disp; 555 VkPhysicalDevice unwrapped_phys_dev = 556 loader_unwrap_physical_device(physicalDevice); 557 disp = loader_get_instance_dispatch(physicalDevice); 558 disp->GetPhysicalDeviceProperties(unwrapped_phys_dev, pProperties); 559 } 560 561 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 562 vkGetPhysicalDeviceQueueFamilyProperties( 563 VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, 564 VkQueueFamilyProperties *pQueueProperties) { 565 const VkLayerInstanceDispatchTable *disp; 566 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); 571 } 572 573 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( 574 VkPhysicalDevice physicalDevice, 575 VkPhysicalDeviceMemoryProperties *pMemoryProperties) { 576 const VkLayerInstanceDispatchTable *disp; 577 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); 582 } 583 584 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 585 vkCreateDevice(VkPhysicalDevice physicalDevice, 586 const VkDeviceCreateInfo *pCreateInfo, 587 const VkAllocationCallbacks *pAllocator, VkDevice *pDevice) { 588 VkResult res; 589 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); 596 597 loader_platform_thread_lock_mutex(&loader_lock); 598 599 phys_dev = (struct loader_physical_device *)physicalDevice; 600 icd = phys_dev->this_icd; 601 if (!icd) { 602 loader_platform_thread_unlock_mutex(&loader_lock); 603 return VK_ERROR_INITIALIZATION_FAILED; 604 } 605 606 inst = (struct loader_instance *)phys_dev->this_icd->this_instance; 607 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 624 /* 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 } 631 632 //TODO handle more than one phys dev per icd (icd->phys_devs[0]) 633 res = loader_add_device_extensions( 634 inst, icd, icd->phys_devs[0], 635 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; 639 } 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, 671 &icd_exts, pCreateInfo); 672 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 712 res = loader_create_device_chain(phys_dev, pCreateInfo, pAllocator, inst, 713 icd, dev); 714 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); 737 738 loader_platform_thread_unlock_mutex(&loader_lock); 739 return res; 740 } 741 742 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 743 vkDestroyDevice(VkDevice device, const VkAllocationCallbacks *pAllocator) { 744 const VkLayerDispatchTable *disp; 745 struct loader_device *dev; 746 747 loader_platform_thread_lock_mutex(&loader_lock); 748 749 struct loader_icd *icd = loader_get_icd_and_device(device, &dev); 750 const struct loader_instance *inst = icd->this_instance; 751 disp = loader_get_dispatch(device); 752 753 disp->DestroyDevice(device, pAllocator); 754 dev->device = NULL; 755 loader_remove_logical_device(inst, icd, dev); 756 757 loader_platform_thread_unlock_mutex(&loader_lock); 758 } 759 760 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 761 vkEnumerateDeviceExtensionProperties(VkPhysicalDevice physicalDevice, 762 const char *pLayerName, 763 uint32_t *pPropertyCount, 764 VkExtensionProperties *pProperties) { 765 VkResult res = VK_SUCCESS; 766 struct loader_physical_device *phys_dev; 767 phys_dev = (struct loader_physical_device *)physicalDevice; 768 769 loader_platform_thread_lock_mutex(&loader_lock); 770 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. */ 775 if (pLayerName == NULL || strlen(pLayerName) == 0) { 776 const VkLayerInstanceDispatchTable *disp; 777 778 disp = loader_get_instance_dispatch(physicalDevice); 779 res = disp->EnumerateDeviceExtensionProperties( 780 phys_dev->phys_dev, NULL, pPropertyCount, pProperties); 781 } else { 782 783 uint32_t count; 784 uint32_t copy_size; 785 const struct loader_instance *inst = phys_dev->this_icd->this_instance; 786 if (vk_string_validate(MaxLoaderStringLength, pLayerName) == 787 VK_STRING_ERROR_NONE) { 788 789 struct loader_device_extension_list *dev_ext_list = NULL; 790 for (uint32_t i = 0; i < inst->device_layer_list.count; i++) { 791 struct loader_layer_properties *props = 792 &inst->device_layer_list.list[i]; 793 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, 807 sizeof(VkExtensionProperties)); 808 } 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 { 816 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); 820 return VK_ERROR_EXTENSION_NOT_PRESENT; 821 } 822 } 823 824 loader_platform_thread_unlock_mutex(&loader_lock); 825 return res; 826 } 827 828 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 829 vkEnumerateDeviceLayerProperties(VkPhysicalDevice physicalDevice, 830 uint32_t *pPropertyCount, 831 VkLayerProperties *pProperties) { 832 uint32_t copy_size; 833 struct loader_physical_device *phys_dev; 834 835 loader_platform_thread_lock_mutex(&loader_lock); 836 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 */ 839 840 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; 843 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++) { 852 memcpy(&pProperties[i], &(inst->device_layer_list.list[i].info), 853 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 862 loader_platform_thread_unlock_mutex(&loader_lock); 863 return VK_SUCCESS; 864 } 865 866 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 867 vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, 868 VkQueue *pQueue) { 869 const VkLayerDispatchTable *disp; 870 871 disp = loader_get_dispatch(device); 872 873 disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); 874 loader_set_dispatch(*pQueue, disp); 875 } 876 877 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 878 vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo *pSubmits, 879 VkFence fence) { 880 const VkLayerDispatchTable *disp; 881 882 disp = loader_get_dispatch(queue); 883 884 return disp->QueueSubmit(queue, submitCount, pSubmits, fence); 885 } 886 887 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) { 888 const VkLayerDispatchTable *disp; 889 890 disp = loader_get_dispatch(queue); 891 892 return disp->QueueWaitIdle(queue); 893 } 894 895 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) { 896 const VkLayerDispatchTable *disp; 897 898 disp = loader_get_dispatch(device); 899 900 return disp->DeviceWaitIdle(device); 901 } 902 903 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 904 vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo *pAllocateInfo, 905 const VkAllocationCallbacks *pAllocator, 906 VkDeviceMemory *pMemory) { 907 const VkLayerDispatchTable *disp; 908 909 disp = loader_get_dispatch(device); 910 911 return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); 912 } 913 914 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 915 vkFreeMemory(VkDevice device, VkDeviceMemory mem, 916 const VkAllocationCallbacks *pAllocator) { 917 const VkLayerDispatchTable *disp; 918 919 disp = loader_get_dispatch(device); 920 921 disp->FreeMemory(device, mem, pAllocator); 922 } 923 924 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 925 vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, 926 VkDeviceSize size, VkFlags flags, void **ppData) { 927 const VkLayerDispatchTable *disp; 928 929 disp = loader_get_dispatch(device); 930 931 return disp->MapMemory(device, mem, offset, size, flags, ppData); 932 } 933 934 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 935 vkUnmapMemory(VkDevice device, VkDeviceMemory mem) { 936 const VkLayerDispatchTable *disp; 937 938 disp = loader_get_dispatch(device); 939 940 disp->UnmapMemory(device, mem); 941 } 942 943 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 944 vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, 945 const VkMappedMemoryRange *pMemoryRanges) { 946 const VkLayerDispatchTable *disp; 947 948 disp = loader_get_dispatch(device); 949 950 return disp->FlushMappedMemoryRanges(device, memoryRangeCount, 951 pMemoryRanges); 952 } 953 954 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 955 vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, 956 const VkMappedMemoryRange *pMemoryRanges) { 957 const VkLayerDispatchTable *disp; 958 959 disp = loader_get_dispatch(device); 960 961 return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, 962 pMemoryRanges); 963 } 964 965 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 966 vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, 967 VkDeviceSize *pCommittedMemoryInBytes) { 968 const VkLayerDispatchTable *disp; 969 970 disp = loader_get_dispatch(device); 971 972 disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 973 } 974 975 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 976 vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, 977 VkDeviceSize offset) { 978 const VkLayerDispatchTable *disp; 979 980 disp = loader_get_dispatch(device); 981 982 return disp->BindBufferMemory(device, buffer, mem, offset); 983 } 984 985 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 986 vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, 987 VkDeviceSize offset) { 988 const VkLayerDispatchTable *disp; 989 990 disp = loader_get_dispatch(device); 991 992 return disp->BindImageMemory(device, image, mem, offset); 993 } 994 995 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 996 vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, 997 VkMemoryRequirements *pMemoryRequirements) { 998 const VkLayerDispatchTable *disp; 999 1000 disp = loader_get_dispatch(device); 1001 1002 disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); 1003 } 1004 1005 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1006 vkGetImageMemoryRequirements(VkDevice device, VkImage image, 1007 VkMemoryRequirements *pMemoryRequirements) { 1008 const VkLayerDispatchTable *disp; 1009 1010 disp = loader_get_dispatch(device); 1011 1012 disp->GetImageMemoryRequirements(device, image, pMemoryRequirements); 1013 } 1014 1015 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements( 1016 VkDevice device, VkImage image, uint32_t *pSparseMemoryRequirementCount, 1017 VkSparseImageMemoryRequirements *pSparseMemoryRequirements) { 1018 const VkLayerDispatchTable *disp; 1019 1020 disp = loader_get_dispatch(device); 1021 1022 disp->GetImageSparseMemoryRequirements(device, image, 1023 pSparseMemoryRequirementCount, 1024 pSparseMemoryRequirements); 1025 } 1026 1027 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1028 vkGetPhysicalDeviceSparseImageFormatProperties( 1029 VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, 1030 VkSampleCountFlagBits samples, VkImageUsageFlags usage, 1031 VkImageTiling tiling, uint32_t *pPropertyCount, 1032 VkSparseImageFormatProperties *pProperties) { 1033 const VkLayerInstanceDispatchTable *disp; 1034 VkPhysicalDevice unwrapped_phys_dev = 1035 loader_unwrap_physical_device(physicalDevice); 1036 disp = loader_get_instance_dispatch(physicalDevice); 1037 1038 disp->GetPhysicalDeviceSparseImageFormatProperties( 1039 unwrapped_phys_dev, format, type, samples, usage, tiling, 1040 pPropertyCount, pProperties); 1041 } 1042 1043 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1044 vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, 1045 const VkBindSparseInfo *pBindInfo, VkFence fence) { 1046 const VkLayerDispatchTable *disp; 1047 1048 disp = loader_get_dispatch(queue); 1049 1050 return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); 1051 } 1052 1053 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1054 vkCreateFence(VkDevice device, const VkFenceCreateInfo *pCreateInfo, 1055 const VkAllocationCallbacks *pAllocator, VkFence *pFence) { 1056 const VkLayerDispatchTable *disp; 1057 1058 disp = loader_get_dispatch(device); 1059 1060 return disp->CreateFence(device, pCreateInfo, pAllocator, pFence); 1061 } 1062 1063 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1064 vkDestroyFence(VkDevice device, VkFence fence, 1065 const VkAllocationCallbacks *pAllocator) { 1066 const VkLayerDispatchTable *disp; 1067 1068 disp = loader_get_dispatch(device); 1069 1070 disp->DestroyFence(device, fence, pAllocator); 1071 } 1072 1073 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1074 vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences) { 1075 const VkLayerDispatchTable *disp; 1076 1077 disp = loader_get_dispatch(device); 1078 1079 return disp->ResetFences(device, fenceCount, pFences); 1080 } 1081 1082 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1083 vkGetFenceStatus(VkDevice device, VkFence fence) { 1084 const VkLayerDispatchTable *disp; 1085 1086 disp = loader_get_dispatch(device); 1087 1088 return disp->GetFenceStatus(device, fence); 1089 } 1090 1091 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1092 vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence *pFences, 1093 VkBool32 waitAll, uint64_t timeout) { 1094 const VkLayerDispatchTable *disp; 1095 1096 disp = loader_get_dispatch(device); 1097 1098 return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout); 1099 } 1100 1101 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1102 vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo *pCreateInfo, 1103 const VkAllocationCallbacks *pAllocator, 1104 VkSemaphore *pSemaphore) { 1105 const VkLayerDispatchTable *disp; 1106 1107 disp = loader_get_dispatch(device); 1108 1109 return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); 1110 } 1111 1112 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1113 vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, 1114 const VkAllocationCallbacks *pAllocator) { 1115 const VkLayerDispatchTable *disp; 1116 1117 disp = loader_get_dispatch(device); 1118 1119 disp->DestroySemaphore(device, semaphore, pAllocator); 1120 } 1121 1122 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1123 vkCreateEvent(VkDevice device, const VkEventCreateInfo *pCreateInfo, 1124 const VkAllocationCallbacks *pAllocator, VkEvent *pEvent) { 1125 const VkLayerDispatchTable *disp; 1126 1127 disp = loader_get_dispatch(device); 1128 1129 return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent); 1130 } 1131 1132 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1133 vkDestroyEvent(VkDevice device, VkEvent event, 1134 const VkAllocationCallbacks *pAllocator) { 1135 const VkLayerDispatchTable *disp; 1136 1137 disp = loader_get_dispatch(device); 1138 1139 disp->DestroyEvent(device, event, pAllocator); 1140 } 1141 1142 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1143 vkGetEventStatus(VkDevice device, VkEvent event) { 1144 const VkLayerDispatchTable *disp; 1145 1146 disp = loader_get_dispatch(device); 1147 1148 return disp->GetEventStatus(device, event); 1149 } 1150 1151 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1152 vkSetEvent(VkDevice device, VkEvent event) { 1153 const VkLayerDispatchTable *disp; 1154 1155 disp = loader_get_dispatch(device); 1156 1157 return disp->SetEvent(device, event); 1158 } 1159 1160 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1161 vkResetEvent(VkDevice device, VkEvent event) { 1162 const VkLayerDispatchTable *disp; 1163 1164 disp = loader_get_dispatch(device); 1165 1166 return disp->ResetEvent(device, event); 1167 } 1168 1169 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1170 vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo *pCreateInfo, 1171 const VkAllocationCallbacks *pAllocator, 1172 VkQueryPool *pQueryPool) { 1173 const VkLayerDispatchTable *disp; 1174 1175 disp = loader_get_dispatch(device); 1176 1177 return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 1178 } 1179 1180 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1181 vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, 1182 const VkAllocationCallbacks *pAllocator) { 1183 const VkLayerDispatchTable *disp; 1184 1185 disp = loader_get_dispatch(device); 1186 1187 disp->DestroyQueryPool(device, queryPool, pAllocator); 1188 } 1189 1190 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1191 vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, 1192 uint32_t firstQuery, uint32_t queryCount, size_t dataSize, 1193 void *pData, VkDeviceSize stride, 1194 VkQueryResultFlags flags) { 1195 const VkLayerDispatchTable *disp; 1196 1197 disp = loader_get_dispatch(device); 1198 1199 return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, 1200 dataSize, pData, stride, flags); 1201 } 1202 1203 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1204 vkCreateBuffer(VkDevice device, const VkBufferCreateInfo *pCreateInfo, 1205 const VkAllocationCallbacks *pAllocator, VkBuffer *pBuffer) { 1206 const VkLayerDispatchTable *disp; 1207 1208 disp = loader_get_dispatch(device); 1209 1210 return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); 1211 } 1212 1213 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1214 vkDestroyBuffer(VkDevice device, VkBuffer buffer, 1215 const VkAllocationCallbacks *pAllocator) { 1216 const VkLayerDispatchTable *disp; 1217 1218 disp = loader_get_dispatch(device); 1219 1220 disp->DestroyBuffer(device, buffer, pAllocator); 1221 } 1222 1223 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1224 vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo *pCreateInfo, 1225 const VkAllocationCallbacks *pAllocator, 1226 VkBufferView *pView) { 1227 const VkLayerDispatchTable *disp; 1228 1229 disp = loader_get_dispatch(device); 1230 1231 return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView); 1232 } 1233 1234 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1235 vkDestroyBufferView(VkDevice device, VkBufferView bufferView, 1236 const VkAllocationCallbacks *pAllocator) { 1237 const VkLayerDispatchTable *disp; 1238 1239 disp = loader_get_dispatch(device); 1240 1241 disp->DestroyBufferView(device, bufferView, pAllocator); 1242 } 1243 1244 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1245 vkCreateImage(VkDevice device, const VkImageCreateInfo *pCreateInfo, 1246 const VkAllocationCallbacks *pAllocator, VkImage *pImage) { 1247 const VkLayerDispatchTable *disp; 1248 1249 disp = loader_get_dispatch(device); 1250 1251 return disp->CreateImage(device, pCreateInfo, pAllocator, pImage); 1252 } 1253 1254 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1255 vkDestroyImage(VkDevice device, VkImage image, 1256 const VkAllocationCallbacks *pAllocator) { 1257 const VkLayerDispatchTable *disp; 1258 1259 disp = loader_get_dispatch(device); 1260 1261 disp->DestroyImage(device, image, pAllocator); 1262 } 1263 1264 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1265 vkGetImageSubresourceLayout(VkDevice device, VkImage image, 1266 const VkImageSubresource *pSubresource, 1267 VkSubresourceLayout *pLayout) { 1268 const VkLayerDispatchTable *disp; 1269 1270 disp = loader_get_dispatch(device); 1271 1272 disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout); 1273 } 1274 1275 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1276 vkCreateImageView(VkDevice device, const VkImageViewCreateInfo *pCreateInfo, 1277 const VkAllocationCallbacks *pAllocator, VkImageView *pView) { 1278 const VkLayerDispatchTable *disp; 1279 1280 disp = loader_get_dispatch(device); 1281 1282 return disp->CreateImageView(device, pCreateInfo, pAllocator, pView); 1283 } 1284 1285 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1286 vkDestroyImageView(VkDevice device, VkImageView imageView, 1287 const VkAllocationCallbacks *pAllocator) { 1288 const VkLayerDispatchTable *disp; 1289 1290 disp = loader_get_dispatch(device); 1291 1292 disp->DestroyImageView(device, imageView, pAllocator); 1293 } 1294 1295 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1296 vkCreateShaderModule(VkDevice device, 1297 const VkShaderModuleCreateInfo *pCreateInfo, 1298 const VkAllocationCallbacks *pAllocator, 1299 VkShaderModule *pShader) { 1300 const VkLayerDispatchTable *disp; 1301 1302 disp = loader_get_dispatch(device); 1303 1304 return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader); 1305 } 1306 1307 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1308 vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, 1309 const VkAllocationCallbacks *pAllocator) { 1310 const VkLayerDispatchTable *disp; 1311 1312 disp = loader_get_dispatch(device); 1313 1314 disp->DestroyShaderModule(device, shaderModule, pAllocator); 1315 } 1316 1317 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1318 vkCreatePipelineCache(VkDevice device, 1319 const VkPipelineCacheCreateInfo *pCreateInfo, 1320 const VkAllocationCallbacks *pAllocator, 1321 VkPipelineCache *pPipelineCache) { 1322 const VkLayerDispatchTable *disp; 1323 1324 disp = loader_get_dispatch(device); 1325 1326 return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, 1327 pPipelineCache); 1328 } 1329 1330 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1331 vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, 1332 const VkAllocationCallbacks *pAllocator) { 1333 const VkLayerDispatchTable *disp; 1334 1335 disp = loader_get_dispatch(device); 1336 1337 disp->DestroyPipelineCache(device, pipelineCache, pAllocator); 1338 } 1339 1340 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1341 vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, 1342 size_t *pDataSize, void *pData) { 1343 const VkLayerDispatchTable *disp; 1344 1345 disp = loader_get_dispatch(device); 1346 1347 return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); 1348 } 1349 1350 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1351 vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, 1352 uint32_t srcCacheCount, 1353 const VkPipelineCache *pSrcCaches) { 1354 const VkLayerDispatchTable *disp; 1355 1356 disp = loader_get_dispatch(device); 1357 1358 return disp->MergePipelineCaches(device, dstCache, srcCacheCount, 1359 pSrcCaches); 1360 } 1361 1362 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1363 vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, 1364 uint32_t createInfoCount, 1365 const VkGraphicsPipelineCreateInfo *pCreateInfos, 1366 const VkAllocationCallbacks *pAllocator, 1367 VkPipeline *pPipelines) { 1368 const VkLayerDispatchTable *disp; 1369 1370 disp = loader_get_dispatch(device); 1371 1372 return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, 1373 pCreateInfos, pAllocator, pPipelines); 1374 } 1375 1376 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1377 vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, 1378 uint32_t createInfoCount, 1379 const VkComputePipelineCreateInfo *pCreateInfos, 1380 const VkAllocationCallbacks *pAllocator, 1381 VkPipeline *pPipelines) { 1382 const VkLayerDispatchTable *disp; 1383 1384 disp = loader_get_dispatch(device); 1385 1386 return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, 1387 pCreateInfos, pAllocator, pPipelines); 1388 } 1389 1390 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1391 vkDestroyPipeline(VkDevice device, VkPipeline pipeline, 1392 const VkAllocationCallbacks *pAllocator) { 1393 const VkLayerDispatchTable *disp; 1394 1395 disp = loader_get_dispatch(device); 1396 1397 disp->DestroyPipeline(device, pipeline, pAllocator); 1398 } 1399 1400 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1401 vkCreatePipelineLayout(VkDevice device, 1402 const VkPipelineLayoutCreateInfo *pCreateInfo, 1403 const VkAllocationCallbacks *pAllocator, 1404 VkPipelineLayout *pPipelineLayout) { 1405 const VkLayerDispatchTable *disp; 1406 1407 disp = loader_get_dispatch(device); 1408 1409 return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, 1410 pPipelineLayout); 1411 } 1412 1413 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1414 vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, 1415 const VkAllocationCallbacks *pAllocator) { 1416 const VkLayerDispatchTable *disp; 1417 1418 disp = loader_get_dispatch(device); 1419 1420 disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator); 1421 } 1422 1423 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1424 vkCreateSampler(VkDevice device, const VkSamplerCreateInfo *pCreateInfo, 1425 const VkAllocationCallbacks *pAllocator, VkSampler *pSampler) { 1426 const VkLayerDispatchTable *disp; 1427 1428 disp = loader_get_dispatch(device); 1429 1430 return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler); 1431 } 1432 1433 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1434 vkDestroySampler(VkDevice device, VkSampler sampler, 1435 const VkAllocationCallbacks *pAllocator) { 1436 const VkLayerDispatchTable *disp; 1437 1438 disp = loader_get_dispatch(device); 1439 1440 disp->DestroySampler(device, sampler, pAllocator); 1441 } 1442 1443 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1444 vkCreateDescriptorSetLayout(VkDevice device, 1445 const VkDescriptorSetLayoutCreateInfo *pCreateInfo, 1446 const VkAllocationCallbacks *pAllocator, 1447 VkDescriptorSetLayout *pSetLayout) { 1448 const VkLayerDispatchTable *disp; 1449 1450 disp = loader_get_dispatch(device); 1451 1452 return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, 1453 pSetLayout); 1454 } 1455 1456 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1457 vkDestroyDescriptorSetLayout(VkDevice device, 1458 VkDescriptorSetLayout descriptorSetLayout, 1459 const VkAllocationCallbacks *pAllocator) { 1460 const VkLayerDispatchTable *disp; 1461 1462 disp = loader_get_dispatch(device); 1463 1464 disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); 1465 } 1466 1467 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1468 vkCreateDescriptorPool(VkDevice device, 1469 const VkDescriptorPoolCreateInfo *pCreateInfo, 1470 const VkAllocationCallbacks *pAllocator, 1471 VkDescriptorPool *pDescriptorPool) { 1472 const VkLayerDispatchTable *disp; 1473 1474 disp = loader_get_dispatch(device); 1475 1476 return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, 1477 pDescriptorPool); 1478 } 1479 1480 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1481 vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, 1482 const VkAllocationCallbacks *pAllocator) { 1483 const VkLayerDispatchTable *disp; 1484 1485 disp = loader_get_dispatch(device); 1486 1487 disp->DestroyDescriptorPool(device, descriptorPool, pAllocator); 1488 } 1489 1490 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1491 vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, 1492 VkDescriptorPoolResetFlags flags) { 1493 const VkLayerDispatchTable *disp; 1494 1495 disp = loader_get_dispatch(device); 1496 1497 return disp->ResetDescriptorPool(device, descriptorPool, flags); 1498 } 1499 1500 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1501 vkAllocateDescriptorSets(VkDevice device, 1502 const VkDescriptorSetAllocateInfo *pAllocateInfo, 1503 VkDescriptorSet *pDescriptorSets) { 1504 const VkLayerDispatchTable *disp; 1505 1506 disp = loader_get_dispatch(device); 1507 1508 return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); 1509 } 1510 1511 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1512 vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, 1513 uint32_t descriptorSetCount, 1514 const VkDescriptorSet *pDescriptorSets) { 1515 const VkLayerDispatchTable *disp; 1516 1517 disp = loader_get_dispatch(device); 1518 1519 return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, 1520 pDescriptorSets); 1521 } 1522 1523 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1524 vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, 1525 const VkWriteDescriptorSet *pDescriptorWrites, 1526 uint32_t descriptorCopyCount, 1527 const VkCopyDescriptorSet *pDescriptorCopies) { 1528 const VkLayerDispatchTable *disp; 1529 1530 disp = loader_get_dispatch(device); 1531 1532 disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, 1533 descriptorCopyCount, pDescriptorCopies); 1534 } 1535 1536 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1537 vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo *pCreateInfo, 1538 const VkAllocationCallbacks *pAllocator, 1539 VkFramebuffer *pFramebuffer) { 1540 const VkLayerDispatchTable *disp; 1541 1542 disp = loader_get_dispatch(device); 1543 1544 return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, 1545 pFramebuffer); 1546 } 1547 1548 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1549 vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, 1550 const VkAllocationCallbacks *pAllocator) { 1551 const VkLayerDispatchTable *disp; 1552 1553 disp = loader_get_dispatch(device); 1554 1555 disp->DestroyFramebuffer(device, framebuffer, pAllocator); 1556 } 1557 1558 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1559 vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo *pCreateInfo, 1560 const VkAllocationCallbacks *pAllocator, 1561 VkRenderPass *pRenderPass) { 1562 const VkLayerDispatchTable *disp; 1563 1564 disp = loader_get_dispatch(device); 1565 1566 return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); 1567 } 1568 1569 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1570 vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, 1571 const VkAllocationCallbacks *pAllocator) { 1572 const VkLayerDispatchTable *disp; 1573 1574 disp = loader_get_dispatch(device); 1575 1576 disp->DestroyRenderPass(device, renderPass, pAllocator); 1577 } 1578 1579 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1580 vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, 1581 VkExtent2D *pGranularity) { 1582 const VkLayerDispatchTable *disp; 1583 1584 disp = loader_get_dispatch(device); 1585 1586 disp->GetRenderAreaGranularity(device, renderPass, pGranularity); 1587 } 1588 1589 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1590 vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo *pCreateInfo, 1591 const VkAllocationCallbacks *pAllocator, 1592 VkCommandPool *pCommandPool) { 1593 const VkLayerDispatchTable *disp; 1594 1595 disp = loader_get_dispatch(device); 1596 1597 return disp->CreateCommandPool(device, pCreateInfo, pAllocator, 1598 pCommandPool); 1599 } 1600 1601 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1602 vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, 1603 const VkAllocationCallbacks *pAllocator) { 1604 const VkLayerDispatchTable *disp; 1605 1606 disp = loader_get_dispatch(device); 1607 1608 disp->DestroyCommandPool(device, commandPool, pAllocator); 1609 } 1610 1611 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1612 vkResetCommandPool(VkDevice device, VkCommandPool commandPool, 1613 VkCommandPoolResetFlags flags) { 1614 const VkLayerDispatchTable *disp; 1615 1616 disp = loader_get_dispatch(device); 1617 1618 return disp->ResetCommandPool(device, commandPool, flags); 1619 } 1620 1621 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1622 vkAllocateCommandBuffers(VkDevice device, 1623 const VkCommandBufferAllocateInfo *pAllocateInfo, 1624 VkCommandBuffer *pCommandBuffers) { 1625 const VkLayerDispatchTable *disp; 1626 VkResult res; 1627 1628 disp = loader_get_dispatch(device); 1629 1630 res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); 1631 if (res == VK_SUCCESS) { 1632 for (uint32_t i = 0; i < pAllocateInfo->commandBufferCount; i++) { 1633 if (pCommandBuffers[i]) { 1634 loader_init_dispatch(pCommandBuffers[i], disp); 1635 } 1636 } 1637 } 1638 1639 return res; 1640 } 1641 1642 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1643 vkFreeCommandBuffers(VkDevice device, VkCommandPool commandPool, 1644 uint32_t commandBufferCount, 1645 const VkCommandBuffer *pCommandBuffers) { 1646 const VkLayerDispatchTable *disp; 1647 1648 disp = loader_get_dispatch(device); 1649 1650 disp->FreeCommandBuffers(device, commandPool, commandBufferCount, 1651 pCommandBuffers); 1652 } 1653 1654 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1655 vkBeginCommandBuffer(VkCommandBuffer commandBuffer, 1656 const VkCommandBufferBeginInfo *pBeginInfo) { 1657 const VkLayerDispatchTable *disp; 1658 1659 disp = loader_get_dispatch(commandBuffer); 1660 1661 return disp->BeginCommandBuffer(commandBuffer, pBeginInfo); 1662 } 1663 1664 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1665 vkEndCommandBuffer(VkCommandBuffer commandBuffer) { 1666 const VkLayerDispatchTable *disp; 1667 1668 disp = loader_get_dispatch(commandBuffer); 1669 1670 return disp->EndCommandBuffer(commandBuffer); 1671 } 1672 1673 LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 1674 vkResetCommandBuffer(VkCommandBuffer commandBuffer, 1675 VkCommandBufferResetFlags flags) { 1676 const VkLayerDispatchTable *disp; 1677 1678 disp = loader_get_dispatch(commandBuffer); 1679 1680 return disp->ResetCommandBuffer(commandBuffer, flags); 1681 } 1682 1683 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1684 vkCmdBindPipeline(VkCommandBuffer commandBuffer, 1685 VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) { 1686 const VkLayerDispatchTable *disp; 1687 1688 disp = loader_get_dispatch(commandBuffer); 1689 1690 disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); 1691 } 1692 1693 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1694 vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, 1695 uint32_t viewportCount, const VkViewport *pViewports) { 1696 const VkLayerDispatchTable *disp; 1697 1698 disp = loader_get_dispatch(commandBuffer); 1699 1700 disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount, 1701 pViewports); 1702 } 1703 1704 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1705 vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, 1706 uint32_t scissorCount, const VkRect2D *pScissors) { 1707 const VkLayerDispatchTable *disp; 1708 1709 disp = loader_get_dispatch(commandBuffer); 1710 1711 disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); 1712 } 1713 1714 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1715 vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) { 1716 const VkLayerDispatchTable *disp; 1717 1718 disp = loader_get_dispatch(commandBuffer); 1719 1720 disp->CmdSetLineWidth(commandBuffer, lineWidth); 1721 } 1722 1723 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1724 vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, 1725 float depthBiasClamp, float depthBiasSlopeFactor) { 1726 const VkLayerDispatchTable *disp; 1727 1728 disp = loader_get_dispatch(commandBuffer); 1729 1730 disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, 1731 depthBiasClamp, depthBiasSlopeFactor); 1732 } 1733 1734 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1735 vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, 1736 const float blendConstants[4]) { 1737 const VkLayerDispatchTable *disp; 1738 1739 disp = loader_get_dispatch(commandBuffer); 1740 1741 disp->CmdSetBlendConstants(commandBuffer, blendConstants); 1742 } 1743 1744 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1745 vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, 1746 float maxDepthBounds) { 1747 const VkLayerDispatchTable *disp; 1748 1749 disp = loader_get_dispatch(commandBuffer); 1750 1751 disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); 1752 } 1753 1754 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1755 vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, 1756 VkStencilFaceFlags faceMask, uint32_t compareMask) { 1757 const VkLayerDispatchTable *disp; 1758 1759 disp = loader_get_dispatch(commandBuffer); 1760 1761 disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); 1762 } 1763 1764 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1765 vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, 1766 VkStencilFaceFlags faceMask, uint32_t writeMask) { 1767 const VkLayerDispatchTable *disp; 1768 1769 disp = loader_get_dispatch(commandBuffer); 1770 1771 disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); 1772 } 1773 1774 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1775 vkCmdSetStencilReference(VkCommandBuffer commandBuffer, 1776 VkStencilFaceFlags faceMask, uint32_t reference) { 1777 const VkLayerDispatchTable *disp; 1778 1779 disp = loader_get_dispatch(commandBuffer); 1780 1781 disp->CmdSetStencilReference(commandBuffer, faceMask, reference); 1782 } 1783 1784 LOADER_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) { 1789 const VkLayerDispatchTable *disp; 1790 1791 disp = loader_get_dispatch(commandBuffer); 1792 1793 disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, 1794 firstSet, descriptorSetCount, pDescriptorSets, 1795 dynamicOffsetCount, pDynamicOffsets); 1796 } 1797 1798 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1799 vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, 1800 VkDeviceSize offset, VkIndexType indexType) { 1801 const VkLayerDispatchTable *disp; 1802 1803 disp = loader_get_dispatch(commandBuffer); 1804 1805 disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); 1806 } 1807 1808 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1809 vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, 1810 uint32_t bindingCount, const VkBuffer *pBuffers, 1811 const VkDeviceSize *pOffsets) { 1812 const VkLayerDispatchTable *disp; 1813 1814 disp = loader_get_dispatch(commandBuffer); 1815 1816 disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, 1817 pBuffers, pOffsets); 1818 } 1819 1820 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1821 vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, 1822 uint32_t instanceCount, uint32_t firstVertex, 1823 uint32_t firstInstance) { 1824 const VkLayerDispatchTable *disp; 1825 1826 disp = loader_get_dispatch(commandBuffer); 1827 1828 disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, 1829 firstInstance); 1830 } 1831 1832 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1833 vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, 1834 uint32_t instanceCount, uint32_t firstIndex, 1835 int32_t vertexOffset, uint32_t firstInstance) { 1836 const VkLayerDispatchTable *disp; 1837 1838 disp = loader_get_dispatch(commandBuffer); 1839 1840 disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, 1841 vertexOffset, firstInstance); 1842 } 1843 1844 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1845 vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, 1846 VkDeviceSize offset, uint32_t drawCount, uint32_t stride) { 1847 const VkLayerDispatchTable *disp; 1848 1849 disp = loader_get_dispatch(commandBuffer); 1850 1851 disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); 1852 } 1853 1854 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1855 vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, 1856 VkDeviceSize offset, uint32_t drawCount, 1857 uint32_t stride) { 1858 const VkLayerDispatchTable *disp; 1859 1860 disp = loader_get_dispatch(commandBuffer); 1861 1862 disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, 1863 stride); 1864 } 1865 1866 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1867 vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, 1868 uint32_t z) { 1869 const VkLayerDispatchTable *disp; 1870 1871 disp = loader_get_dispatch(commandBuffer); 1872 1873 disp->CmdDispatch(commandBuffer, x, y, z); 1874 } 1875 1876 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1877 vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, 1878 VkDeviceSize offset) { 1879 const VkLayerDispatchTable *disp; 1880 1881 disp = loader_get_dispatch(commandBuffer); 1882 1883 disp->CmdDispatchIndirect(commandBuffer, buffer, offset); 1884 } 1885 1886 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1887 vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, 1888 VkBuffer dstBuffer, uint32_t regionCount, 1889 const VkBufferCopy *pRegions) { 1890 const VkLayerDispatchTable *disp; 1891 1892 disp = loader_get_dispatch(commandBuffer); 1893 1894 disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, 1895 pRegions); 1896 } 1897 1898 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1899 vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, 1900 VkImageLayout srcImageLayout, VkImage dstImage, 1901 VkImageLayout dstImageLayout, uint32_t regionCount, 1902 const VkImageCopy *pRegions) { 1903 const VkLayerDispatchTable *disp; 1904 1905 disp = loader_get_dispatch(commandBuffer); 1906 1907 disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, 1908 dstImageLayout, regionCount, pRegions); 1909 } 1910 1911 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1912 vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, 1913 VkImageLayout srcImageLayout, VkImage dstImage, 1914 VkImageLayout dstImageLayout, uint32_t regionCount, 1915 const VkImageBlit *pRegions, VkFilter filter) { 1916 const VkLayerDispatchTable *disp; 1917 1918 disp = loader_get_dispatch(commandBuffer); 1919 1920 disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, 1921 dstImageLayout, regionCount, pRegions, filter); 1922 } 1923 1924 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1925 vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, 1926 VkImage dstImage, VkImageLayout dstImageLayout, 1927 uint32_t regionCount, 1928 const VkBufferImageCopy *pRegions) { 1929 const VkLayerDispatchTable *disp; 1930 1931 disp = loader_get_dispatch(commandBuffer); 1932 1933 disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, 1934 dstImageLayout, regionCount, pRegions); 1935 } 1936 1937 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1938 vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, 1939 VkImageLayout srcImageLayout, VkBuffer dstBuffer, 1940 uint32_t regionCount, 1941 const VkBufferImageCopy *pRegions) { 1942 const VkLayerDispatchTable *disp; 1943 1944 disp = loader_get_dispatch(commandBuffer); 1945 1946 disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, 1947 dstBuffer, regionCount, pRegions); 1948 } 1949 1950 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1951 vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, 1952 VkDeviceSize dstOffset, VkDeviceSize dataSize, 1953 const uint32_t *pData) { 1954 const VkLayerDispatchTable *disp; 1955 1956 disp = loader_get_dispatch(commandBuffer); 1957 1958 disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); 1959 } 1960 1961 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1962 vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, 1963 VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) { 1964 const VkLayerDispatchTable *disp; 1965 1966 disp = loader_get_dispatch(commandBuffer); 1967 1968 disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); 1969 } 1970 1971 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1972 vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, 1973 VkImageLayout imageLayout, const VkClearColorValue *pColor, 1974 uint32_t rangeCount, 1975 const VkImageSubresourceRange *pRanges) { 1976 const VkLayerDispatchTable *disp; 1977 1978 disp = loader_get_dispatch(commandBuffer); 1979 1980 disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, 1981 rangeCount, pRanges); 1982 } 1983 1984 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1985 vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, 1986 VkImageLayout imageLayout, 1987 const VkClearDepthStencilValue *pDepthStencil, 1988 uint32_t rangeCount, 1989 const VkImageSubresourceRange *pRanges) { 1990 const VkLayerDispatchTable *disp; 1991 1992 disp = loader_get_dispatch(commandBuffer); 1993 1994 disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, 1995 pDepthStencil, rangeCount, pRanges); 1996 } 1997 1998 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 1999 vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, 2000 const VkClearAttachment *pAttachments, uint32_t rectCount, 2001 const VkClearRect *pRects) { 2002 const VkLayerDispatchTable *disp; 2003 2004 disp = loader_get_dispatch(commandBuffer); 2005 2006 disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, 2007 rectCount, pRects); 2008 } 2009 2010 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2011 vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, 2012 VkImageLayout srcImageLayout, VkImage dstImage, 2013 VkImageLayout dstImageLayout, uint32_t regionCount, 2014 const VkImageResolve *pRegions) { 2015 const VkLayerDispatchTable *disp; 2016 2017 disp = loader_get_dispatch(commandBuffer); 2018 2019 disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, 2020 dstImageLayout, regionCount, pRegions); 2021 } 2022 2023 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2024 vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, 2025 VkPipelineStageFlags stageMask) { 2026 const VkLayerDispatchTable *disp; 2027 2028 disp = loader_get_dispatch(commandBuffer); 2029 2030 disp->CmdSetEvent(commandBuffer, event, stageMask); 2031 } 2032 2033 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2034 vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, 2035 VkPipelineStageFlags stageMask) { 2036 const VkLayerDispatchTable *disp; 2037 2038 disp = loader_get_dispatch(commandBuffer); 2039 2040 disp->CmdResetEvent(commandBuffer, event, stageMask); 2041 } 2042 2043 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2044 vkCmdWaitEvents(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) { 2052 const VkLayerDispatchTable *disp; 2053 2054 disp = loader_get_dispatch(commandBuffer); 2055 2056 disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, 2057 dstStageMask, memoryBarrierCount, pMemoryBarriers, 2058 bufferMemoryBarrierCount, pBufferMemoryBarriers, 2059 imageMemoryBarrierCount, pImageMemoryBarriers); 2060 } 2061 2062 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier( 2063 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) { 2070 const VkLayerDispatchTable *disp; 2071 2072 disp = loader_get_dispatch(commandBuffer); 2073 2074 disp->CmdPipelineBarrier( 2075 commandBuffer, srcStageMask, dstStageMask, dependencyFlags, 2076 memoryBarrierCount, pMemoryBarriers, bufferMemoryBarrierCount, 2077 pBufferMemoryBarriers, imageMemoryBarrierCount, pImageMemoryBarriers); 2078 } 2079 2080 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2081 vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, 2082 uint32_t slot, VkFlags flags) { 2083 const VkLayerDispatchTable *disp; 2084 2085 disp = loader_get_dispatch(commandBuffer); 2086 2087 disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags); 2088 } 2089 2090 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2091 vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, 2092 uint32_t slot) { 2093 const VkLayerDispatchTable *disp; 2094 2095 disp = loader_get_dispatch(commandBuffer); 2096 2097 disp->CmdEndQuery(commandBuffer, queryPool, slot); 2098 } 2099 2100 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2101 vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, 2102 uint32_t firstQuery, uint32_t queryCount) { 2103 const VkLayerDispatchTable *disp; 2104 2105 disp = loader_get_dispatch(commandBuffer); 2106 2107 disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); 2108 } 2109 2110 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2111 vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, 2112 VkPipelineStageFlagBits pipelineStage, 2113 VkQueryPool queryPool, uint32_t slot) { 2114 const VkLayerDispatchTable *disp; 2115 2116 disp = loader_get_dispatch(commandBuffer); 2117 2118 disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot); 2119 } 2120 2121 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2122 vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, 2123 uint32_t firstQuery, uint32_t queryCount, 2124 VkBuffer dstBuffer, VkDeviceSize dstOffset, 2125 VkDeviceSize stride, VkFlags flags) { 2126 const VkLayerDispatchTable *disp; 2127 2128 disp = loader_get_dispatch(commandBuffer); 2129 2130 disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, 2131 queryCount, dstBuffer, dstOffset, stride, 2132 flags); 2133 } 2134 2135 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2136 vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, 2137 VkShaderStageFlags stageFlags, uint32_t offset, 2138 uint32_t size, const void *pValues) { 2139 const VkLayerDispatchTable *disp; 2140 2141 disp = loader_get_dispatch(commandBuffer); 2142 2143 disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, 2144 pValues); 2145 } 2146 2147 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2148 vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, 2149 const VkRenderPassBeginInfo *pRenderPassBegin, 2150 VkSubpassContents contents) { 2151 const VkLayerDispatchTable *disp; 2152 2153 disp = loader_get_dispatch(commandBuffer); 2154 2155 disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); 2156 } 2157 2158 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2159 vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) { 2160 const VkLayerDispatchTable *disp; 2161 2162 disp = loader_get_dispatch(commandBuffer); 2163 2164 disp->CmdNextSubpass(commandBuffer, contents); 2165 } 2166 2167 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2168 vkCmdEndRenderPass(VkCommandBuffer commandBuffer) { 2169 const VkLayerDispatchTable *disp; 2170 2171 disp = loader_get_dispatch(commandBuffer); 2172 2173 disp->CmdEndRenderPass(commandBuffer); 2174 } 2175 2176 LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 2177 vkCmdExecuteCommands(VkCommandBuffer commandBuffer, 2178 uint32_t commandBuffersCount, 2179 const VkCommandBuffer *pCommandBuffers) { 2180 const VkLayerDispatchTable *disp; 2181 2182 disp = loader_get_dispatch(commandBuffer); 2183 2184 disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, 2185 pCommandBuffers); 2186 } 2187
