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