trampoline.c revision af9e4fd72c31e1080cadc3d6baa16b669af8e913
1/* 2 * 3 * Copyright (C) 2015 Valve Corporation 4 * 5 * Permission is hereby granted, free of charge, to any person obtaining a 6 * copy of this software and associated documentation files (the "Software"), 7 * to deal in the Software without restriction, including without limitation 8 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 9 * and/or sell copies of the Software, and to permit persons to whom the 10 * Software is furnished to do so, subject to the following conditions: 11 * 12 * The above copyright notice and this permission notice shall be included 13 * in all copies or substantial portions of the Software. 14 * 15 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 16 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 17 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 18 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 19 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 20 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 21 * DEALINGS IN THE SOFTWARE. 22 * 23 * Author: Chris Forbes <chrisf@ijw.co.nz> 24 * Author: Cody Northrop <cody@lunarg.com> 25 * Author: Jon Ashburn <jon@lunarg.com> 26 * Author: Tony Barbour <tony@LunarG.com> 27 */ 28#define _GNU_SOURCE 29#include <stdlib.h> 30#include <string.h> 31 32#include "vk_loader_platform.h" 33#include "loader.h" 34#include "debug_report.h" 35#include "wsi_swapchain.h" 36 37 38/* Trampoline entrypoints */ 39LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( 40 const VkInstanceCreateInfo* pCreateInfo, 41 const VkAllocationCallbacks* pAllocator, 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 (pAllocator) { 50 ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation( 51 pAllocator->pUserData, 52 sizeof(struct loader_instance), 53 sizeof(VkInstance), 54 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); 55 } else { 56 ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance)); 57 } 58 if (ptr_instance == NULL) { 59 return VK_ERROR_OUT_OF_HOST_MEMORY; 60 } 61 62 tls_instance = ptr_instance; 63 loader_platform_thread_lock_mutex(&loader_lock); 64 memset(ptr_instance, 0, sizeof(struct loader_instance)); 65 66 if (pAllocator) { 67 ptr_instance->alloc_callbacks = *pAllocator; 68 } 69 70 /* Due to implicit layers need to get layer list even if 71 * enabledLayerNameCount == 0 and VK_INSTANCE_LAYERS is unset. For now always 72 * get layer list (both instance and device) via loader_layer_scan(). */ 73 memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list)); 74 memset(&ptr_instance->device_layer_list, 0, sizeof(ptr_instance->device_layer_list)); 75 loader_layer_scan(ptr_instance, 76 77 78 &ptr_instance->instance_layer_list, 79 &ptr_instance->device_layer_list); 80 81 /* validate the app requested layers to be enabled */ 82 if (pCreateInfo->enabledLayerNameCount > 0) { 83 res = loader_validate_layers(pCreateInfo->enabledLayerNameCount, 84 pCreateInfo->ppEnabledLayerNames, 85 &ptr_instance->instance_layer_list); 86 if (res != VK_SUCCESS) { 87 loader_platform_thread_unlock_mutex(&loader_lock); 88 return res; 89 } 90 } 91 92 /* Scan/discover all ICD libraries */ 93 memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs)); 94 loader_icd_scan(ptr_instance, &ptr_instance->icd_libs); 95 96 /* get extensions from all ICD's, merge so no duplicates, then validate */ 97 loader_get_icd_loader_instance_extensions(ptr_instance, 98 &ptr_instance->icd_libs, 99 &ptr_instance->ext_list); 100 res = loader_validate_instance_extensions(&ptr_instance->ext_list, 101 &ptr_instance->instance_layer_list, 102 pCreateInfo); 103 if (res != VK_SUCCESS) { 104 loader_delete_layer_properties(ptr_instance, 105 &ptr_instance->device_layer_list); 106 loader_delete_layer_properties(ptr_instance, 107 &ptr_instance->instance_layer_list); 108 loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs); 109 loader_destroy_ext_list(ptr_instance, &ptr_instance->ext_list); 110 loader_platform_thread_unlock_mutex(&loader_lock); 111 loader_heap_free(ptr_instance, ptr_instance); 112 return res; 113 } 114 115 ptr_instance->disp = loader_heap_alloc( 116 ptr_instance, 117 sizeof(VkLayerInstanceDispatchTable), 118 VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); 119 if (ptr_instance->disp == NULL) { 120 loader_delete_layer_properties(ptr_instance, 121 &ptr_instance->device_layer_list); 122 loader_delete_layer_properties(ptr_instance, 123 &ptr_instance->instance_layer_list); 124 loader_scanned_icd_clear(ptr_instance, 125 &ptr_instance->icd_libs); 126 loader_destroy_ext_list(ptr_instance, 127 &ptr_instance->ext_list); 128 loader_platform_thread_unlock_mutex(&loader_lock); 129 loader_heap_free(ptr_instance, ptr_instance); 130 return VK_ERROR_OUT_OF_HOST_MEMORY; 131 } 132 memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp)); 133 ptr_instance->next = loader.instances; 134 loader.instances = ptr_instance; 135 136 /* activate any layers on instance chain */ 137 res = loader_enable_instance_layers(ptr_instance, 138 pCreateInfo, 139 &ptr_instance->instance_layer_list); 140 if (res != VK_SUCCESS) { 141 loader_delete_layer_properties(ptr_instance, 142 &ptr_instance->device_layer_list); 143 loader_delete_layer_properties(ptr_instance, 144 &ptr_instance->instance_layer_list); 145 loader_scanned_icd_clear(ptr_instance, 146 &ptr_instance->icd_libs); 147 loader_destroy_ext_list(ptr_instance, 148 &ptr_instance->ext_list); 149 loader.instances = ptr_instance->next; 150 loader_platform_thread_unlock_mutex(&loader_lock); 151 loader_heap_free(ptr_instance, ptr_instance->disp); 152 loader_heap_free(ptr_instance, ptr_instance); 153 return res; 154 } 155 loader_activate_instance_layers(ptr_instance); 156 157 wsi_swapchain_create_instance(ptr_instance, pCreateInfo); 158 debug_report_create_instance(ptr_instance, pCreateInfo); 159 160 161 *pInstance = (VkInstance) ptr_instance; 162 163 res = ptr_instance->disp->CreateInstance(pCreateInfo, pAllocator, pInstance); 164 165 /* 166 * Finally have the layers in place and everyone has seen 167 * the CreateInstance command go by. This allows the layer's 168 * GetInstanceProcAddr functions to return valid extension functions 169 * if enabled. 170 */ 171 loader_activate_instance_layer_extensions(ptr_instance); 172 173 loader_platform_thread_unlock_mutex(&loader_lock); 174 return res; 175} 176 177LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( 178 VkInstance instance, 179 const VkAllocationCallbacks* pAllocator) 180{ 181 const VkLayerInstanceDispatchTable *disp; 182 struct loader_instance *ptr_instance = NULL; 183 disp = loader_get_instance_dispatch(instance); 184 185 loader_platform_thread_lock_mutex(&loader_lock); 186 187 ptr_instance = loader_get_instance(instance); 188 disp->DestroyInstance(instance, pAllocator); 189 190 loader_deactivate_instance_layers(ptr_instance); 191 loader_heap_free(ptr_instance, ptr_instance->disp); 192 loader_heap_free(ptr_instance, ptr_instance); 193 loader_platform_thread_unlock_mutex(&loader_lock); 194} 195 196LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( 197 VkInstance instance, 198 uint32_t* pPhysicalDeviceCount, 199 VkPhysicalDevice* pPhysicalDevices) 200{ 201 const VkLayerInstanceDispatchTable *disp; 202 VkResult res; 203 disp = loader_get_instance_dispatch(instance); 204 205 loader_platform_thread_lock_mutex(&loader_lock); 206 res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, 207 pPhysicalDevices); 208 loader_platform_thread_unlock_mutex(&loader_lock); 209 return res; 210} 211 212LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( 213 VkPhysicalDevice gpu, 214 VkPhysicalDeviceFeatures *pFeatures) 215{ 216 const VkLayerInstanceDispatchTable *disp; 217 218 disp = loader_get_instance_dispatch(gpu); 219 disp->GetPhysicalDeviceFeatures(gpu, pFeatures); 220} 221 222LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( 223 VkPhysicalDevice gpu, 224 VkFormat format, 225 VkFormatProperties *pFormatInfo) 226{ 227 const VkLayerInstanceDispatchTable *disp; 228 229 disp = loader_get_instance_dispatch(gpu); 230 disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo); 231} 232 233LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) 234{ 235 const VkLayerInstanceDispatchTable *disp; 236 237 disp = loader_get_instance_dispatch(physicalDevice); 238 return disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); 239} 240 241LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( 242 VkPhysicalDevice gpu, 243 VkPhysicalDeviceProperties* pProperties) 244{ 245 const VkLayerInstanceDispatchTable *disp; 246 247 disp = loader_get_instance_dispatch(gpu); 248 disp->GetPhysicalDeviceProperties(gpu, pProperties); 249} 250 251LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( 252 VkPhysicalDevice gpu, 253 uint32_t* pQueueFamilyPropertyCount, 254 VkQueueFamilyProperties* pQueueProperties) 255{ 256 const VkLayerInstanceDispatchTable *disp; 257 258 disp = loader_get_instance_dispatch(gpu); 259 disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pQueueFamilyPropertyCount, pQueueProperties); 260} 261 262LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( 263 VkPhysicalDevice gpu, 264 VkPhysicalDeviceMemoryProperties* pMemoryProperties) 265{ 266 const VkLayerInstanceDispatchTable *disp; 267 268 disp = loader_get_instance_dispatch(gpu); 269 disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties); 270} 271 272LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( 273 VkPhysicalDevice gpu, 274 const VkDeviceCreateInfo* pCreateInfo, 275 const VkAllocationCallbacks* pAllocator, 276 VkDevice* pDevice) 277{ 278 VkResult res; 279 280 loader_platform_thread_lock_mutex(&loader_lock); 281 282 res = loader_CreateDevice(gpu, pCreateInfo, pAllocator, pDevice); 283 284 loader_platform_thread_unlock_mutex(&loader_lock); 285 return res; 286} 287 288LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) 289{ 290 const VkLayerDispatchTable *disp; 291 struct loader_device *dev; 292 struct loader_icd *icd = loader_get_icd_and_device(device, &dev); 293 const struct loader_instance *inst = icd->this_instance; 294 disp = loader_get_dispatch(device); 295 296 loader_platform_thread_lock_mutex(&loader_lock); 297 disp->DestroyDevice(device, pAllocator); 298 loader_remove_logical_device(inst, device); 299 loader_platform_thread_unlock_mutex(&loader_lock); 300} 301 302LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( 303 VkPhysicalDevice physicalDevice, 304 const char* pLayerName, 305 uint32_t* pPropertyCount, 306 VkExtensionProperties* pProperties) 307{ 308 VkResult res; 309 310 loader_platform_thread_lock_mutex(&loader_lock); 311 312 /* If pLayerName == NULL, then querying ICD extensions, pass this call 313 down the instance chain which will terminate in the ICD. This allows 314 layers to filter the extensions coming back up the chain. 315 If pLayerName != NULL then get layer extensions from manifest file. */ 316 if (pLayerName == NULL || strlen(pLayerName) == 0) { 317 const VkLayerInstanceDispatchTable *disp; 318 319 disp = loader_get_instance_dispatch(physicalDevice); 320 res = disp->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pPropertyCount, pProperties); 321 } else { 322 res = loader_EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); 323 } 324 325 loader_platform_thread_unlock_mutex(&loader_lock); 326 return res; 327} 328 329LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( 330 VkPhysicalDevice physicalDevice, 331 uint32_t* pPropertyCount, 332 VkLayerProperties* pProperties) 333{ 334 VkResult res; 335 336 loader_platform_thread_lock_mutex(&loader_lock); 337 338 /* Don't dispatch this call down the instance chain, want all device layers 339 enumerated and instance chain may not contain all device layers */ 340 res = loader_EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); 341 loader_platform_thread_unlock_mutex(&loader_lock); 342 return res; 343} 344 345LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) 346{ 347 const VkLayerDispatchTable *disp; 348 349 disp = loader_get_dispatch(device); 350 351 disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); 352 loader_set_dispatch(*pQueue, disp); 353} 354 355LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) 356{ 357 const VkLayerDispatchTable *disp; 358 359 disp = loader_get_dispatch(queue); 360 361 return disp->QueueSubmit(queue, submitCount, pSubmits, fence); 362} 363 364LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) 365{ 366 const VkLayerDispatchTable *disp; 367 368 disp = loader_get_dispatch(queue); 369 370 return disp->QueueWaitIdle(queue); 371} 372 373LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) 374{ 375 const VkLayerDispatchTable *disp; 376 377 disp = loader_get_dispatch(device); 378 379 return disp->DeviceWaitIdle(device); 380} 381 382LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) 383{ 384 const VkLayerDispatchTable *disp; 385 386 disp = loader_get_dispatch(device); 387 388 return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); 389} 390 391LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* pAllocator) 392{ 393 const VkLayerDispatchTable *disp; 394 395 disp = loader_get_dispatch(device); 396 397 disp->FreeMemory(device, mem, pAllocator); 398} 399 400LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) 401{ 402 const VkLayerDispatchTable *disp; 403 404 disp = loader_get_dispatch(device); 405 406 return disp->MapMemory(device, mem, offset, size, flags, ppData); 407} 408 409LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem) 410{ 411 const VkLayerDispatchTable *disp; 412 413 disp = loader_get_dispatch(device); 414 415 disp->UnmapMemory(device, mem); 416} 417 418LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) 419{ 420 const VkLayerDispatchTable *disp; 421 422 disp = loader_get_dispatch(device); 423 424 return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 425} 426 427LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) 428{ 429 const VkLayerDispatchTable *disp; 430 431 disp = loader_get_dispatch(device); 432 433 return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); 434} 435 436LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) 437{ 438 const VkLayerDispatchTable *disp; 439 440 disp = loader_get_dispatch(device); 441 442 disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); 443} 444 445LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset) 446{ 447 const VkLayerDispatchTable *disp; 448 449 disp = loader_get_dispatch(device); 450 451 return disp->BindBufferMemory(device, buffer, mem, offset); 452} 453 454LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize offset) 455{ 456 const VkLayerDispatchTable *disp; 457 458 disp = loader_get_dispatch(device); 459 460 return disp->BindImageMemory(device, image, mem, offset); 461} 462 463LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) 464{ 465 const VkLayerDispatchTable *disp; 466 467 disp = loader_get_dispatch(device); 468 469 disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); 470} 471 472LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) 473{ 474 const VkLayerDispatchTable *disp; 475 476 disp = loader_get_dispatch(device); 477 478 disp->GetImageMemoryRequirements(device, image, pMemoryRequirements); 479} 480 481LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) 482{ 483 const VkLayerDispatchTable *disp; 484 485 disp = loader_get_dispatch(device); 486 487 disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); 488} 489 490LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) 491{ 492 const VkLayerInstanceDispatchTable *disp; 493 494 disp = loader_get_instance_dispatch(physicalDevice); 495 496 disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); 497} 498 499LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) 500{ 501 const VkLayerDispatchTable *disp; 502 503 disp = loader_get_dispatch(queue); 504 505 return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); 506} 507 508LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) 509{ 510 const VkLayerDispatchTable *disp; 511 512 disp = loader_get_dispatch(device); 513 514 return disp->CreateFence(device, pCreateInfo, pAllocator, pFence); 515} 516 517LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) 518{ 519 const VkLayerDispatchTable *disp; 520 521 disp = loader_get_dispatch(device); 522 523 disp->DestroyFence(device, fence, pAllocator); 524} 525 526LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) 527{ 528 const VkLayerDispatchTable *disp; 529 530 disp = loader_get_dispatch(device); 531 532 return disp->ResetFences(device, fenceCount, pFences); 533} 534 535LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) 536{ 537 const VkLayerDispatchTable *disp; 538 539 disp = loader_get_dispatch(device); 540 541 return disp->GetFenceStatus(device, fence); 542} 543 544LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) 545{ 546 const VkLayerDispatchTable *disp; 547 548 disp = loader_get_dispatch(device); 549 550 return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout); 551} 552 553LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) 554{ 555 const VkLayerDispatchTable *disp; 556 557 disp = loader_get_dispatch(device); 558 559 return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); 560} 561 562LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) 563{ 564 const VkLayerDispatchTable *disp; 565 566 disp = loader_get_dispatch(device); 567 568 disp->DestroySemaphore(device, semaphore, pAllocator); 569} 570 571LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) 572{ 573 const VkLayerDispatchTable *disp; 574 575 disp = loader_get_dispatch(device); 576 577 return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent); 578} 579 580LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) 581{ 582 const VkLayerDispatchTable *disp; 583 584 disp = loader_get_dispatch(device); 585 586 disp->DestroyEvent(device, event, pAllocator); 587} 588 589LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) 590{ 591 const VkLayerDispatchTable *disp; 592 593 disp = loader_get_dispatch(device); 594 595 return disp->GetEventStatus(device, event); 596} 597 598LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) 599{ 600 const VkLayerDispatchTable *disp; 601 602 disp = loader_get_dispatch(device); 603 604 return disp->SetEvent(device, event); 605} 606 607LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) 608{ 609 const VkLayerDispatchTable *disp; 610 611 disp = loader_get_dispatch(device); 612 613 return disp->ResetEvent(device, event); 614} 615 616LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) 617{ 618 const VkLayerDispatchTable *disp; 619 620 disp = loader_get_dispatch(device); 621 622 return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); 623} 624 625LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) 626{ 627 const VkLayerDispatchTable *disp; 628 629 disp = loader_get_dispatch(device); 630 631 disp->DestroyQueryPool(device, queryPool, pAllocator); 632} 633 634LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) 635{ 636 const VkLayerDispatchTable *disp; 637 638 disp = loader_get_dispatch(device); 639 640 return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, dataSize, pData, stride, flags); 641} 642 643LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) 644{ 645 const VkLayerDispatchTable *disp; 646 647 disp = loader_get_dispatch(device); 648 649 return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); 650} 651 652LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) 653{ 654 const VkLayerDispatchTable *disp; 655 656 disp = loader_get_dispatch(device); 657 658 disp->DestroyBuffer(device, buffer, pAllocator); 659} 660 661LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) 662{ 663 const VkLayerDispatchTable *disp; 664 665 disp = loader_get_dispatch(device); 666 667 return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView); 668} 669 670LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) 671{ 672 const VkLayerDispatchTable *disp; 673 674 disp = loader_get_dispatch(device); 675 676 disp->DestroyBufferView(device, bufferView, pAllocator); 677} 678 679LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) 680{ 681 const VkLayerDispatchTable *disp; 682 683 disp = loader_get_dispatch(device); 684 685 return disp->CreateImage(device, pCreateInfo, pAllocator, pImage); 686} 687 688LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) 689{ 690 const VkLayerDispatchTable *disp; 691 692 disp = loader_get_dispatch(device); 693 694 disp->DestroyImage(device, image, pAllocator); 695} 696 697LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 698{ 699 const VkLayerDispatchTable *disp; 700 701 disp = loader_get_dispatch(device); 702 703 disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout); 704} 705 706LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) 707{ 708 const VkLayerDispatchTable *disp; 709 710 disp = loader_get_dispatch(device); 711 712 return disp->CreateImageView(device, pCreateInfo, pAllocator, pView); 713} 714 715LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) 716{ 717 const VkLayerDispatchTable *disp; 718 719 disp = loader_get_dispatch(device); 720 721 disp->DestroyImageView(device, imageView, pAllocator); 722} 723 724LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShader) 725{ 726 const VkLayerDispatchTable *disp; 727 728 disp = loader_get_dispatch(device); 729 730 return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader); 731} 732 733LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) 734{ 735 const VkLayerDispatchTable *disp; 736 737 disp = loader_get_dispatch(device); 738 739 disp->DestroyShaderModule(device, shaderModule, pAllocator); 740} 741 742LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR VkResult VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL 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 VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) 1428{ 1429 const VkLayerDispatchTable *disp; 1430 1431 disp = loader_get_dispatch(commandBuffer); 1432 1433 disp->CmdEndRenderPass(commandBuffer); 1434} 1435 1436LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL 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