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