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