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