trampoline.c revision b620ace53373bb2803db70005dee39be9c184f06
1/* 2 * Vulkan 3 * 4 * Copyright (C) 2014 LunarG, Inc. 5 * 6 * Permission is hereby granted, free of charge, to any person obtaining a 7 * copy of this software and associated documentation files (the "Software"), 8 * to deal in the Software without restriction, including without limitation 9 * the rights to use, copy, modify, merge, publish, distribute, sublicense, 10 * and/or sell copies of the Software, and to permit persons to whom the 11 * Software is furnished to do so, subject to the following conditions: 12 * 13 * The above copyright notice and this permission notice shall be included 14 * in all copies or substantial portions of the Software. 15 * 16 * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR 17 * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, 18 * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL 19 * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER 20 * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING 21 * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER 22 * DEALINGS IN THE SOFTWARE. 23 */ 24#define _GNU_SOURCE 25#include <stdlib.h> 26#include <string.h> 27 28#include "vk_loader_platform.h" 29#include "loader.h" 30#include "debug_report.h" 31 32#if defined(WIN32) 33// On Windows need to disable global optimization for function entrypoints or 34// else mhook will not be able to hook all of them 35#pragma optimize( "g", off ) 36#endif 37 38/* Trampoline entrypoints */ 39LOADER_EXPORT VkResult VKAPI vkCreateInstance( 40 const VkInstanceCreateInfo* pCreateInfo, 41 VkInstance* pInstance) 42{ 43 struct loader_instance *ptr_instance = NULL; 44 45 VkResult res = VK_ERROR_INITIALIZATION_FAILED; 46 47 /* Scan/discover all ICD libraries in a single-threaded manner */ 48 loader_platform_thread_once(&once_icd, loader_icd_scan); 49 50 /* get layer libraries in a single-threaded manner */ 51 loader_platform_thread_once(&once_layer, loader_layer_scan); 52 53 /* merge any duplicate extensions */ 54 loader_platform_thread_once(&once_exts, loader_coalesce_extensions); 55 56 ptr_instance = (struct loader_instance*) malloc(sizeof(struct loader_instance)); 57 if (ptr_instance == NULL) { 58 return VK_ERROR_OUT_OF_HOST_MEMORY; 59 } 60 loader_platform_thread_lock_mutex(&loader_lock); 61 memset(ptr_instance, 0, sizeof(struct loader_instance)); 62 63 ptr_instance->disp = malloc(sizeof(VkLayerInstanceDispatchTable)); 64 if (ptr_instance->disp == NULL) { 65 loader_platform_thread_unlock_mutex(&loader_lock); 66 return VK_ERROR_OUT_OF_HOST_MEMORY; 67 } 68 memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp)); 69 ptr_instance->next = loader.instances; 70 loader.instances = ptr_instance; 71 72 if (pCreateInfo->pAllocCb 73 && pCreateInfo->pAllocCb->pfnAlloc 74 && pCreateInfo->pAllocCb->pfnFree) { 75 ptr_instance->alloc_callbacks.pUserData = pCreateInfo->pAllocCb->pUserData; 76 ptr_instance->alloc_callbacks.pfnAlloc = pCreateInfo->pAllocCb->pfnAlloc; 77 ptr_instance->alloc_callbacks.pfnFree = pCreateInfo->pAllocCb->pfnFree; 78 } 79 80 loader_enable_instance_layers(ptr_instance, pCreateInfo); 81 82 debug_report_create_instance(ptr_instance, pCreateInfo); 83 84 /* enable any layers on instance chain */ 85 loader_activate_instance_layers(ptr_instance); 86 87 *pInstance = (VkInstance) ptr_instance; 88 89 res = ptr_instance->disp->CreateInstance(pCreateInfo, pInstance); 90 91 /* 92 * Finally have the layers in place and everyone has seen 93 * the CreateInstance command go by. This allows the layer's 94 * GetInstanceProcAddr functions to return valid extension functions 95 * if enabled. 96 */ 97 loader_activate_instance_layer_extensions(ptr_instance); 98 99 loader_platform_thread_unlock_mutex(&loader_lock); 100 101 return res; 102} 103 104LOADER_EXPORT VkResult VKAPI vkDestroyInstance( 105 VkInstance instance) 106{ 107 const VkLayerInstanceDispatchTable *disp; 108 VkResult res; 109 disp = loader_get_instance_dispatch(instance); 110 111 loader_platform_thread_lock_mutex(&loader_lock); 112 113 res = disp->DestroyInstance(instance); 114 115 struct loader_instance *ptr_instance = loader_instance(instance); 116 loader_deactivate_instance_layers(ptr_instance); 117 118 free(ptr_instance); 119 120 loader_platform_thread_unlock_mutex(&loader_lock); 121 122 return res; 123} 124 125LOADER_EXPORT VkResult VKAPI vkEnumeratePhysicalDevices( 126 VkInstance instance, 127 uint32_t* pPhysicalDeviceCount, 128 VkPhysicalDevice* pPhysicalDevices) 129{ 130 const VkLayerInstanceDispatchTable *disp; 131 VkResult res; 132 disp = loader_get_instance_dispatch(instance); 133 134 loader_platform_thread_lock_mutex(&loader_lock); 135 res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, 136 pPhysicalDevices); 137 loader_platform_thread_unlock_mutex(&loader_lock); 138 return res; 139} 140 141LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceProperties( 142 VkPhysicalDevice gpu, 143 VkPhysicalDeviceProperties* pProperties) 144{ 145 const VkLayerInstanceDispatchTable *disp; 146 VkResult res; 147 148 disp = loader_get_instance_dispatch(gpu); 149 res = disp->GetPhysicalDeviceProperties(gpu, pProperties); 150 return res; 151} 152 153LOADER_EXPORT VkResult VKAPI vkGetPhysicalDevicePerformance( 154 VkPhysicalDevice gpu, 155 VkPhysicalDevicePerformance* pPerformance) 156{ 157 const VkLayerInstanceDispatchTable *disp; 158 VkResult res; 159 160 disp = loader_get_instance_dispatch(gpu); 161 res = disp->GetPhysicalDevicePerformance(gpu, pPerformance); 162 return res; 163} 164 165LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueCount( 166 VkPhysicalDevice gpu, 167 uint32_t* pCount) 168{ 169 const VkLayerInstanceDispatchTable *disp; 170 VkResult res; 171 172 disp = loader_get_instance_dispatch(gpu); 173 res = disp->GetPhysicalDeviceQueueCount(gpu, pCount); 174 return res; 175} 176 177LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceQueueProperties( 178 VkPhysicalDevice gpu, 179 uint32_t count, 180 VkPhysicalDeviceQueueProperties* pQueueProperties) 181{ 182 const VkLayerInstanceDispatchTable *disp; 183 VkResult res; 184 185 disp = loader_get_instance_dispatch(gpu); 186 res = disp->GetPhysicalDeviceQueueProperties(gpu, count, pQueueProperties); 187 return res; 188} 189 190LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceMemoryProperties( 191 VkPhysicalDevice gpu, 192 VkPhysicalDeviceMemoryProperties* pMemoryProperties) 193{ 194 const VkLayerInstanceDispatchTable *disp; 195 VkResult res; 196 197 disp = loader_get_instance_dispatch(gpu); 198 res = disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties); 199 return res; 200} 201 202LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFeatures( 203 VkPhysicalDevice gpu, 204 VkPhysicalDeviceFeatures *pFeatures) 205{ 206 const VkLayerInstanceDispatchTable *disp; 207 VkResult res; 208 209 disp = loader_get_instance_dispatch(gpu); 210 res = disp->GetPhysicalDeviceFeatures(gpu, pFeatures); 211 return res; 212} 213 214LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceFormatInfo( 215 VkPhysicalDevice gpu, 216 VkFormat format, 217 VkFormatProperties *pFormatInfo) 218{ 219 const VkLayerInstanceDispatchTable *disp; 220 VkResult res; 221 222 disp = loader_get_instance_dispatch(gpu); 223 res = disp->GetPhysicalDeviceFormatInfo(gpu, format, pFormatInfo); 224 return res; 225} 226 227LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLimits( 228 VkPhysicalDevice gpu, 229 VkPhysicalDeviceLimits *pLimits) 230{ 231 const VkLayerInstanceDispatchTable *disp; 232 VkResult res; 233 234 disp = loader_get_instance_dispatch(gpu); 235 res = disp->GetPhysicalDeviceLimits(gpu, pLimits); 236 return res; 237} 238 239LOADER_EXPORT VkResult VKAPI vkCreateDevice( 240 VkPhysicalDevice gpu, 241 const VkDeviceCreateInfo* pCreateInfo, 242 VkDevice* pDevice) 243{ 244 VkResult res; 245 246 loader_platform_thread_lock_mutex(&loader_lock); 247 248 res = loader_CreateDevice(gpu, pCreateInfo, pDevice); 249 250 loader_platform_thread_unlock_mutex(&loader_lock); 251 return res; 252} 253 254LOADER_EXPORT VkResult VKAPI vkDestroyDevice(VkDevice device) 255{ 256 const VkLayerDispatchTable *disp; 257 VkResult res; 258 259 disp = loader_get_dispatch(device); 260 261 loader_platform_thread_lock_mutex(&loader_lock); 262 res = disp->DestroyDevice(device); 263 loader_remove_logical_device(device); 264 loader_platform_thread_unlock_mutex(&loader_lock); 265 return res; 266} 267 268LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceExtensionProperties( 269 VkPhysicalDevice physicalDevice, 270 const char* pLayerName, 271 uint32_t* pCount, 272 VkExtensionProperties* pProperties) 273{ 274 VkResult res; 275 276 loader_platform_thread_lock_mutex(&loader_lock); 277 res = loader_GetPhysicalDeviceExtensionProperties(physicalDevice, pLayerName, pCount, pProperties); 278 loader_platform_thread_unlock_mutex(&loader_lock); 279 return res; 280} 281 282LOADER_EXPORT VkResult VKAPI vkGetPhysicalDeviceLayerProperties( 283 VkPhysicalDevice physicalDevice, 284 uint32_t* pCount, 285 VkLayerProperties* pProperties) 286{ 287 VkResult res; 288 289 loader_platform_thread_lock_mutex(&loader_lock); 290 res = loader_GetPhysicalDeviceLayerProperties(physicalDevice, pCount, pProperties); 291 loader_platform_thread_unlock_mutex(&loader_lock); 292 return res; 293} 294 295LOADER_EXPORT VkResult VKAPI vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) 296{ 297 const VkLayerDispatchTable *disp; 298 VkResult res; 299 300 disp = loader_get_dispatch(device); 301 302 res = disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); 303 if (res == VK_SUCCESS) { 304 loader_set_dispatch(*pQueue, disp); 305 } 306 307 return res; 308} 309 310LOADER_EXPORT VkResult VKAPI vkQueueSubmit(VkQueue queue, uint32_t cmdBufferCount, const VkCmdBuffer* pCmdBuffers, VkFence fence) 311{ 312 const VkLayerDispatchTable *disp; 313 314 disp = loader_get_dispatch(queue); 315 316 return disp->QueueSubmit(queue, cmdBufferCount, pCmdBuffers, fence); 317} 318 319LOADER_EXPORT VkResult VKAPI vkQueueWaitIdle(VkQueue queue) 320{ 321 const VkLayerDispatchTable *disp; 322 323 disp = loader_get_dispatch(queue); 324 325 return disp->QueueWaitIdle(queue); 326} 327 328LOADER_EXPORT VkResult VKAPI vkDeviceWaitIdle(VkDevice device) 329{ 330 const VkLayerDispatchTable *disp; 331 332 disp = loader_get_dispatch(device); 333 334 return disp->DeviceWaitIdle(device); 335} 336 337LOADER_EXPORT VkResult VKAPI vkAllocMemory(VkDevice device, const VkMemoryAllocInfo* pAllocInfo, VkDeviceMemory* pMem) 338{ 339 const VkLayerDispatchTable *disp; 340 341 disp = loader_get_dispatch(device); 342 343 return disp->AllocMemory(device, pAllocInfo, pMem); 344} 345 346LOADER_EXPORT VkResult VKAPI vkFreeMemory(VkDevice device, VkDeviceMemory mem) 347{ 348 const VkLayerDispatchTable *disp; 349 350 disp = loader_get_dispatch(device); 351 352 return disp->FreeMemory(device, mem); 353} 354 355LOADER_EXPORT VkResult VKAPI vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) 356{ 357 const VkLayerDispatchTable *disp; 358 359 disp = loader_get_dispatch(device); 360 361 return disp->MapMemory(device, mem, offset, size, flags, ppData); 362} 363 364LOADER_EXPORT VkResult VKAPI vkUnmapMemory(VkDevice device, VkDeviceMemory mem) 365{ 366 const VkLayerDispatchTable *disp; 367 368 disp = loader_get_dispatch(device); 369 370 return disp->UnmapMemory(device, mem); 371} 372 373LOADER_EXPORT VkResult VKAPI vkFlushMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) 374{ 375 const VkLayerDispatchTable *disp; 376 377 disp = loader_get_dispatch(device); 378 379 return disp->FlushMappedMemoryRanges(device, memRangeCount, pMemRanges); 380} 381 382LOADER_EXPORT VkResult VKAPI vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memRangeCount, const VkMappedMemoryRange* pMemRanges) 383{ 384 const VkLayerDispatchTable *disp; 385 386 disp = loader_get_dispatch(device); 387 388 return disp->InvalidateMappedMemoryRanges(device, memRangeCount, pMemRanges); 389} 390 391LOADER_EXPORT VkResult VKAPI vkDestroyObject(VkDevice device, VkObjectType objType, VkObject object) 392{ 393 const VkLayerDispatchTable *disp; 394 395 disp = loader_get_dispatch(device); 396 397 return disp->DestroyObject(device, objType, object); 398} 399 400LOADER_EXPORT VkResult VKAPI vkGetObjectMemoryRequirements(VkDevice device, VkObjectType objType, VkObject object, VkMemoryRequirements* pMemoryRequirements) 401{ 402 const VkLayerDispatchTable *disp; 403 404 disp = loader_get_dispatch(device); 405 406 return disp->GetObjectMemoryRequirements(device, objType, object, pMemoryRequirements); 407} 408 409LOADER_EXPORT VkResult VKAPI vkBindObjectMemory(VkDevice device, VkObjectType objType, VkObject object, VkDeviceMemory mem, VkDeviceSize offset) 410{ 411 const VkLayerDispatchTable *disp; 412 413 disp = loader_get_dispatch(device); 414 415 return disp->BindObjectMemory(device, objType, object, mem, offset); 416} 417 418LOADER_EXPORT VkResult VKAPI vkQueueBindSparseBufferMemory(VkQueue queue, VkBuffer buffer, VkDeviceSize rangeOffset, VkDeviceSize rangeSize, VkDeviceMemory mem, VkDeviceSize memOffset) 419{ 420 const VkLayerDispatchTable *disp; 421 422 disp = loader_get_dispatch(queue); 423 424 return disp->QueueBindSparseBufferMemory(queue, buffer, rangeOffset, rangeSize, mem, memOffset); 425} 426 427LOADER_EXPORT VkResult VKAPI vkQueueBindSparseImageMemory(VkQueue queue, VkImage image, const VkImageMemoryBindInfo* pBindInfo, VkDeviceMemory mem, VkDeviceSize memOffset) 428{ 429 const VkLayerDispatchTable *disp; 430 431 disp = loader_get_dispatch(queue); 432 433 return disp->QueueBindSparseImageMemory(queue, image, pBindInfo, mem, memOffset); 434} 435 436LOADER_EXPORT VkResult VKAPI vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, VkFence* pFence) 437{ 438 const VkLayerDispatchTable *disp; 439 440 disp = loader_get_dispatch(device); 441 442 return disp->CreateFence(device, pCreateInfo, pFence); 443} 444 445LOADER_EXPORT VkResult VKAPI vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) 446{ 447 const VkLayerDispatchTable *disp; 448 449 disp = loader_get_dispatch(device); 450 451 return disp->ResetFences(device, fenceCount, pFences); 452} 453 454LOADER_EXPORT VkResult VKAPI vkGetFenceStatus(VkDevice device, VkFence fence) 455{ 456 const VkLayerDispatchTable *disp; 457 458 disp = loader_get_dispatch(device); 459 460 return disp->GetFenceStatus(device, fence); 461} 462 463LOADER_EXPORT VkResult VKAPI vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, bool32_t waitAll, uint64_t timeout) 464{ 465 const VkLayerDispatchTable *disp; 466 467 disp = loader_get_dispatch(device); 468 469 return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout); 470} 471 472LOADER_EXPORT VkResult VKAPI vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, VkSemaphore* pSemaphore) 473{ 474 const VkLayerDispatchTable *disp; 475 476 disp = loader_get_dispatch(device); 477 478 return disp->CreateSemaphore(device, pCreateInfo, pSemaphore); 479} 480 481LOADER_EXPORT VkResult VKAPI vkQueueSignalSemaphore(VkQueue queue, VkSemaphore semaphore) 482{ 483 const VkLayerDispatchTable *disp; 484 485 disp = loader_get_dispatch(queue); 486 487 return disp->QueueSignalSemaphore(queue, semaphore); 488} 489 490LOADER_EXPORT VkResult VKAPI vkQueueWaitSemaphore(VkQueue queue, VkSemaphore semaphore) 491{ 492 const VkLayerDispatchTable *disp; 493 494 disp = loader_get_dispatch(queue); 495 496 return disp->QueueWaitSemaphore(queue, semaphore); 497} 498 499LOADER_EXPORT VkResult VKAPI vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, VkEvent* pEvent) 500{ 501 const VkLayerDispatchTable *disp; 502 503 disp = loader_get_dispatch(device); 504 505 return disp->CreateEvent(device, pCreateInfo, pEvent); 506} 507 508LOADER_EXPORT VkResult VKAPI vkGetEventStatus(VkDevice device, VkEvent event) 509{ 510 const VkLayerDispatchTable *disp; 511 512 disp = loader_get_dispatch(device); 513 514 return disp->GetEventStatus(device, event); 515} 516 517LOADER_EXPORT VkResult VKAPI vkSetEvent(VkDevice device, VkEvent event) 518{ 519 const VkLayerDispatchTable *disp; 520 521 disp = loader_get_dispatch(device); 522 523 return disp->SetEvent(device, event); 524} 525 526LOADER_EXPORT VkResult VKAPI vkResetEvent(VkDevice device, VkEvent event) 527{ 528 const VkLayerDispatchTable *disp; 529 530 disp = loader_get_dispatch(device); 531 532 return disp->ResetEvent(device, event); 533} 534 535LOADER_EXPORT VkResult VKAPI vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, VkQueryPool* pQueryPool) 536{ 537 const VkLayerDispatchTable *disp; 538 539 disp = loader_get_dispatch(device); 540 541 return disp->CreateQueryPool(device, pCreateInfo, pQueryPool); 542} 543 544LOADER_EXPORT VkResult VKAPI vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, size_t* pDataSize, void* pData, VkQueryResultFlags flags) 545{ 546 const VkLayerDispatchTable *disp; 547 548 disp = loader_get_dispatch(device); 549 550 return disp->GetQueryPoolResults(device, queryPool, startQuery, queryCount, pDataSize, pData, flags); 551} 552 553LOADER_EXPORT VkResult VKAPI vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, VkBuffer* pBuffer) 554{ 555 const VkLayerDispatchTable *disp; 556 557 disp = loader_get_dispatch(device); 558 559 return disp->CreateBuffer(device, pCreateInfo, pBuffer); 560} 561 562LOADER_EXPORT VkResult VKAPI vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, VkBufferView* pView) 563{ 564 const VkLayerDispatchTable *disp; 565 566 disp = loader_get_dispatch(device); 567 568 return disp->CreateBufferView(device, pCreateInfo, pView); 569} 570 571LOADER_EXPORT VkResult VKAPI vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, VkImage* pImage) 572{ 573 const VkLayerDispatchTable *disp; 574 575 disp = loader_get_dispatch(device); 576 577 return disp->CreateImage(device, pCreateInfo, pImage); 578} 579 580LOADER_EXPORT VkResult VKAPI vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) 581{ 582 const VkLayerDispatchTable *disp; 583 584 disp = loader_get_dispatch(device); 585 586 return disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout); 587} 588 589LOADER_EXPORT VkResult VKAPI vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, VkImageView* pView) 590{ 591 const VkLayerDispatchTable *disp; 592 593 disp = loader_get_dispatch(device); 594 595 return disp->CreateImageView(device, pCreateInfo, pView); 596} 597 598LOADER_EXPORT VkResult VKAPI vkCreateColorAttachmentView(VkDevice device, const VkColorAttachmentViewCreateInfo* pCreateInfo, VkColorAttachmentView* pView) 599{ 600 const VkLayerDispatchTable *disp; 601 602 disp = loader_get_dispatch(device); 603 604 return disp->CreateColorAttachmentView(device, pCreateInfo, pView); 605} 606 607LOADER_EXPORT VkResult VKAPI vkCreateDepthStencilView(VkDevice device, const VkDepthStencilViewCreateInfo* pCreateInfo, VkDepthStencilView* pView) 608{ 609 const VkLayerDispatchTable *disp; 610 611 disp = loader_get_dispatch(device); 612 613 return disp->CreateDepthStencilView(device, pCreateInfo, pView); 614} 615 616LOADER_EXPORT VkResult VKAPI vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, VkShaderModule* pShader) 617{ 618 const VkLayerDispatchTable *disp; 619 620 disp = loader_get_dispatch(device); 621 622 return disp->CreateShaderModule(device, pCreateInfo, pShader); 623} 624 625LOADER_EXPORT VkResult VKAPI vkCreateShader(VkDevice device, const VkShaderCreateInfo* pCreateInfo, VkShader* pShader) 626{ 627 const VkLayerDispatchTable *disp; 628 629 disp = loader_get_dispatch(device); 630 631 return disp->CreateShader(device, pCreateInfo, pShader); 632} 633 634LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipeline(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) 635{ 636 const VkLayerDispatchTable *disp; 637 638 disp = loader_get_dispatch(device); 639 640 return disp->CreateGraphicsPipeline(device, pCreateInfo, pPipeline); 641} 642 643LOADER_EXPORT VkResult VKAPI vkCreateGraphicsPipelineDerivative(VkDevice device, const VkGraphicsPipelineCreateInfo* pCreateInfo, VkPipeline basePipeline, VkPipeline* pPipeline) 644{ 645 const VkLayerDispatchTable *disp; 646 647 disp = loader_get_dispatch(device); 648 649 return disp->CreateGraphicsPipelineDerivative(device, pCreateInfo, basePipeline, pPipeline); 650} 651 652LOADER_EXPORT VkResult VKAPI vkCreateComputePipeline(VkDevice device, const VkComputePipelineCreateInfo* pCreateInfo, VkPipeline* pPipeline) 653{ 654 const VkLayerDispatchTable *disp; 655 656 disp = loader_get_dispatch(device); 657 658 return disp->CreateComputePipeline(device, pCreateInfo, pPipeline); 659} 660 661LOADER_EXPORT VkResult VKAPI vkStorePipeline(VkDevice device, VkPipeline pipeline, size_t* pDataSize, void* pData) 662{ 663 const VkLayerDispatchTable *disp; 664 665 disp = loader_get_dispatch(device); 666 667 return disp->StorePipeline(device, pipeline, pDataSize, pData); 668} 669 670LOADER_EXPORT VkResult VKAPI vkLoadPipeline(VkDevice device, size_t dataSize, const void* pData, VkPipeline* pPipeline) 671{ 672 const VkLayerDispatchTable *disp; 673 674 disp = loader_get_dispatch(device); 675 676 return disp->LoadPipeline(device, dataSize, pData, pPipeline); 677} 678 679LOADER_EXPORT VkResult VKAPI vkLoadPipelineDerivative(VkDevice device, size_t dataSize, const void* pData, VkPipeline basePipeline, VkPipeline* pPipeline) 680{ 681 const VkLayerDispatchTable *disp; 682 683 disp = loader_get_dispatch(device); 684 685 return disp->LoadPipelineDerivative(device, dataSize, pData, basePipeline, pPipeline); 686} 687 688LOADER_EXPORT VkResult VKAPI vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, VkPipelineLayout* pPipelineLayout) 689{ 690 const VkLayerDispatchTable *disp; 691 692 disp = loader_get_dispatch(device); 693 694 return disp->CreatePipelineLayout(device, pCreateInfo, pPipelineLayout); 695} 696 697LOADER_EXPORT VkResult VKAPI vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, VkSampler* pSampler) 698{ 699 const VkLayerDispatchTable *disp; 700 701 disp = loader_get_dispatch(device); 702 703 return disp->CreateSampler(device, pCreateInfo, pSampler); 704} 705 706LOADER_EXPORT VkResult VKAPI vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, VkDescriptorSetLayout* pSetLayout) 707{ 708 const VkLayerDispatchTable *disp; 709 710 disp = loader_get_dispatch(device); 711 712 return disp->CreateDescriptorSetLayout(device, pCreateInfo, pSetLayout); 713} 714 715LOADER_EXPORT VkResult VKAPI vkCreateDescriptorPool(VkDevice device, VkDescriptorPoolUsage poolUsage, uint32_t maxSets, const VkDescriptorPoolCreateInfo* pCreateInfo, VkDescriptorPool* pDescriptorPool) 716{ 717 const VkLayerDispatchTable *disp; 718 719 disp = loader_get_dispatch(device); 720 721 return disp->CreateDescriptorPool(device, poolUsage, maxSets, pCreateInfo, pDescriptorPool); 722} 723 724LOADER_EXPORT VkResult VKAPI vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool) 725{ 726 const VkLayerDispatchTable *disp; 727 728 disp = loader_get_dispatch(device); 729 730 return disp->ResetDescriptorPool(device, descriptorPool); 731} 732 733LOADER_EXPORT VkResult VKAPI vkAllocDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorSetUsage setUsage, uint32_t count, const VkDescriptorSetLayout* pSetLayouts, VkDescriptorSet* pDescriptorSets, uint32_t* pCount) 734{ 735 const VkLayerDispatchTable *disp; 736 737 disp = loader_get_dispatch(device); 738 739 return disp->AllocDescriptorSets(device, descriptorPool, setUsage, count, pSetLayouts, pDescriptorSets, pCount); 740} 741 742LOADER_EXPORT VkResult VKAPI vkUpdateDescriptorSets(VkDevice device, uint32_t writeCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t copyCount, const VkCopyDescriptorSet* pDescriptorCopies) 743{ 744 const VkLayerDispatchTable *disp; 745 746 disp = loader_get_dispatch(device); 747 748 return disp->UpdateDescriptorSets(device, writeCount, pDescriptorWrites, copyCount, pDescriptorCopies); 749} 750 751LOADER_EXPORT VkResult VKAPI vkCreateDynamicViewportState(VkDevice device, const VkDynamicVpStateCreateInfo* pCreateInfo, VkDynamicVpState* pState) 752{ 753 const VkLayerDispatchTable *disp; 754 755 disp = loader_get_dispatch(device); 756 757 return disp->CreateDynamicViewportState(device, pCreateInfo, pState); 758} 759 760LOADER_EXPORT VkResult VKAPI vkCreateDynamicRasterState(VkDevice device, const VkDynamicRsStateCreateInfo* pCreateInfo, VkDynamicRsState* pState) 761{ 762 const VkLayerDispatchTable *disp; 763 764 disp = loader_get_dispatch(device); 765 766 return disp->CreateDynamicRasterState(device, pCreateInfo, pState); 767} 768 769LOADER_EXPORT VkResult VKAPI vkCreateDynamicColorBlendState(VkDevice device, const VkDynamicCbStateCreateInfo* pCreateInfo, VkDynamicCbState* pState) 770{ 771 const VkLayerDispatchTable *disp; 772 773 disp = loader_get_dispatch(device); 774 775 return disp->CreateDynamicColorBlendState(device, pCreateInfo, pState); 776} 777 778LOADER_EXPORT VkResult VKAPI vkCreateDynamicDepthStencilState(VkDevice device, const VkDynamicDsStateCreateInfo* pCreateInfo, VkDynamicDsState* pState) 779{ 780 const VkLayerDispatchTable *disp; 781 782 disp = loader_get_dispatch(device); 783 784 return disp->CreateDynamicDepthStencilState(device, pCreateInfo, pState); 785} 786 787LOADER_EXPORT VkResult VKAPI vkCreateCommandBuffer(VkDevice device, const VkCmdBufferCreateInfo* pCreateInfo, VkCmdBuffer* pCmdBuffer) 788{ 789 const VkLayerDispatchTable *disp; 790 VkResult res; 791 792 disp = loader_get_dispatch(device); 793 794 res = disp->CreateCommandBuffer(device, pCreateInfo, pCmdBuffer); 795 if (res == VK_SUCCESS) { 796 loader_init_dispatch(*pCmdBuffer, disp); 797 } 798 799 return res; 800} 801 802LOADER_EXPORT VkResult VKAPI vkBeginCommandBuffer(VkCmdBuffer cmdBuffer, const VkCmdBufferBeginInfo* pBeginInfo) 803{ 804 const VkLayerDispatchTable *disp; 805 806 disp = loader_get_dispatch(cmdBuffer); 807 808 return disp->BeginCommandBuffer(cmdBuffer, pBeginInfo); 809} 810 811LOADER_EXPORT VkResult VKAPI vkEndCommandBuffer(VkCmdBuffer cmdBuffer) 812{ 813 const VkLayerDispatchTable *disp; 814 815 disp = loader_get_dispatch(cmdBuffer); 816 817 return disp->EndCommandBuffer(cmdBuffer); 818} 819 820LOADER_EXPORT VkResult VKAPI vkResetCommandBuffer(VkCmdBuffer cmdBuffer) 821{ 822 const VkLayerDispatchTable *disp; 823 824 disp = loader_get_dispatch(cmdBuffer); 825 826 return disp->ResetCommandBuffer(cmdBuffer); 827} 828 829LOADER_EXPORT void VKAPI vkCmdBindPipeline(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) 830{ 831 const VkLayerDispatchTable *disp; 832 833 disp = loader_get_dispatch(cmdBuffer); 834 835 disp->CmdBindPipeline(cmdBuffer, pipelineBindPoint, pipeline); 836} 837 838LOADER_EXPORT void VKAPI vkCmdBindDynamicStateObject(VkCmdBuffer cmdBuffer, VkStateBindPoint stateBindPoint, VkDynamicStateObject state) 839{ 840 const VkLayerDispatchTable *disp; 841 842 disp = loader_get_dispatch(cmdBuffer); 843 844 disp->CmdBindDynamicStateObject(cmdBuffer, stateBindPoint, state); 845} 846 847LOADER_EXPORT void VKAPI vkCmdBindDescriptorSets(VkCmdBuffer cmdBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t setCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) 848{ 849 const VkLayerDispatchTable *disp; 850 851 disp = loader_get_dispatch(cmdBuffer); 852 853 disp->CmdBindDescriptorSets(cmdBuffer, pipelineBindPoint, layout, firstSet, setCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); 854} 855 856LOADER_EXPORT void VKAPI vkCmdBindVertexBuffers(VkCmdBuffer cmdBuffer, uint32_t startBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) 857{ 858 const VkLayerDispatchTable *disp; 859 860 disp = loader_get_dispatch(cmdBuffer); 861 862 disp->CmdBindVertexBuffers(cmdBuffer, startBinding, bindingCount, pBuffers, pOffsets); 863} 864 865LOADER_EXPORT void VKAPI vkCmdBindIndexBuffer(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) 866{ 867 const VkLayerDispatchTable *disp; 868 869 disp = loader_get_dispatch(cmdBuffer); 870 871 disp->CmdBindIndexBuffer(cmdBuffer, buffer, offset, indexType); 872} 873 874LOADER_EXPORT void VKAPI vkCmdDraw(VkCmdBuffer cmdBuffer, uint32_t firstVertex, uint32_t vertexCount, uint32_t firstInstance, uint32_t instanceCount) 875{ 876 const VkLayerDispatchTable *disp; 877 878 disp = loader_get_dispatch(cmdBuffer); 879 880 disp->CmdDraw(cmdBuffer, firstVertex, vertexCount, firstInstance, instanceCount); 881} 882 883LOADER_EXPORT void VKAPI vkCmdDrawIndexed(VkCmdBuffer cmdBuffer, uint32_t firstIndex, uint32_t indexCount, int32_t vertexOffset, uint32_t firstInstance, uint32_t instanceCount) 884{ 885 const VkLayerDispatchTable *disp; 886 887 disp = loader_get_dispatch(cmdBuffer); 888 889 disp->CmdDrawIndexed(cmdBuffer, firstIndex, indexCount, vertexOffset, firstInstance, instanceCount); 890} 891 892LOADER_EXPORT void VKAPI vkCmdDrawIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) 893{ 894 const VkLayerDispatchTable *disp; 895 896 disp = loader_get_dispatch(cmdBuffer); 897 898 disp->CmdDrawIndirect(cmdBuffer, buffer, offset, count, stride); 899} 900 901LOADER_EXPORT void VKAPI vkCmdDrawIndexedIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t count, uint32_t stride) 902{ 903 const VkLayerDispatchTable *disp; 904 905 disp = loader_get_dispatch(cmdBuffer); 906 907 disp->CmdDrawIndexedIndirect(cmdBuffer, buffer, offset, count, stride); 908} 909 910LOADER_EXPORT void VKAPI vkCmdDispatch(VkCmdBuffer cmdBuffer, uint32_t x, uint32_t y, uint32_t z) 911{ 912 const VkLayerDispatchTable *disp; 913 914 disp = loader_get_dispatch(cmdBuffer); 915 916 disp->CmdDispatch(cmdBuffer, x, y, z); 917} 918 919LOADER_EXPORT void VKAPI vkCmdDispatchIndirect(VkCmdBuffer cmdBuffer, VkBuffer buffer, VkDeviceSize offset) 920{ 921 const VkLayerDispatchTable *disp; 922 923 disp = loader_get_dispatch(cmdBuffer); 924 925 disp->CmdDispatchIndirect(cmdBuffer, buffer, offset); 926} 927 928LOADER_EXPORT void VKAPI vkCmdCopyBuffer(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkBuffer destBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) 929{ 930 const VkLayerDispatchTable *disp; 931 932 disp = loader_get_dispatch(cmdBuffer); 933 934 disp->CmdCopyBuffer(cmdBuffer, srcBuffer, destBuffer, regionCount, pRegions); 935} 936 937LOADER_EXPORT void VKAPI vkCmdCopyImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) 938{ 939 const VkLayerDispatchTable *disp; 940 941 disp = loader_get_dispatch(cmdBuffer); 942 943 disp->CmdCopyImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); 944} 945 946LOADER_EXPORT void VKAPI vkCmdBlitImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkTexFilter filter) 947{ 948 const VkLayerDispatchTable *disp; 949 950 disp = loader_get_dispatch(cmdBuffer); 951 952 disp->CmdBlitImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions, filter); 953} 954 955LOADER_EXPORT void VKAPI vkCmdCopyBufferToImage(VkCmdBuffer cmdBuffer, VkBuffer srcBuffer, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) 956{ 957 const VkLayerDispatchTable *disp; 958 959 disp = loader_get_dispatch(cmdBuffer); 960 961 disp->CmdCopyBufferToImage(cmdBuffer, srcBuffer, destImage, destImageLayout, regionCount, pRegions); 962} 963 964LOADER_EXPORT void VKAPI vkCmdCopyImageToBuffer(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer destBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) 965{ 966 const VkLayerDispatchTable *disp; 967 968 disp = loader_get_dispatch(cmdBuffer); 969 970 disp->CmdCopyImageToBuffer(cmdBuffer, srcImage, srcImageLayout, destBuffer, regionCount, pRegions); 971} 972 973LOADER_EXPORT void VKAPI vkCmdUpdateBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize dataSize, const uint32_t* pData) 974{ 975 const VkLayerDispatchTable *disp; 976 977 disp = loader_get_dispatch(cmdBuffer); 978 979 disp->CmdUpdateBuffer(cmdBuffer, destBuffer, destOffset, dataSize, pData); 980} 981 982LOADER_EXPORT void VKAPI vkCmdFillBuffer(VkCmdBuffer cmdBuffer, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize fillSize, uint32_t data) 983{ 984 const VkLayerDispatchTable *disp; 985 986 disp = loader_get_dispatch(cmdBuffer); 987 988 disp->CmdFillBuffer(cmdBuffer, destBuffer, destOffset, fillSize, data); 989} 990 991LOADER_EXPORT void VKAPI vkCmdClearColorImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) 992{ 993 const VkLayerDispatchTable *disp; 994 995 disp = loader_get_dispatch(cmdBuffer); 996 997 disp->CmdClearColorImage(cmdBuffer, image, imageLayout, pColor, rangeCount, pRanges); 998} 999 1000LOADER_EXPORT void VKAPI vkCmdClearDepthStencilImage(VkCmdBuffer cmdBuffer, VkImage image, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) 1001{ 1002 const VkLayerDispatchTable *disp; 1003 1004 disp = loader_get_dispatch(cmdBuffer); 1005 1006 disp->CmdClearDepthStencilImage(cmdBuffer, image, imageLayout, depth, stencil, rangeCount, pRanges); 1007} 1008 1009LOADER_EXPORT void VKAPI vkCmdClearColorAttachment(VkCmdBuffer cmdBuffer, uint32_t colorAttachment, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rectCount, const VkRect3D* pRects) 1010{ 1011 const VkLayerDispatchTable *disp; 1012 1013 disp = loader_get_dispatch(cmdBuffer); 1014 1015 disp->CmdClearColorAttachment(cmdBuffer, colorAttachment, imageLayout, pColor, rectCount, pRects); 1016} 1017 1018LOADER_EXPORT void VKAPI vkCmdClearDepthStencilAttachment(VkCmdBuffer cmdBuffer, VkImageAspectFlags imageAspectMask, VkImageLayout imageLayout, float depth, uint32_t stencil, uint32_t rectCount, const VkRect3D* pRects) 1019{ 1020 const VkLayerDispatchTable *disp; 1021 1022 disp = loader_get_dispatch(cmdBuffer); 1023 1024 disp->CmdClearDepthStencilAttachment(cmdBuffer, imageAspectMask, imageLayout, depth, stencil, rectCount, pRects); 1025} 1026 1027LOADER_EXPORT void VKAPI vkCmdResolveImage(VkCmdBuffer cmdBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage destImage, VkImageLayout destImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) 1028{ 1029 const VkLayerDispatchTable *disp; 1030 1031 disp = loader_get_dispatch(cmdBuffer); 1032 1033 disp->CmdResolveImage(cmdBuffer, srcImage, srcImageLayout, destImage, destImageLayout, regionCount, pRegions); 1034} 1035 1036LOADER_EXPORT void VKAPI vkCmdSetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) 1037{ 1038 const VkLayerDispatchTable *disp; 1039 1040 disp = loader_get_dispatch(cmdBuffer); 1041 1042 disp->CmdSetEvent(cmdBuffer, event, stageMask); 1043} 1044 1045LOADER_EXPORT void VKAPI vkCmdResetEvent(VkCmdBuffer cmdBuffer, VkEvent event, VkPipelineStageFlags stageMask) 1046{ 1047 const VkLayerDispatchTable *disp; 1048 1049 disp = loader_get_dispatch(cmdBuffer); 1050 1051 disp->CmdResetEvent(cmdBuffer, event, stageMask); 1052} 1053 1054LOADER_EXPORT void VKAPI vkCmdWaitEvents(VkCmdBuffer cmdBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, uint32_t memBarrierCount, const void** ppMemBarriers) 1055{ 1056 const VkLayerDispatchTable *disp; 1057 1058 disp = loader_get_dispatch(cmdBuffer); 1059 1060 disp->CmdWaitEvents(cmdBuffer, eventCount, pEvents, sourceStageMask, destStageMask, memBarrierCount, ppMemBarriers); 1061} 1062 1063LOADER_EXPORT void VKAPI vkCmdPipelineBarrier(VkCmdBuffer cmdBuffer, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags destStageMask, bool32_t byRegion, uint32_t memBarrierCount, const void** ppMemBarriers) 1064{ 1065 const VkLayerDispatchTable *disp; 1066 1067 disp = loader_get_dispatch(cmdBuffer); 1068 1069 disp->CmdPipelineBarrier(cmdBuffer, sourceStageMask, destStageMask, byRegion, memBarrierCount, ppMemBarriers); 1070} 1071 1072LOADER_EXPORT void VKAPI vkCmdBeginQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) 1073{ 1074 const VkLayerDispatchTable *disp; 1075 1076 disp = loader_get_dispatch(cmdBuffer); 1077 1078 disp->CmdBeginQuery(cmdBuffer, queryPool, slot, flags); 1079} 1080 1081LOADER_EXPORT void VKAPI vkCmdEndQuery(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t slot) 1082{ 1083 const VkLayerDispatchTable *disp; 1084 1085 disp = loader_get_dispatch(cmdBuffer); 1086 1087 disp->CmdEndQuery(cmdBuffer, queryPool, slot); 1088} 1089 1090LOADER_EXPORT void VKAPI vkCmdResetQueryPool(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount) 1091{ 1092 const VkLayerDispatchTable *disp; 1093 1094 disp = loader_get_dispatch(cmdBuffer); 1095 1096 disp->CmdResetQueryPool(cmdBuffer, queryPool, startQuery, queryCount); 1097} 1098 1099LOADER_EXPORT void VKAPI vkCmdWriteTimestamp(VkCmdBuffer cmdBuffer, VkTimestampType timestampType, VkBuffer destBuffer, VkDeviceSize destOffset) 1100{ 1101 const VkLayerDispatchTable *disp; 1102 1103 disp = loader_get_dispatch(cmdBuffer); 1104 1105 disp->CmdWriteTimestamp(cmdBuffer, timestampType, destBuffer, destOffset); 1106} 1107 1108LOADER_EXPORT void VKAPI vkCmdCopyQueryPoolResults(VkCmdBuffer cmdBuffer, VkQueryPool queryPool, uint32_t startQuery, uint32_t queryCount, VkBuffer destBuffer, VkDeviceSize destOffset, VkDeviceSize destStride, VkFlags flags) 1109{ 1110 const VkLayerDispatchTable *disp; 1111 1112 disp = loader_get_dispatch(cmdBuffer); 1113 1114 disp->CmdCopyQueryPoolResults(cmdBuffer, queryPool, startQuery, queryCount, destBuffer, destOffset, destStride, flags); 1115} 1116 1117LOADER_EXPORT VkResult VKAPI vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, VkFramebuffer* pFramebuffer) 1118{ 1119 const VkLayerDispatchTable *disp; 1120 1121 disp = loader_get_dispatch(device); 1122 1123 return disp->CreateFramebuffer(device, pCreateInfo, pFramebuffer); 1124} 1125 1126LOADER_EXPORT VkResult VKAPI vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, VkRenderPass* pRenderPass) 1127{ 1128 const VkLayerDispatchTable *disp; 1129 1130 disp = loader_get_dispatch(device); 1131 1132 return disp->CreateRenderPass(device, pCreateInfo, pRenderPass); 1133} 1134 1135LOADER_EXPORT void VKAPI vkCmdBeginRenderPass(VkCmdBuffer cmdBuffer, const VkRenderPassBegin* pRenderPassBegin) 1136{ 1137 const VkLayerDispatchTable *disp; 1138 1139 disp = loader_get_dispatch(cmdBuffer); 1140 1141 disp->CmdBeginRenderPass(cmdBuffer, pRenderPassBegin); 1142} 1143 1144LOADER_EXPORT void VKAPI vkCmdEndRenderPass(VkCmdBuffer cmdBuffer) 1145{ 1146 const VkLayerDispatchTable *disp; 1147 1148 disp = loader_get_dispatch(cmdBuffer); 1149 1150 disp->CmdEndRenderPass(cmdBuffer); 1151} 1152 1153LOADER_EXPORT void VKAPI vkCmdExecuteCommands(VkCmdBuffer cmdBuffer, uint32_t cmdBuffersCount, const VkCmdBuffer* pCmdBuffers) 1154{ 1155 const VkLayerDispatchTable *disp; 1156 1157 disp = loader_get_dispatch(cmdBuffer); 1158 1159 disp->CmdExecuteCommands(cmdBuffer, cmdBuffersCount, pCmdBuffers); 1160} 1161