trampoline.c revision bfa43b7050276b411e1c194b852819da78278d77
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#include <stdlib.h> 25#include <string.h> 26 27#include "loader_platform.h" 28#include "loader.h" 29 30#if defined(WIN32) 31// On Windows need to disable global optimization for function entrypoints or 32// else mhook will not be able to hook all of them 33#pragma optimize( "g", off ) 34#endif 35 36/* Trampoline entrypoints */ 37LOADER_EXPORT VkResult VKAPI vkCreateInstance( 38 const VkInstanceCreateInfo* pCreateInfo, 39 VkInstance* pInstance) 40{ 41 struct loader_instance *ptr_instance = NULL; 42 43 VkResult res = VK_ERROR_INITIALIZATION_FAILED; 44 uint32_t i; 45 46 /* Scan/discover all ICD libraries in a single-threaded manner */ 47 loader_platform_thread_once(&once_icd, loader_icd_scan); 48 49 /* get layer libraries in a single-threaded manner */ 50 loader_platform_thread_once(&once_layer, layer_lib_scan); 51 52 /* merge any duplicate extensions */ 53 loader_platform_thread_once(&once_exts, loader_coalesce_extensions); 54 55 ptr_instance = (struct loader_instance*) malloc(sizeof(struct loader_instance)); 56 if (ptr_instance == NULL) { 57 return VK_ERROR_OUT_OF_HOST_MEMORY; 58 } 59 memset(ptr_instance, 0, sizeof(struct loader_instance)); 60 ptr_instance->extension_count = pCreateInfo->extensionCount; 61 ptr_instance->extension_names = (ptr_instance->extension_count > 0) ? 62 malloc(sizeof (char *) * ptr_instance->extension_count) : NULL; 63 if (ptr_instance->extension_names == NULL && (ptr_instance->extension_count > 0)) 64 return VK_ERROR_OUT_OF_HOST_MEMORY; 65 for (i = 0; i < ptr_instance->extension_count; i++) { 66 if (!loader_is_extension_scanned(pCreateInfo->ppEnabledExtensionNames[i])) 67 return VK_ERROR_INVALID_EXTENSION; 68 ptr_instance->extension_names[i] = malloc(strlen(pCreateInfo->ppEnabledExtensionNames[i]) + 1); 69 if (ptr_instance->extension_names[i] == NULL) 70 return VK_ERROR_OUT_OF_HOST_MEMORY; 71 strcpy(ptr_instance->extension_names[i], pCreateInfo->ppEnabledExtensionNames[i]); 72 } 73 ptr_instance->disp = malloc(sizeof(VkLayerInstanceDispatchTable)); 74 if (ptr_instance->disp == NULL) 75 return VK_ERROR_OUT_OF_HOST_MEMORY; 76 memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp)); 77 ptr_instance->next = loader.instances; 78 loader.instances = ptr_instance; 79 loader_activate_instance_layers(ptr_instance); 80 81 res = instance_disp.CreateInstance(pCreateInfo, (VkInstance *) ptr_instance); 82 83 *pInstance = (VkInstance) ptr_instance; 84 return res; 85} 86 87LOADER_EXPORT VkResult VKAPI vkDestroyInstance( 88 VkInstance instance) 89{ 90 const VkLayerInstanceDispatchTable *disp; 91 92 disp = loader_get_instance_dispatch(instance); 93 return disp->DestroyInstance(instance); 94} 95 96LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices( 97 VkInstance instance, 98 uint32_t* pPhysicalDeviceCount, 99 VkPhysicalDevice* pPhysicalDevices) 100{ 101 const VkLayerInstanceDispatchTable *disp; 102 103 disp = loader_get_instance_dispatch(instance); 104 return disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, 105 pPhysicalDevices); 106} 107 108LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceInfo( 109 VkPhysicalDevice gpu, 110 VkPhysicalDeviceInfoType infoType, 111 size_t* pDataSize, 112 void* pData) 113{ 114 const VkLayerInstanceDispatchTable *disp; 115 VkResult res; 116 117 disp = loader_get_instance_dispatch(gpu); 118 119 res = disp->GetPhysicalDeviceInfo(gpu, infoType, pDataSize, pData); 120 //TODO add check for extension enabled 121 if (infoType == VK_PHYSICAL_DEVICE_INFO_TYPE_DISPLAY_PROPERTIES_WSI && pData && res == VK_SUCCESS) { 122 VkDisplayPropertiesWSI *info = pData; 123 size_t count = *pDataSize / sizeof(*info), i; 124 for (i = 0; i < count; i++) { 125 loader_set_dispatch(info[i].display, disp); 126 } 127 } 128 129 return res; 130} 131 132LOADER_EXPORT VkResult VKAPI vkCreateDevice( 133 VkPhysicalDevice gpu, 134 const VkDeviceCreateInfo* pCreateInfo, 135 VkDevice* pDevice) 136{ 137 const VkLayerInstanceDispatchTable *disp; 138 VkResult res; 139 140 disp = loader_get_instance_dispatch(gpu); 141 142 // CreateDevice is dispatched on the instance chain 143 res = disp->CreateDevice(gpu, pCreateInfo, pDevice); 144 return res; 145} 146 147LOADER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) 148{ 149 const VkLayerDispatchTable *disp; 150 VkResult res; 151 152 disp = loader_get_dispatch(device); 153 154 res = disp->DestroyDevice(device); 155 // TODO need to keep track of device objs to be able to get icd/gpu to deactivate 156 //loader_deactivate_device_layer(device); 157 return res; 158} 159 160#if 0 //TODO get working on layer instance chain 161LOADER_EXPORT VkResult VKAPI vkGetGlobalExtensionInfo( 162 VkExtensionInfoType infoType, 163 uint32_t extensionIndex, 164 size_t* pDataSize, 165 void* pData) 166{ 167 return instance_disp.GetGlobalExtensionInfo(infoType, extensionIndex, pDataSize, pData); 168} 169#endif 170 171LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionInfo( 172 VkPhysicalDevice gpu, 173 VkExtensionInfoType infoType, 174 uint32_t extensionIndex, 175 size_t* pDataSize, 176 void* pData) 177{ 178 const VkLayerInstanceDispatchTable *disp; 179 180 disp = loader_get_instance_dispatch(gpu); 181 182 return disp->GetPhysicalDeviceExtensionInfo(gpu, infoType, extensionIndex, pDataSize, pData); 183} 184 185LOADER_EXPORT VkResult VKAPI vkEnumerateLayers( 186 VkPhysicalDevice gpu, 187 size_t maxStringSize, 188 size_t* pLayerCount, 189 char* const* pOutLayers, 190 void* pReserved) 191{ 192 const VkLayerInstanceDispatchTable *disp; 193 194 disp = loader_get_instance_dispatch(gpu); 195 196 return disp->EnumerateLayers(gpu, maxStringSize, pLayerCount,pOutLayers, pReserved); 197} 198 199LOADER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) 200{ 201 const VkLayerDispatchTable *disp; 202 VkResult res; 203 204 disp = loader_get_dispatch(device); 205 206 res = disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); 207 if (res == VK_SUCCESS) { 208 loader_set_dispatch(*pQueue, disp); 209 } 210 211 return res; 212} 213 214LOADER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) 215{ 216 const VkLayerDispatchTable *disp; 217 218 disp = loader_get_dispatch(queue); 219 220 return disp->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); 221} 222 223LOADER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue) 224{ 225 const VkLayerDispatchTable *disp; 226 227 disp = loader_get_dispatch(queue); 228 229 return disp->QueueWaitIdle(queue); 230} 231 232LOADER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) 233{ 234 const VkLayerDispatchTable *disp; 235 236 disp = loader_get_dispatch(device); 237 238 return disp->DeviceWaitIdle(device); 239} 240 241LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) 242{ 243 const VkLayerDispatchTable *disp; 244 245 disp = loader_get_dispatch(device); 246 247 return disp->AllocMemory(device, pAllocInfo, pMem); 248} 249 250LOADER_EXPORT VkResult VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem) 251{ 252 const VkLayerDispatchTable *disp; 253 254 disp = loader_get_dispatch(device); 255 256 return disp->FreeMemory(device, mem); 257} 258 259LOADER_EXPORT VkResult VKAPI vkSetMemoryPriority(VkDevice device, VkDeviceMemory mem, VkMemoryPriority priority) 260{ 261 const VkLayerDispatchTable *disp; 262 263 disp = loader_get_dispatch(device); 264 265 return disp->SetMemoryPriority(device, mem, priority); 266} 267 268LOADER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) 269{ 270 const VkLayerDispatchTable *disp; 271 272 disp = loader_get_dispatch(device); 273 274 return disp->MapMemory(device, mem, offset, size, flags, ppData); 275} 276 277LOADER_EXPORT VkResult VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem) 278{ 279 const VkLayerDispatchTable *disp; 280 281 disp = loader_get_dispatch(device); 282 283 return disp->UnmapMemory(device, mem); 284} 285 286LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) 287{ 288 const VkLayerDispatchTable *disp; 289 290 disp = loader_get_dispatch(device); 291 292 return disp->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges); 293} 294 295LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) 296{ 297 const VkLayerDispatchTable *disp; 298 299 disp = loader_get_dispatch(device); 300 301 return disp->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges); 302} 303 304LOADER_EXPORT VkResult VKAPI vkPinSystemMemory(VkDevice device, const void* pSysMem, size_t memSize, VkDeviceMemory* pMem) 305{ 306 const VkLayerDispatchTable *disp; 307 308 disp = loader_get_dispatch(device); 309 310 return disp->PinSystemMemory(device, pSysMem, memSize, pMem); 311} 312 313LOADER_EXPORT VkResult VKAPI vkGetMultiDeviceCompatibility(VkPhysicalDevice gpu0, VkPhysicalDevice gpu1, VkPhysicalDeviceCompatibilityInfo* pInfo) 314{ 315 const VkLayerInstanceDispatchTable *disp; 316 317 disp = loader_get_instance_dispatch(gpu0); 318 319 return disp->GetMultiDeviceCompatibility(gpu0, gpu1, pInfo); 320} 321 322LOADER_EXPORT VkResult VKAPI vkOpenSharedMemory(VkDevice device, const VkMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) 323{ 324 const VkLayerDispatchTable *disp; 325 326 disp = loader_get_dispatch(device); 327 328 return disp->OpenSharedMemory(device, pOpenInfo, pMem); 329} 330 331LOADER_EXPORT VkResult VKAPI vkOpenSharedSemaphore(VkDevice device, const VkSemaphoreOpenInfo* pOpenInfo, VkSemaphore* pSemaphore) 332{ 333 const VkLayerDispatchTable *disp; 334 335 disp = loader_get_dispatch(device); 336 337 return disp->OpenSharedSemaphore(device, pOpenInfo, pSemaphore); 338} 339 340LOADER_EXPORT VkResult VKAPI vkOpenPeerMemory(VkDevice device, const VkPeerMemoryOpenInfo* pOpenInfo, VkDeviceMemory* pMem) 341{ 342 const VkLayerDispatchTable *disp; 343 344 disp = loader_get_dispatch(device); 345 346 return disp->OpenPeerMemory(device, pOpenInfo, pMem); 347} 348 349LOADER_EXPORT VkResult VKAPI vkOpenPeerImage(VkDevice device, const VkPeerImageOpenInfo* pOpenInfo, VkImage* pImage, VkDeviceMemory* pMem) 350{ 351 const VkLayerDispatchTable *disp; 352 353 disp = loader_get_dispatch(device); 354 355 return disp->OpenPeerImage(device, pOpenInfo, pImage, pMem); 356} 357 358LOADER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object) 359{ 360 const VkLayerDispatchTable *disp; 361 362 disp = loader_get_dispatch(device); 363 364 return disp->DestroyObject(device, objType, object); 365} 366 367LOADER_EXPORT VkResult VKAPI vkGetObjectInfo(VkDevice device, VkObjectType objType, VkObject object, VkObjectInfoType infoType, size_t* pDataSize, void* pData) 368{ 369 const VkLayerDispatchTable *disp; 370 371 disp = loader_get_dispatch(device); 372 373 return disp->GetObjectInfo(device, objType, object, infoType, pDataSize, pData); 374} 375 376LOADER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize offset) 377{ 378 const VkLayerDispatchTable *disp; 379 380 disp = loader_get_dispatch(device); 381 382 return disp->BindObjectMemory(device, objType, object, mem, offset); 383} 384 385LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) 386{ 387 const VkLayerDispatchTable *disp; 388 389 disp = loader_get_dispatch(queue); 390 391 return disp->QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset); 392} 393 394LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset) 395{ 396 const VkLayerDispatchTable *disp; 397 398 disp = loader_get_dispatch(queue); 399 400 return disp->QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset); 401} 402 403LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) 404{ 405 const VkLayerDispatchTable *disp; 406 407 disp = loader_get_dispatch(device); 408 409 return disp->CreateFence(device, pCreateInfo, pFence); 410} 411 412LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, VkFence* pFences) 413{ 414 const VkLayerDispatchTable *disp; 415 416 disp = loader_get_dispatch(device); 417 418 return disp->ResetFences(device, fenceCount, pFences); 419} 420 421LOADER_EXPORT VkResult VKAPI vkGetFenceStatus(VkDevice device, VkFence fence) 422{ 423 const VkLayerDispatchTable *disp; 424 425 disp = loader_get_dispatch(device); 426 427 return disp->GetFenceStatus(device, fence); 428} 429 430LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout) 431{ 432 const VkLayerDispatchTable *disp; 433 434 disp = loader_get_dispatch(device); 435 436 return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout); 437} 438 439LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) 440{ 441 const VkLayerDispatchTable *disp; 442 443 disp = loader_get_dispatch(device); 444 445 return disp->CreateSemaphore(device, pCreateInfo, pSemaphore); 446} 447 448LOADER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) 449{ 450 const VkLayerDispatchTable *disp; 451 452 disp = loader_get_dispatch(queue); 453 454 return disp->QueueSignalSemaphore(queue, semaphore); 455} 456 457LOADER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) 458{ 459 const VkLayerDispatchTable *disp; 460 461 disp = loader_get_dispatch(queue); 462 463 return disp->QueueWaitSemaphore(queue, semaphore); 464} 465 466LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) 467{ 468 const VkLayerDispatchTable *disp; 469 470 disp = loader_get_dispatch(device); 471 472 return disp->CreateEvent(device, pCreateInfo, pEvent); 473} 474 475LOADER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event) 476{ 477 const VkLayerDispatchTable *disp; 478 479 disp = loader_get_dispatch(device); 480 481 return disp->GetEventStatus(device, event); 482} 483 484LOADER_EXPORT VkResult VKAPI vkSetEvent(VkDevice device, VkEvent event) 485{ 486 const VkLayerDispatchTable *disp; 487 488 disp = loader_get_dispatch(device); 489 490 return disp->SetEvent(device, event); 491} 492 493LOADER_EXPORT VkResult VKAPI vkResetEvent(VkDevice device, VkEvent event) 494{ 495 const VkLayerDispatchTable *disp; 496 497 disp = loader_get_dispatch(device); 498 499 return disp->ResetEvent(device, event); 500} 501 502LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) 503{ 504 const VkLayerDispatchTable *disp; 505 506 disp = loader_get_dispatch(device); 507 508 return disp->CreateQueryPool(device, pCreateInfo, pQueryPool); 509} 510 511LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) 512{ 513 const VkLayerDispatchTable *disp; 514 515 disp = loader_get_dispatch(device); 516 517 return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags); 518} 519 520LOADER_EXPORT VkResult VKAPI vkGetFormatInfo(VkDevice device, VkFormat format, VkFormatInfoType infoType, size_t* pDataSize, void* pData) 521{ 522 const VkLayerDispatchTable *disp; 523 524 disp = loader_get_dispatch(device); 525 526 return disp->GetFormatInfo(device, format, infoType, pDataSize, pData); 527} 528 529LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) 530{ 531 const VkLayerDispatchTable *disp; 532 533 disp = loader_get_dispatch(device); 534 535 return disp->CreateBuffer(device, pCreateInfo, pBuffer); 536} 537 538LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) 539{ 540 const VkLayerDispatchTable *disp; 541 542 disp = loader_get_dispatch(device); 543 544 return disp->CreateBufferView(device, pCreateInfo, pView); 545} 546 547LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) 548{ 549 const VkLayerDispatchTable *disp; 550 551 disp = loader_get_dispatch(device); 552 553 return disp->CreateImage(device, pCreateInfo, pImage); 554} 555 556LOADER_EXPORT VkResult VKAPI vkGetImageSubresourceInfo(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceInfoType infoType, size_t* pDataSize, void* pData) 557{ 558 const VkLayerDispatchTable *disp; 559 560 disp = loader_get_dispatch(device); 561 562 return disp->GetImageSubresourceInfo(device, image, pSubresource, infoType, pDataSize, pData); 563} 564 565LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) 566{ 567 const VkLayerDispatchTable *disp; 568 569 disp = loader_get_dispatch(device); 570 571 return disp->CreateImageView(device, pCreateInfo, pView); 572} 573 574LOADER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) 575{ 576 const VkLayerDispatchTable *disp; 577 578 disp = loader_get_dispatch(device); 579 580 return disp->CreateColorAttachmentView(device, pCreateInfo, pView); 581} 582 583LOADER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) 584{ 585 const VkLayerDispatchTable *disp; 586 587 disp = loader_get_dispatch(device); 588 589 return disp->CreateDepthStencilView(device, pCreateInfo, pView); 590} 591 592LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) 593{ 594 const VkLayerDispatchTable *disp; 595 596 disp = loader_get_dispatch(device); 597 598 return disp->CreateShader(device, pCreateInfo, pShader); 599} 600 601LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) 602{ 603 const VkLayerDispatchTable *disp; 604 605 disp = loader_get_dispatch(device); 606 607 return disp->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); 608} 609 610LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) 611{ 612 const VkLayerDispatchTable *disp; 613 614 disp = loader_get_dispatch(device); 615 616 return disp->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); 617} 618 619LOADER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) 620{ 621 const VkLayerDispatchTable *disp; 622 623 disp = loader_get_dispatch(device); 624 625 return disp->CreateComputePipeline(device, pCreateInfo, pPipeline); 626} 627 628LOADER_EXPORT VkResult VKAPI vkStorePipeline(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData) 629{ 630 const VkLayerDispatchTable *disp; 631 632 disp = loader_get_dispatch(device); 633 634 return disp->StorePipeline(device, pipeline, pDataSize, pData); 635} 636 637LOADER_EXPORT VkResult VKAPI vkLoadPipeline(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline) 638{ 639 const VkLayerDispatchTable *disp; 640 641 disp = loader_get_dispatch(device); 642 643 return disp->LoadPipeline(device, dataSize, pData, pPipeline); 644} 645 646LOADER_EXPORT VkResult VKAPI vkLoadPipelineDerivative(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) 647{ 648 const VkLayerDispatchTable *disp; 649 650 disp = loader_get_dispatch(device); 651 652 return disp->LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline); 653} 654 655LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) 656{ 657 const VkLayerDispatchTable *disp; 658 659 disp = loader_get_dispatch(device); 660 661 return disp->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout); 662} 663 664LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) 665{ 666 const VkLayerDispatchTable *disp; 667 668 disp = loader_get_dispatch(device); 669 670 return disp->CreateSampler(device, pCreateInfo, pSampler); 671} 672 673LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) 674{ 675 const VkLayerDispatchTable *disp; 676 677 disp = loader_get_dispatch(device); 678 679 return disp->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); 680} 681 682LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) 683{ 684 const VkLayerDispatchTable *disp; 685 686 disp = loader_get_dispatch(device); 687 688 return disp->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); 689} 690 691LOADER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) 692{ 693 const VkLayerDispatchTable *disp; 694 695 disp = loader_get_dispatch(device); 696 697 return disp->ResetDescriptorPool(device, descriptorPool); 698} 699 700LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) 701{ 702 const VkLayerDispatchTable *disp; 703 704 disp = loader_get_dispatch(device); 705 706 return disp->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); 707} 708 709LOADER_EXPORT void VKAPI vkClearDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t count, const VkDescriptorSet* pDescriptorSets) 710{ 711 const VkLayerDispatchTable *disp; 712 713 disp = loader_get_dispatch(device); 714 715 disp->ClearDescriptorSets(device, descriptorPool, count, pDescriptorSets); 716} 717 718LOADER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) 719{ 720 const VkLayerDispatchTable *disp; 721 722 disp = loader_get_dispatch(device); 723 724 return disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies); 725} 726 727LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) 728{ 729 const VkLayerDispatchTable *disp; 730 731 disp = loader_get_dispatch(device); 732 733 return disp->CreateDynamicViewportState(device, pCreateInfo, pState); 734} 735 736LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState) 737{ 738 const VkLayerDispatchTable *disp; 739 740 disp = loader_get_dispatch(device); 741 742 return disp->CreateDynamicRasterState(device, pCreateInfo, pState); 743} 744 745LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState) 746{ 747 const VkLayerDispatchTable *disp; 748 749 disp = loader_get_dispatch(device); 750 751 return disp->CreateDynamicColorBlendState(device, pCreateInfo, pState); 752} 753 754LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState) 755{ 756 const VkLayerDispatchTable *disp; 757 758 disp = loader_get_dispatch(device); 759 760 return disp->CreateDynamicDepthStencilState(device, pCreateInfo, pState); 761} 762 763LOADER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) 764{ 765 const VkLayerDispatchTable *disp; 766 VkResult res; 767 768 disp = loader_get_dispatch(device); 769 770 res = disp->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); 771 if (res == VK_SUCCESS) { 772 loader_init_dispatch(*pCmdBuffer, disp); 773 } 774 775 return res; 776} 777 778LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) 779{ 780 const VkLayerDispatchTable *disp; 781 782 disp = loader_get_dispatch(cmdBuffer); 783 784 return disp->BeginCommandBuffer(cmdBuffer, pBeginInfo); 785} 786 787LOADER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) 788{ 789 const VkLayerDispatchTable *disp; 790 791 disp = loader_get_dispatch(cmdBuffer); 792 793 return disp->EndCommandBuffer(cmdBuffer); 794} 795 796LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) 797{ 798 const VkLayerDispatchTable *disp; 799 800 disp = loader_get_dispatch(cmdBuffer); 801 802 return disp->ResetCommandBuffer(cmdBuffer); 803} 804 805LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) 806{ 807 const VkLayerDispatchTable *disp; 808 809 disp = loader_get_dispatch(cmdBuffer); 810 811 disp->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); 812} 813 814LOADER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) 815{ 816 const VkLayerDispatchTable *disp; 817 818 disp = loader_get_dispatch(cmdBuffer); 819 820 disp->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state); 821} 822 823LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) 824{ 825 const VkLayerDispatchTable *disp; 826 827 disp = loader_get_dispatch(cmdBuffer); 828 829 disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 830} 831 832LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) 833{ 834 const VkLayerDispatchTable *disp; 835 836 disp = loader_get_dispatch(cmdBuffer); 837 838 disp->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); 839} 840 841LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) 842{ 843 const VkLayerDispatchTable *disp; 844 845 disp = loader_get_dispatch(cmdBuffer); 846 847 disp->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); 848} 849 850LOADER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) 851{ 852 const VkLayerDispatchTable *disp; 853 854 disp = loader_get_dispatch(cmdBuffer); 855 856 disp->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); 857} 858 859LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) 860{ 861 const VkLayerDispatchTable *disp; 862 863 disp = loader_get_dispatch(cmdBuffer); 864 865 disp->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); 866} 867 868LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) 869{ 870 const VkLayerDispatchTable *disp; 871 872 disp = loader_get_dispatch(cmdBuffer); 873 874 disp->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); 875} 876 877LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) 878{ 879 const VkLayerDispatchTable *disp; 880 881 disp = loader_get_dispatch(cmdBuffer); 882 883 disp->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); 884} 885 886LOADER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) 887{ 888 const VkLayerDispatchTable *disp; 889 890 disp = loader_get_dispatch(cmdBuffer); 891 892 disp->CmdDispatch(cmdBuffer, x, y, z); 893} 894 895LOADER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) 896{ 897 const VkLayerDispatchTable *disp; 898 899 disp = loader_get_dispatch(cmdBuffer); 900 901 disp->CmdDispatchIndirect(cmdBuffer, buffer, offset); 902} 903 904LOADER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) 905{ 906 const VkLayerDispatchTable *disp; 907 908 disp = loader_get_dispatch(cmdBuffer); 909 910 disp->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); 911} 912 913LOADER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) 914{ 915 const VkLayerDispatchTable *disp; 916 917 disp = loader_get_dispatch(cmdBuffer); 918 919 disp->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); 920} 921 922LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter) 923{ 924 const VkLayerDispatchTable *disp; 925 926 disp = loader_get_dispatch(cmdBuffer); 927 928 disp->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); 929} 930 931LOADER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) 932{ 933 const VkLayerDispatchTable *disp; 934 935 disp = loader_get_dispatch(cmdBuffer); 936 937 disp->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); 938} 939 940LOADER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) 941{ 942 const VkLayerDispatchTable *disp; 943 944 disp = loader_get_dispatch(cmdBuffer); 945 946 disp->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); 947} 948 949LOADER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) 950{ 951 const VkLayerDispatchTable *disp; 952 953 disp = loader_get_dispatch(cmdBuffer); 954 955 disp->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); 956} 957 958LOADER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) 959{ 960 const VkLayerDispatchTable *disp; 961 962 disp = loader_get_dispatch(cmdBuffer); 963 964 disp->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); 965} 966 967LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColor* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) 968{ 969 const VkLayerDispatchTable *disp; 970 971 disp = loader_get_dispatch(cmdBuffer); 972 973 disp->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); 974} 975 976LOADER_EXPORT void VKAPI vkCmdClearDepthStencil(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) 977{ 978 const VkLayerDispatchTable *disp; 979 980 disp = loader_get_dispatch(cmdBuffer); 981 982 disp->CmdClearDepthStencil(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); 983} 984 985LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) 986{ 987 const VkLayerDispatchTable *disp; 988 989 disp = loader_get_dispatch(cmdBuffer); 990 991 disp->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); 992} 993 994LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) 995{ 996 const VkLayerDispatchTable *disp; 997 998 disp = loader_get_dispatch(cmdBuffer); 999 1000 disp->CmdSetEvent(cmdBuffer, event, pipeEvent); 1001} 1002 1003LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipeEvent pipeEvent) 1004{ 1005 const VkLayerDispatchTable *disp; 1006 1007 disp = loader_get_dispatch(cmdBuffer); 1008 1009 disp->CmdResetEvent(cmdBuffer, event, pipeEvent); 1010} 1011 1012LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t eventCount, const VkEvent* pEvents, uint32_t memBarrierCount, const void** ppMemBarriers) 1013{ 1014 const VkLayerDispatchTable *disp; 1015 1016 disp = loader_get_dispatch(cmdBuffer); 1017 1018 disp->CmdWaitEvents(cmdBuffer, waitEvent, eventCount, pEvents, memBarrierCount, ppMemBarriers); 1019} 1020 1021LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkWaitEvent waitEvent, uint32_t pipeEventCount, const VkPipeEvent* pPipeEvents, uint32_t memBarrierCount, const void** ppMemBarriers) 1022{ 1023 const VkLayerDispatchTable *disp; 1024 1025 disp = loader_get_dispatch(cmdBuffer); 1026 1027 disp->CmdPipelineBarrier(cmdBuffer, waitEvent, pipeEventCount, pPipeEvents, memBarrierCount, ppMemBarriers); 1028} 1029 1030LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) 1031{ 1032 const VkLayerDispatchTable *disp; 1033 1034 disp = loader_get_dispatch(cmdBuffer); 1035 1036 disp->CmdBeginQuery(cmdBuffer, queryPool, slot, flags); 1037} 1038 1039LOADER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) 1040{ 1041 const VkLayerDispatchTable *disp; 1042 1043 disp = loader_get_dispatch(cmdBuffer); 1044 1045 disp->CmdEndQuery(cmdBuffer, queryPool, slot); 1046} 1047 1048LOADER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) 1049{ 1050 const VkLayerDispatchTable *disp; 1051 1052 disp = loader_get_dispatch(cmdBuffer); 1053 1054 disp->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); 1055} 1056 1057LOADER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) 1058{ 1059 const VkLayerDispatchTable *disp; 1060 1061 disp = loader_get_dispatch(cmdBuffer); 1062 1063 disp->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset); 1064} 1065 1066LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkFlags flags) 1067{ 1068 const VkLayerDispatchTable *disp; 1069 1070 disp = loader_get_dispatch(cmdBuffer); 1071 1072 disp->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags); 1073} 1074 1075LOADER_EXPORT void VKAPI vkCmdInitAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, const uint32_t* pData) 1076{ 1077 const VkLayerDispatchTable *disp; 1078 1079 disp = loader_get_dispatch(cmdBuffer); 1080 1081 disp->CmdInitAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, pData); 1082} 1083 1084LOADER_EXPORT void VKAPI vkCmdLoadAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer srcBuffer, VkDeviceSize srcOffset) 1085{ 1086 const VkLayerDispatchTable *disp; 1087 1088 disp = loader_get_dispatch(cmdBuffer); 1089 1090 disp->CmdLoadAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, srcBuffer, srcOffset); 1091} 1092 1093LOADER_EXPORT void VKAPI vkCmdSaveAtomicCounters(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, uint32_t startCounter, uint32_t counterCount, VkBuffer destBuffer, VkDeviceSize destOffset) 1094{ 1095 const VkLayerDispatchTable *disp; 1096 1097 disp = loader_get_dispatch(cmdBuffer); 1098 1099 disp->CmdSaveAtomicCounters(cmdBuffer, pipelineBindPoint, startCounter, counterCount, destBuffer, destOffset); 1100} 1101 1102LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) 1103{ 1104 const VkLayerDispatchTable *disp; 1105 1106 disp = loader_get_dispatch(device); 1107 1108 return disp->CreateFramebuffer(device, pCreateInfo, pFramebuffer); 1109} 1110 1111LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) 1112{ 1113 const VkLayerDispatchTable *disp; 1114 1115 disp = loader_get_dispatch(device); 1116 1117 return disp->CreateRenderPass(device, pCreateInfo, pRenderPass); 1118} 1119 1120LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) 1121{ 1122 const VkLayerDispatchTable *disp; 1123 1124 disp = loader_get_dispatch(cmdBuffer); 1125 1126 disp->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin); 1127} 1128 1129LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer, VkRenderPass renderPass) 1130{ 1131 const VkLayerDispatchTable *disp; 1132 1133 disp = loader_get_dispatch(cmdBuffer); 1134 1135 disp->CmdEndRenderPass(cmdBuffer, renderPass); 1136} 1137 1138LOADER_EXPORT VkResult VKAPI vkDbgRegisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback, void* pUserData) 1139{ 1140 const VkLayerInstanceDispatchTable *disp; 1141 1142 disp = loader_get_instance_dispatch(instance); 1143 1144 return disp->DbgRegisterMsgCallback(instance, pfnMsgCallback, pUserData); 1145} 1146 1147LOADER_EXPORT VkResult VKAPI vkDbgUnregisterMsgCallback(VkInstance instance, VK_DBG_MSG_CALLBACK_FUNCTION pfnMsgCallback) 1148{ 1149 const VkLayerInstanceDispatchTable *disp; 1150 1151 disp = loader_get_instance_dispatch(instance); 1152 1153 return disp->DbgUnregisterMsgCallback(instance, pfnMsgCallback); 1154} 1155 1156LOADER_EXPORT VkResult VKAPI vkDbgSetGlobalOption(VkInstance instance, VK_DBG_GLOBAL_OPTION dbgOption, size_t dataSize, const void* pData) 1157{ 1158 const VkLayerInstanceDispatchTable *disp; 1159 1160 disp = loader_get_instance_dispatch(instance); 1161 1162 return disp->DbgSetGlobalOption(instance, dbgOption, dataSize, pData); 1163} 1164 1165LOADER_EXPORT VkResult VKAPI vkDbgSetValidationLevel(VkDevice device, VkValidationLevel validationLevel) 1166{ 1167 const VkLayerDispatchTable *disp; 1168 1169 disp = loader_get_dispatch(device); 1170 1171 return disp->DbgSetValidationLevel(device, validationLevel); 1172} 1173 1174LOADER_EXPORT VkResult VKAPI vkDbgSetMessageFilter(VkDevice device, int32_t msgCode, VK_DBG_MSG_FILTER filter) 1175{ 1176 const VkLayerDispatchTable *disp; 1177 1178 disp = loader_get_dispatch(device); 1179 1180 return disp->DbgSetMessageFilter(device, msgCode, filter); 1181} 1182 1183LOADER_EXPORT VkResult VKAPI vkDbgSetObjectTag(VkDevice device, VkObject object, size_t tagSize, const void* pTag) 1184{ 1185 const VkLayerDispatchTable *disp; 1186 1187 disp = loader_get_dispatch(device); 1188 1189 return disp->DbgSetObjectTag(device, object, tagSize, pTag); 1190} 1191 1192LOADER_EXPORT VkResult VKAPI vkDbgSetDeviceOption(VkDevice device, VK_DBG_DEVICE_OPTION dbgOption, size_t dataSize, const void* pData) 1193{ 1194 const VkLayerDispatchTable *disp; 1195 1196 disp = loader_get_dispatch(device); 1197 1198 return disp->DbgSetDeviceOption(device, dbgOption, dataSize, pData); 1199} 1200 1201LOADER_EXPORT void VKAPI vkCmdDbgMarkerBegin(VkCmdBuffer cmdBuffer, const char* pMarker) 1202{ 1203 const VkLayerDispatchTable *disp; 1204 1205 disp = loader_get_dispatch(cmdBuffer); 1206 1207 disp->CmdDbgMarkerBegin(cmdBuffer, pMarker); 1208} 1209 1210LOADER_EXPORT void VKAPI vkCmdDbgMarkerEnd(VkCmdBuffer cmdBuffer) 1211{ 1212 const VkLayerDispatchTable *disp; 1213 1214 disp = loader_get_dispatch(cmdBuffer); 1215 1216 disp->CmdDbgMarkerEnd(cmdBuffer); 1217} 1218 1219LOADER_EXPORT VkResult VKAPI vkGetDisplayInfoWSI(VkDisplayWSI display, VkDisplayInfoTypeWSI infoType, size_t* pDataSize, void* pData) 1220{ 1221 const VkLayerInstanceDispatchTable *disp; 1222 1223 disp = loader_get_instance_dispatch(display); 1224 1225 return disp->GetDisplayInfoWSI(display, infoType, pDataSize, pData); 1226} 1227 1228LOADER_EXPORT VkResult VKAPI vkCreateSwapChainWSI(VkDevice device, const VkSwapChainCreateInfoWSI* pCreateInfo, VkSwapChainWSI* pSwapChain) 1229{ 1230 const VkLayerDispatchTable *disp; 1231 VkResult res; 1232 1233 disp = loader_get_dispatch(device); 1234 1235 res = disp->CreateSwapChainWSI(device, pCreateInfo, pSwapChain); 1236 if (res == VK_SUCCESS) { 1237 loader_init_dispatch(*pSwapChain, disp); 1238 } 1239 1240 return res; 1241} 1242 1243LOADER_EXPORT VkResult VKAPI vkDestroySwapChainWSI(VkSwapChainWSI swapChain) 1244{ 1245 const VkLayerDispatchTable *disp; 1246 1247 disp = loader_get_dispatch(swapChain); 1248 1249 return disp->DestroySwapChainWSI(swapChain); 1250} 1251 1252LOADER_EXPORT VkResult VKAPI vkGetSwapChainInfoWSI(VkSwapChainWSI swapChain, VkSwapChainInfoTypeWSI infoType, size_t* pDataSize, void* pData) 1253{ 1254 const VkLayerDispatchTable *disp; 1255 1256 disp = loader_get_dispatch(swapChain); 1257 1258 return disp->GetSwapChainInfoWSI(swapChain, infoType, pDataSize, pData); 1259} 1260 1261LOADER_EXPORT VkResult VKAPI vkQueuePresentWSI(VkQueue queue, const VkPresentInfoWSI* pPresentInfo) 1262{ 1263 const VkLayerDispatchTable *disp; 1264 1265 disp = loader_get_dispatch(queue); 1266 1267 return disp->QueuePresentWSI(queue, pPresentInfo); 1268} 1269 1270#if defined(WIN32) 1271#pragma optimize( "", on ) 1272#endif 1273