trampoline.c revision ebbb96d9efd5db51afa9b392c3026a4834c978e7
1/* 2 * 3 * Copyright (C) 2015 Valve Corporation 4 * Copyright (C) 2015 Google Inc. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included 14 * in all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 * 24 * Author: Chris Forbes <chrisf@ijw.co.nz> 25 * Author: Cody Northrop <cody@lunarg.com> 26 * Author: Jon Ashburn <jon@lunarg.com> 27 * Author: Tony Barbour <tony@LunarG.com> 28 */ 29#define _GNU_SOURCE 30#include <stdlib.h> 31#include <string.h> 32 33#include "vk_loader_platform.h" 34#include "loader.h" 35#include "debug_report.h" 36#include "wsi.h" 37 38 39/* Trampoline entrypoints */ 40LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( 41 const VkInstanceCreateInfo* pCreateInfo, 42 const VkAllocationCallbacks* pAllocator, 43 VkInstance* pInstance) 44{ 45 struct loader_instance *ptr_instance = NULL; 46 VkResult res = VK_ERROR_INITIALIZATION_FAILED; 47 48 loader_platform_thread_once(&once_init, loader_initialize); 49 50 if (pAllocator) { 51 ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation( 52 pAllocator->pUserData, 53 sizeof(struct loader_instance), 54 sizeof(VkInstance), 55 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); 56 } else { 57 ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance)); 58 } 59 if (ptr_instance == NULL) { 60 return VK_ERROR_OUT_OF_HOST_MEMORY; 61 } 62 63 tls_instance = ptr_instance; 64 loader_platform_thread_lock_mutex(&loader_lock); 65 memset(ptr_instance, 0, sizeof(struct loader_instance)); 66 67 if (pAllocator) { 68 ptr_instance->alloc_callbacks = *pAllocator; 69 } 70 71 /* Due to implicit layers need to get layer list even if 72 * enabledLayerNameCount == 0 and VK_INSTANCE_LAYERS is unset. For now always 73 * get layer list (both instance and device) via loader_layer_scan(). */ 74 memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list)); 75 memset(&ptr_instance->device_layer_list, 0, sizeof(ptr_instance->device_layer_list)); 76 loader_layer_scan(ptr_instance, 77 &ptr_instance->instance_layer_list, 78 &ptr_instance->device_layer_list); 79 80 /* validate the app requested layers to be enabled */ 81 if (pCreateInfo->enabledLayerNameCount > 0) { 82 res = loader_validate_layers(pCreateInfo->enabledLayerNameCount, 83 pCreateInfo->ppEnabledLayerNames, 84 &ptr_instance->instance_layer_list); 85 if (res != VK_SUCCESS) { 86 loader_platform_thread_unlock_mutex(&loader_lock); 87 return res; 88 } 89 } 90 91 /* Scan/discover all ICD libraries */ 92 memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs)); 93 loader_icd_scan(ptr_instance, &ptr_instance->icd_libs); 94 95 /* get extensions from all ICD's, merge so no duplicates, then validate */ 96 loader_get_icd_loader_instance_extensions(ptr_instance, 97 &ptr_instance->icd_libs, 98 &ptr_instance->ext_list); 99 res = loader_validate_instance_extensions(&ptr_instance->ext_list, 100 &ptr_instance->instance_layer_list, 101 pCreateInfo); 102 if (res != VK_SUCCESS) { 103 loader_delete_layer_properties(ptr_instance, 104 &ptr_instance->device_layer_list); 105 loader_delete_layer_properties(ptr_instance, 106 &ptr_instance->instance_layer_list); 107 loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs); 108 loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *) 109 &ptr_instance->ext_list); 110 loader_platform_thread_unlock_mutex(&loader_lock); 111 loader_heap_free(ptr_instance, ptr_instance); 112 return res; 113 } 114 115 ptr_instance->disp = loader_heap_alloc( 116 ptr_instance, 117 sizeof(VkLayerInstanceDispatchTable), 118 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); 119 if (ptr_instance->disp == NULL) { 120 loader_delete_layer_properties(ptr_instance, 121 &ptr_instance->device_layer_list); 122 loader_delete_layer_properties(ptr_instance, 123 &ptr_instance->instance_layer_list); 124 loader_scanned_icd_clear(ptr_instance, 125 &ptr_instance->icd_libs); 126 loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *) 127 &ptr_instance->ext_list); 128 loader_platform_thread_unlock_mutex(&loader_lock); 129 loader_heap_free(ptr_instance, ptr_instance); 130 return VK_ERROR_OUT_OF_HOST_MEMORY; 131 } 132 memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp)); 133 ptr_instance->next = loader.instances; 134 loader.instances = ptr_instance; 135 136 /* activate any layers on instance chain */ 137 res = loader_enable_instance_layers(ptr_instance, 138 pCreateInfo, 139 &ptr_instance->instance_layer_list); 140 if (res != VK_SUCCESS) { 141 loader_delete_layer_properties(ptr_instance, 142 &ptr_instance->device_layer_list); 143 loader_delete_layer_properties(ptr_instance, 144 &ptr_instance->instance_layer_list); 145 loader_scanned_icd_clear(ptr_instance, 146 &ptr_instance->icd_libs); 147 loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *) 148 &ptr_instance->ext_list); 149 loader.instances = ptr_instance->next; 150 loader_platform_thread_unlock_mutex(&loader_lock); 151 loader_heap_free(ptr_instance, ptr_instance->disp); 152 loader_heap_free(ptr_instance, ptr_instance); 153 return res; 154 } 155 loader_activate_instance_layers(ptr_instance); 156 157 wsi_create_instance(ptr_instance, pCreateInfo); 158 debug_report_create_instance(ptr_instance, pCreateInfo); 159 160 161 *pInstance = (VkInstance) ptr_instance; 162 163 res = ptr_instance->disp->CreateInstance(pCreateInfo, pAllocator, pInstance); 164 165 /* 166 * Finally have the layers in place and everyone has seen 167 * the CreateInstance command go by. This allows the layer's 168 * GetInstanceProcAddr functions to return valid extension functions 169 * if enabled. 170 */ 171 loader_activate_instance_layer_extensions(ptr_instance); 172 173 loader_platform_thread_unlock_mutex(&loader_lock); 174 return res; 175} 176 177LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( 178 VkInstance instance, 179 const VkAllocationCallbacks* pAllocator) 180{ 181 const VkLayerInstanceDispatchTable *disp; 182 struct loader_instance *ptr_instance = NULL; 183 disp = loader_get_instance_dispatch(instance); 184 185 loader_platform_thread_lock_mutex(&loader_lock); 186 187 ptr_instance = loader_get_instance(instance); 188 disp->DestroyInstance(instance, pAllocator); 189 190 loader_deactivate_instance_layers(ptr_instance); 191 loader_heap_free(ptr_instance, ptr_instance->disp); 192 loader_heap_free(ptr_instance, ptr_instance); 193 loader_platform_thread_unlock_mutex(&loader_lock); 194} 195 196LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( 197 VkInstance instance, 198 uint32_t* pPhysicalDeviceCount, 199 VkPhysicalDevice* pPhysicalDevices) 200{ 201 const VkLayerInstanceDispatchTable *disp; 202 VkResult res; 203 disp = loader_get_instance_dispatch(instance); 204 205 loader_platform_thread_lock_mutex(&loader_lock); 206 res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, 207 pPhysicalDevices); 208 loader_platform_thread_unlock_mutex(&loader_lock); 209 return res; 210} 211 212LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( 213 VkPhysicalDevice gpu, 214 VkPhysicalDeviceFeatures *pFeatures) 215{ 216 const VkLayerInstanceDispatchTable *disp; 217 218 disp = loader_get_instance_dispatch(gpu); 219 disp->GetPhysicalDeviceFeatures(gpu, pFeatures); 220} 221 222LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( 223 VkPhysicalDevice gpu, 224 VkFormat format, 225 VkFormatProperties *pFormatInfo) 226{ 227 const VkLayerInstanceDispatchTable *disp; 228 229 disp = loader_get_instance_dispatch(gpu); 230 disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo); 231} 232 233LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) 234{ 235 const VkLayerInstanceDispatchTable *disp; 236 237 disp = loader_get_instance_dispatch(physicalDevice); 238 return disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); 239} 240 241LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( 242 VkPhysicalDevice gpu, 243 VkPhysicalDeviceProperties* pProperties) 244{ 245 const VkLayerInstanceDispatchTable *disp; 246 247 disp = loader_get_instance_dispatch(gpu); 248 disp->GetPhysicalDeviceProperties(gpu, pProperties); 249} 250 251LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( 252 VkPhysicalDevice gpu, 253 uint32_t* pQueueFamilyPropertyCount, 254 VkQueueFamilyProperties* pQueueProperties) 255{ 256 const VkLayerInstanceDispatchTable *disp; 257 258 disp = loader_get_instance_dispatch(gpu); 259 disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pQueueFamilyPropertyCount, pQueueProperties); 260} 261 262LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( 263 VkPhysicalDevice gpu, 264 VkPhysicalDeviceMemoryProperties* pMemoryProperties) 265{ 266 const VkLayerInstanceDispatchTable *disp; 267 268 disp = loader_get_instance_dispatch(gpu); 269 disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties); 270} 271 272LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( 273 VkPhysicalDevice gpu, 274 const VkDeviceCreateInfo* pCreateInfo, 275 const VkAllocationCallbacks* pAllocator, 276 VkDevice* pDevice) 277{ 278 VkResult res; 279 280 loader_platform_thread_lock_mutex(&loader_lock); 281 282 res = loader_CreateDevice(gpu, pCreateInfo, pAllocator, pDevice); 283 284 loader_platform_thread_unlock_mutex(&loader_lock); 285 return res; 286} 287 288LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) 289{ 290 const VkLayerDispatchTable *disp; 291 struct loader_device *dev; 292 struct loader_icd *icd = loader_get_icd_and_device(device, &dev); 293 const struct loader_instance *inst = icd->this_instance; 294 disp = loader_get_dispatch(device); 295 296 loader_platform_thread_lock_mutex(&loader_lock); 297 disp->DestroyDevice(device, pAllocator); 298 dev->device = NULL; 299 loader_remove_logical_device(inst, icd, dev); 300 301 loader_platform_thread_unlock_mutex(&loader_lock); 302} 303 304LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( 305 VkPhysicalDevice physicalDevice, 306 const char* pLayerName, 307 uint32_t* pPropertyCount, 308 VkExtensionProperties* pProperties) 309{ 310 VkResult res; 311 312 loader_platform_thread_lock_mutex(&loader_lock); 313 314 /* If pLayerName == NULL, then querying ICD extensions, pass this call 315 down the instance chain which will terminate in the ICD. This allows 316 layers to filter the extensions coming back up the chain. 317 If pLayerName != NULL then get layer extensions from manifest file. */ 318 if (pLayerName == NULL || strlen(pLayerName) == 0) { 319 const VkLayerInstanceDispatchTable *disp; 320 321 disp = loader_get_instance_dispatch(physicalDevice); 322 res = disp->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pPropertyCount, pProperties); 323 } else { 324 res = loader_EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); 325 } 326 327 loader_platform_thread_unlock_mutex(&loader_lock); 328 return res; 329} 330 331LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( 332 VkPhysicalDevice physicalDevice, 333 uint32_t* pPropertyCount, 334 VkLayerProperties* pProperties) 335{ 336 VkResult res; 337 338 loader_platform_thread_lock_mutex(&loader_lock); 339 340 /* Don't dispatch this call down the instance chain, want all device layers 341 enumerated and instance chain may not contain all device layers */ 342 res = loader_EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); 343 loader_platform_thread_unlock_mutex(&loader_lock); 344 return res; 345} 346 347LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) 348{ 349 const VkLayerDispatchTable *disp; 350 351 disp = loader_get_dispatch(device); 352 353 disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); 354 loader_set_dispatch(*pQueue, disp); 355} 356 357LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) 358{ 359 const VkLayerDispatchTable *disp; 360 361 disp = loader_get_dispatch(queue); 362 363 return disp->QueueSubmit(queue, submitCount, pSubmits, fence); 364} 365 366LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) 367{ 368 const VkLayerDispatchTable *disp; 369 370 disp = loader_get_dispatch(queue); 371 372 return disp->QueueWaitIdle(queue); 373} 374 375LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) 376{ 377 const VkLayerDispatchTable *disp; 378 379 disp = loader_get_dispatch(device); 380 381 return disp->DeviceWaitIdle(device); 382} 383 384LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) 385{ 386 const VkLayerDispatchTable *disp; 387 388 disp = loader_get_dispatch(device); 389 390 return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); 391} 392 393LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* pAllocator) 394{ 395 const VkLayerDispatchTable *disp; 396 397 disp = loader_get_dispatch(device); 398 399 disp->FreeMemory(device, mem, pAllocator); 400} 401 402LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) 403{ 404 const VkLayerDispatchTable *disp; 405 406 disp = loader_get_dispatch(device); 407 408 return disp->MapMemory(device, mem, offset, size, flags, ppData); 409} 410 411LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem) 412{ 413 const VkLayerDispatchTable *disp; 414 415 disp = loader_get_dispatch(device); 416 417 disp->UnmapMemory(device, mem); 418} 419 420LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) 421{ 422 const VkLayerDispatchTable *disp; 423 424 disp = loader_get_dispatch(device); 425 426 return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 427} 428 429LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) 430{ 431 const VkLayerDispatchTable *disp; 432 433 disp = loader_get_dispatch(device); 434 435 return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 436} 437 438LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) 439{ 440 const VkLayerDispatchTable *disp; 441 442 disp = loader_get_dispatch(device); 443 444 disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 445} 446 447LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset) 448{ 449 const VkLayerDispatchTable *disp; 450 451 disp = loader_get_dispatch(device); 452 453 return disp->BindBufferMemory(device, buffer, mem, offset); 454} 455 456LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize offset) 457{ 458 const VkLayerDispatchTable *disp; 459 460 disp = loader_get_dispatch(device); 461 462 return disp->BindImageMemory(device, image, mem, offset); 463} 464 465LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) 466{ 467 const VkLayerDispatchTable *disp; 468 469 disp = loader_get_dispatch(device); 470 471 disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); 472} 473 474LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 475{ 476 const VkLayerDispatchTable *disp; 477 478 disp = loader_get_dispatch(device); 479 480 disp->GetImageMemoryRequirements(device, image, pMemoryRequirements); 481} 482 483LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 484{ 485 const VkLayerDispatchTable *disp; 486 487 disp = loader_get_dispatch(device); 488 489 disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 490} 491 492LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) 493{ 494 const VkLayerInstanceDispatchTable *disp; 495 496 disp = loader_get_instance_dispatch(physicalDevice); 497 498 disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); 499} 500 501LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) 502{ 503 const VkLayerDispatchTable *disp; 504 505 disp = loader_get_dispatch(queue); 506 507 return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); 508} 509 510LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) 511{ 512 const VkLayerDispatchTable *disp; 513 514 disp = loader_get_dispatch(device); 515 516 return disp->CreateFence(device, pCreateInfo, pAllocator, pFence); 517} 518 519LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) 520{ 521 const VkLayerDispatchTable *disp; 522 523 disp = loader_get_dispatch(device); 524 525 disp->DestroyFence(device, fence, pAllocator); 526} 527 528LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) 529{ 530 const VkLayerDispatchTable *disp; 531 532 disp = loader_get_dispatch(device); 533 534 return disp->ResetFences(device, fenceCount, pFences); 535} 536 537LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) 538{ 539 const VkLayerDispatchTable *disp; 540 541 disp = loader_get_dispatch(device); 542 543 return disp->GetFenceStatus(device, fence); 544} 545 546LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) 547{ 548 const VkLayerDispatchTable *disp; 549 550 disp = loader_get_dispatch(device); 551 552 return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout); 553} 554 555LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) 556{ 557 const VkLayerDispatchTable *disp; 558 559 disp = loader_get_dispatch(device); 560 561 return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); 562} 563 564LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) 565{ 566 const VkLayerDispatchTable *disp; 567 568 disp = loader_get_dispatch(device); 569 570 disp->DestroySemaphore(device, semaphore, pAllocator); 571} 572 573LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) 574{ 575 const VkLayerDispatchTable *disp; 576 577 disp = loader_get_dispatch(device); 578 579 return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent); 580} 581 582LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) 583{ 584 const VkLayerDispatchTable *disp; 585 586 disp = loader_get_dispatch(device); 587 588 disp->DestroyEvent(device, event, pAllocator); 589} 590 591LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) 592{ 593 const VkLayerDispatchTable *disp; 594 595 disp = loader_get_dispatch(device); 596 597 return disp->GetEventStatus(device, event); 598} 599 600LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) 601{ 602 const VkLayerDispatchTable *disp; 603 604 disp = loader_get_dispatch(device); 605 606 return disp->SetEvent(device, event); 607} 608 609LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) 610{ 611 const VkLayerDispatchTable *disp; 612 613 disp = loader_get_dispatch(device); 614 615 return disp->ResetEvent(device, event); 616} 617 618LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) 619{ 620 const VkLayerDispatchTable *disp; 621 622 disp = loader_get_dispatch(device); 623 624 return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 625} 626 627LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) 628{ 629 const VkLayerDispatchTable *disp; 630 631 disp = loader_get_dispatch(device); 632 633 disp->DestroyQueryPool(device, queryPool, pAllocator); 634} 635 636LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) 637{ 638 const VkLayerDispatchTable *disp; 639 640 disp = loader_get_dispatch(device); 641 642 return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags); 643} 644 645LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) 646{ 647 const VkLayerDispatchTable *disp; 648 649 disp = loader_get_dispatch(device); 650 651 return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); 652} 653 654LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) 655{ 656 const VkLayerDispatchTable *disp; 657 658 disp = loader_get_dispatch(device); 659 660 disp->DestroyBuffer(device, buffer, pAllocator); 661} 662 663LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) 664{ 665 const VkLayerDispatchTable *disp; 666 667 disp = loader_get_dispatch(device); 668 669 return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView); 670} 671 672LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) 673{ 674 const VkLayerDispatchTable *disp; 675 676 disp = loader_get_dispatch(device); 677 678 disp->DestroyBufferView(device, bufferView, pAllocator); 679} 680 681LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 682{ 683 const VkLayerDispatchTable *disp; 684 685 disp = loader_get_dispatch(device); 686 687 return disp->CreateImage(device, pCreateInfo, pAllocator, pImage); 688} 689 690LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 691{ 692 const VkLayerDispatchTable *disp; 693 694 disp = loader_get_dispatch(device); 695 696 disp->DestroyImage(device, image, pAllocator); 697} 698 699LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 700{ 701 const VkLayerDispatchTable *disp; 702 703 disp = loader_get_dispatch(device); 704 705 disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout); 706} 707 708LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) 709{ 710 const VkLayerDispatchTable *disp; 711 712 disp = loader_get_dispatch(device); 713 714 return disp->CreateImageView(device, pCreateInfo, pAllocator, pView); 715} 716 717LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) 718{ 719 const VkLayerDispatchTable *disp; 720 721 disp = loader_get_dispatch(device); 722 723 disp->DestroyImageView(device, imageView, pAllocator); 724} 725 726LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShader) 727{ 728 const VkLayerDispatchTable *disp; 729 730 disp = loader_get_dispatch(device); 731 732 return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader); 733} 734 735LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) 736{ 737 const VkLayerDispatchTable *disp; 738 739 disp = loader_get_dispatch(device); 740 741 disp->DestroyShaderModule(device, shaderModule, pAllocator); 742} 743 744LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) 745{ 746 const VkLayerDispatchTable *disp; 747 748 disp = loader_get_dispatch(device); 749 750 return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); 751} 752 753LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) 754{ 755 const VkLayerDispatchTable *disp; 756 757 disp = loader_get_dispatch(device); 758 759 disp->DestroyPipelineCache(device, pipelineCache, pAllocator); 760} 761 762LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) 763{ 764 const VkLayerDispatchTable *disp; 765 766 disp = loader_get_dispatch(device); 767 768 return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); 769} 770 771LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) 772{ 773 const VkLayerDispatchTable *disp; 774 775 disp = loader_get_dispatch(device); 776 777 return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); 778} 779 780LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) 781{ 782 const VkLayerDispatchTable *disp; 783 784 disp = loader_get_dispatch(device); 785 786 return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 787} 788 789LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) 790{ 791 const VkLayerDispatchTable *disp; 792 793 disp = loader_get_dispatch(device); 794 795 return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); 796} 797 798LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) 799{ 800 const VkLayerDispatchTable *disp; 801 802 disp = loader_get_dispatch(device); 803 804 disp->DestroyPipeline(device, pipeline, pAllocator); 805} 806 807LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) 808{ 809 const VkLayerDispatchTable *disp; 810 811 disp = loader_get_dispatch(device); 812 813 return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); 814} 815 816LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) 817{ 818 const VkLayerDispatchTable *disp; 819 820 disp = loader_get_dispatch(device); 821 822 disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator); 823} 824 825LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) 826{ 827 const VkLayerDispatchTable *disp; 828 829 disp = loader_get_dispatch(device); 830 831 return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler); 832} 833 834LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) 835{ 836 const VkLayerDispatchTable *disp; 837 838 disp = loader_get_dispatch(device); 839 840 disp->DestroySampler(device, sampler, pAllocator); 841} 842 843 844LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) 845{ 846 const VkLayerDispatchTable *disp; 847 848 disp = loader_get_dispatch(device); 849 850 return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); 851} 852 853LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) 854{ 855 const VkLayerDispatchTable *disp; 856 857 disp = loader_get_dispatch(device); 858 859 disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); 860} 861 862LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) 863{ 864 const VkLayerDispatchTable *disp; 865 866 disp = loader_get_dispatch(device); 867 868 return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); 869} 870 871LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) 872{ 873 const VkLayerDispatchTable *disp; 874 875 disp = loader_get_dispatch(device); 876 877 disp->DestroyDescriptorPool(device, descriptorPool, pAllocator); 878} 879 880 881LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) 882{ 883 const VkLayerDispatchTable *disp; 884 885 disp = loader_get_dispatch(device); 886 887 return disp->ResetDescriptorPool(device, descriptorPool, flags); 888} 889 890LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) 891{ 892 const VkLayerDispatchTable *disp; 893 894 disp = loader_get_dispatch(device); 895 896 return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); 897} 898 899LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) 900{ 901 const VkLayerDispatchTable *disp; 902 903 disp = loader_get_dispatch(device); 904 905 return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); 906} 907 908LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) 909{ 910 const VkLayerDispatchTable *disp; 911 912 disp = loader_get_dispatch(device); 913 914 disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); 915} 916 917LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) 918{ 919 const VkLayerDispatchTable *disp; 920 921 disp = loader_get_dispatch(device); 922 923 return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); 924} 925 926LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) 927{ 928 const VkLayerDispatchTable *disp; 929 930 disp = loader_get_dispatch(device); 931 932 disp->DestroyFramebuffer(device, framebuffer, pAllocator); 933} 934 935LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) 936{ 937 const VkLayerDispatchTable *disp; 938 939 disp = loader_get_dispatch(device); 940 941 return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); 942} 943 944LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) 945{ 946 const VkLayerDispatchTable *disp; 947 948 disp = loader_get_dispatch(device); 949 950 disp->DestroyRenderPass(device, renderPass, pAllocator); 951} 952 953LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) 954{ 955 const VkLayerDispatchTable *disp; 956 957 disp = loader_get_dispatch(device); 958 959 disp->GetRenderAreaGranularity(device, renderPass, pGranularity); 960} 961 962LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) 963{ 964 const VkLayerDispatchTable *disp; 965 966 disp = loader_get_dispatch(device); 967 968 return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); 969} 970 971LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) 972{ 973 const VkLayerDispatchTable *disp; 974 975 disp = loader_get_dispatch(device); 976 977 disp->DestroyCommandPool(device, commandPool, pAllocator); 978} 979 980LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) 981{ 982 const VkLayerDispatchTable *disp; 983 984 disp = loader_get_dispatch(device); 985 986 return disp->ResetCommandPool(device, commandPool, flags); 987} 988 989LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( 990 VkDevice device, 991 const VkCommandBufferAllocateInfo* pAllocateInfo, 992 VkCommandBuffer* pCommandBuffers) 993{ 994 const VkLayerDispatchTable *disp; 995 VkResult res; 996 997 disp = loader_get_dispatch(device); 998 999 res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); 1000 if (res == VK_SUCCESS) { 1001 for (uint32_t i =0; i < pAllocateInfo->bufferCount; i++) { 1002 if (pCommandBuffers[i]) { 1003 loader_init_dispatch(pCommandBuffers[i], disp); 1004 } 1005 } 1006 } 1007 1008 return res; 1009} 1010 1011LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( 1012 VkDevice device, 1013 VkCommandPool commandPool, 1014 uint32_t commandBufferCount, 1015 const VkCommandBuffer* pCommandBuffers) 1016{ 1017 const VkLayerDispatchTable *disp; 1018 1019 disp = loader_get_dispatch(device); 1020 1021 disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); 1022} 1023 1024LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) 1025{ 1026 const VkLayerDispatchTable *disp; 1027 1028 disp = loader_get_dispatch(commandBuffer); 1029 1030 return disp->BeginCommandBuffer(commandBuffer, pBeginInfo); 1031} 1032 1033LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) 1034{ 1035 const VkLayerDispatchTable *disp; 1036 1037 disp = loader_get_dispatch(commandBuffer); 1038 1039 return disp->EndCommandBuffer(commandBuffer); 1040} 1041 1042LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) 1043{ 1044 const VkLayerDispatchTable *disp; 1045 1046 disp = loader_get_dispatch(commandBuffer); 1047 1048 return disp->ResetCommandBuffer(commandBuffer, flags); 1049} 1050 1051LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) 1052{ 1053 const VkLayerDispatchTable *disp; 1054 1055 disp = loader_get_dispatch(commandBuffer); 1056 1057 disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); 1058} 1059 1060LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t viewportCount, const VkViewport* pViewports) 1061{ 1062 const VkLayerDispatchTable *disp; 1063 1064 disp = loader_get_dispatch(commandBuffer); 1065 1066 disp->CmdSetViewport(commandBuffer, viewportCount, pViewports); 1067} 1068 1069LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t scissorCount, const VkRect2D* pScissors) 1070{ 1071 const VkLayerDispatchTable *disp; 1072 1073 disp = loader_get_dispatch(commandBuffer); 1074 1075 disp->CmdSetScissor(commandBuffer, scissorCount, pScissors); 1076} 1077 1078LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) 1079{ 1080 const VkLayerDispatchTable *disp; 1081 1082 disp = loader_get_dispatch(commandBuffer); 1083 1084 disp->CmdSetLineWidth(commandBuffer, lineWidth); 1085} 1086 1087LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) 1088{ 1089 const VkLayerDispatchTable *disp; 1090 1091 disp = loader_get_dispatch(commandBuffer); 1092 1093 disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); 1094} 1095 1096LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) 1097{ 1098 const VkLayerDispatchTable *disp; 1099 1100 disp = loader_get_dispatch(commandBuffer); 1101 1102 disp->CmdSetBlendConstants(commandBuffer, blendConstants); 1103} 1104 1105LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) 1106{ 1107 const VkLayerDispatchTable *disp; 1108 1109 disp = loader_get_dispatch(commandBuffer); 1110 1111 disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); 1112} 1113 1114LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) 1115{ 1116 const VkLayerDispatchTable *disp; 1117 1118 disp = loader_get_dispatch(commandBuffer); 1119 1120 disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); 1121} 1122 1123LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) 1124{ 1125 const VkLayerDispatchTable *disp; 1126 1127 disp = loader_get_dispatch(commandBuffer); 1128 1129 disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); 1130} 1131 1132LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) 1133{ 1134 const VkLayerDispatchTable *disp; 1135 1136 disp = loader_get_dispatch(commandBuffer); 1137 1138 disp->CmdSetStencilReference(commandBuffer, faceMask, reference); 1139} 1140 1141LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) 1142{ 1143 const VkLayerDispatchTable *disp; 1144 1145 disp = loader_get_dispatch(commandBuffer); 1146 1147 disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 1148} 1149 1150LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) 1151{ 1152 const VkLayerDispatchTable *disp; 1153 1154 disp = loader_get_dispatch(commandBuffer); 1155 1156 disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); 1157} 1158 1159LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) 1160{ 1161 const VkLayerDispatchTable *disp; 1162 1163 disp = loader_get_dispatch(commandBuffer); 1164 1165 disp->CmdBindVertexBuffers(commandBuffer, startBinding, bindingCount, pBuffers, pOffsets); 1166} 1167 1168LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) 1169{ 1170 const VkLayerDispatchTable *disp; 1171 1172 disp = loader_get_dispatch(commandBuffer); 1173 1174 disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); 1175} 1176 1177LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) 1178{ 1179 const VkLayerDispatchTable *disp; 1180 1181 disp = loader_get_dispatch(commandBuffer); 1182 1183 disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); 1184} 1185 1186LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) 1187{ 1188 const VkLayerDispatchTable *disp; 1189 1190 disp = loader_get_dispatch(commandBuffer); 1191 1192 disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); 1193} 1194 1195LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) 1196{ 1197 const VkLayerDispatchTable *disp; 1198 1199 disp = loader_get_dispatch(commandBuffer); 1200 1201 disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); 1202} 1203 1204LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) 1205{ 1206 const VkLayerDispatchTable *disp; 1207 1208 disp = loader_get_dispatch(commandBuffer); 1209 1210 disp->CmdDispatch(commandBuffer, x, y, z); 1211} 1212 1213LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) 1214{ 1215 const VkLayerDispatchTable *disp; 1216 1217 disp = loader_get_dispatch(commandBuffer); 1218 1219 disp->CmdDispatchIndirect(commandBuffer, buffer, offset); 1220} 1221 1222LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) 1223{ 1224 const VkLayerDispatchTable *disp; 1225 1226 disp = loader_get_dispatch(commandBuffer); 1227 1228 disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); 1229} 1230 1231LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) 1232{ 1233 const VkLayerDispatchTable *disp; 1234 1235 disp = loader_get_dispatch(commandBuffer); 1236 1237 disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1238} 1239 1240LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) 1241{ 1242 const VkLayerDispatchTable *disp; 1243 1244 disp = loader_get_dispatch(commandBuffer); 1245 1246 disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); 1247} 1248 1249LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) 1250{ 1251 const VkLayerDispatchTable *disp; 1252 1253 disp = loader_get_dispatch(commandBuffer); 1254 1255 disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); 1256} 1257 1258LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) 1259{ 1260 const VkLayerDispatchTable *disp; 1261 1262 disp = loader_get_dispatch(commandBuffer); 1263 1264 disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); 1265} 1266 1267LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) 1268{ 1269 const VkLayerDispatchTable *disp; 1270 1271 disp = loader_get_dispatch(commandBuffer); 1272 1273 disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); 1274} 1275 1276LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) 1277{ 1278 const VkLayerDispatchTable *disp; 1279 1280 disp = loader_get_dispatch(commandBuffer); 1281 1282 disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); 1283} 1284 1285LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) 1286{ 1287 const VkLayerDispatchTable *disp; 1288 1289 disp = loader_get_dispatch(commandBuffer); 1290 1291 disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); 1292} 1293 1294LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) 1295{ 1296 const VkLayerDispatchTable *disp; 1297 1298 disp = loader_get_dispatch(commandBuffer); 1299 1300 disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); 1301} 1302 1303LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) 1304{ 1305 const VkLayerDispatchTable *disp; 1306 1307 disp = loader_get_dispatch(commandBuffer); 1308 1309 disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); 1310} 1311 1312LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) 1313{ 1314 const VkLayerDispatchTable *disp; 1315 1316 disp = loader_get_dispatch(commandBuffer); 1317 1318 disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); 1319} 1320 1321LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) 1322{ 1323 const VkLayerDispatchTable *disp; 1324 1325 disp = loader_get_dispatch(commandBuffer); 1326 1327 disp->CmdSetEvent(commandBuffer, event, stageMask); 1328} 1329 1330LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) 1331{ 1332 const VkLayerDispatchTable *disp; 1333 1334 disp = loader_get_dispatch(commandBuffer); 1335 1336 disp->CmdResetEvent(commandBuffer, event, stageMask); 1337} 1338 1339LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) 1340{ 1341 const VkLayerDispatchTable *disp; 1342 1343 disp = loader_get_dispatch(commandBuffer); 1344 1345 disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers); 1346} 1347 1348LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) 1349{ 1350 const VkLayerDispatchTable *disp; 1351 1352 disp = loader_get_dispatch(commandBuffer); 1353 1354 disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers); 1355} 1356 1357LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) 1358{ 1359 const VkLayerDispatchTable *disp; 1360 1361 disp = loader_get_dispatch(commandBuffer); 1362 1363 disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags); 1364} 1365 1366LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) 1367{ 1368 const VkLayerDispatchTable *disp; 1369 1370 disp = loader_get_dispatch(commandBuffer); 1371 1372 disp->CmdEndQuery(commandBuffer, queryPool, slot); 1373} 1374 1375LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) 1376{ 1377 const VkLayerDispatchTable *disp; 1378 1379 disp = loader_get_dispatch(commandBuffer); 1380 1381 disp->CmdResetQueryPool(commandBuffer, queryPool, startQuery, queryCount); 1382} 1383 1384LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) 1385{ 1386 const VkLayerDispatchTable *disp; 1387 1388 disp = loader_get_dispatch(commandBuffer); 1389 1390 disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot); 1391} 1392 1393LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags) 1394{ 1395 const VkLayerDispatchTable *disp; 1396 1397 disp = loader_get_dispatch(commandBuffer); 1398 1399 disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, startQuery, queryCount, dstBuffer, dstOffset, stride, flags); 1400} 1401 1402LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) 1403{ 1404 const VkLayerDispatchTable *disp; 1405 1406 disp = loader_get_dispatch(commandBuffer); 1407 1408 disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); 1409} 1410 1411LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) 1412{ 1413 const VkLayerDispatchTable *disp; 1414 1415 disp = loader_get_dispatch(commandBuffer); 1416 1417 disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); 1418} 1419 1420LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) 1421{ 1422 const VkLayerDispatchTable *disp; 1423 1424 disp = loader_get_dispatch(commandBuffer); 1425 1426 disp->CmdNextSubpass(commandBuffer, contents); 1427} 1428 1429LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) 1430{ 1431 const VkLayerDispatchTable *disp; 1432 1433 disp = loader_get_dispatch(commandBuffer); 1434 1435 disp->CmdEndRenderPass(commandBuffer); 1436} 1437 1438LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) 1439{ 1440 const VkLayerDispatchTable *disp; 1441 1442 disp = loader_get_dispatch(commandBuffer); 1443 1444 disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers); 1445} 1446