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