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