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