| /* |
| * |
| * Copyright (C) 2015 Valve Corporation |
| * Copyright (C) 2015 Google Inc. |
| * |
| * Permission is hereby granted, free of charge, to any person obtaining a |
| * copy of this software and associated documentation files (the "Software"), |
| * to deal in the Software without restriction, including without limitation |
| * the rights to use, copy, modify, merge, publish, distribute, sublicense, |
| * and/or sell copies of the Software, and to permit persons to whom the |
| * Software is furnished to do so, subject to the following conditions: |
| * |
| * The above copyright notice and this permission notice shall be included |
| * in all copies or substantial portions of the Software. |
| * |
| * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR |
| * IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, |
| * FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL |
| * THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER |
| * LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING |
| * FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER |
| * DEALINGS IN THE SOFTWARE. |
| * |
| * Author: Chris Forbes <chrisf@ijw.co.nz> |
| * Author: Cody Northrop <cody@lunarg.com> |
| * Author: Jon Ashburn <jon@lunarg.com> |
| * Author: Tony Barbour <tony@LunarG.com> |
| */ |
| #define _GNU_SOURCE |
| #include <stdlib.h> |
| #include <string.h> |
| |
| #include "vk_loader_platform.h" |
| #include "loader.h" |
| #include "debug_report.h" |
| #include "wsi.h" |
| |
| |
| /* Trampoline entrypoints */ |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateInstance( |
| const VkInstanceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkInstance* pInstance) |
| { |
| struct loader_instance *ptr_instance = NULL; |
| VkResult res = VK_ERROR_INITIALIZATION_FAILED; |
| VkDebugReportCallbackEXT instance_callback = VK_NULL_HANDLE; |
| void *pNext = (void *) pCreateInfo->pNext; |
| |
| loader_platform_thread_once(&once_init, loader_initialize); |
| |
| if (pAllocator) { |
| ptr_instance = (struct loader_instance *) pAllocator->pfnAllocation( |
| pAllocator->pUserData, |
| sizeof(struct loader_instance), |
| sizeof(int *), |
| VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); |
| } else { |
| ptr_instance = (struct loader_instance *) malloc(sizeof(struct loader_instance)); |
| } |
| if (ptr_instance == NULL) { |
| return VK_ERROR_OUT_OF_HOST_MEMORY; |
| } |
| |
| tls_instance = ptr_instance; |
| loader_platform_thread_lock_mutex(&loader_lock); |
| memset(ptr_instance, 0, sizeof(struct loader_instance)); |
| |
| if (pAllocator) { |
| ptr_instance->alloc_callbacks = *pAllocator; |
| } |
| |
| /* |
| * Look for a debug report create info structure |
| * and setup a callback if found. |
| */ |
| while (pNext) { |
| if (((VkInstanceCreateInfo *)pNext)->sType == VK_STRUCTURE_TYPE_DEBUG_REPORT_CREATE_INFO_EXT) { |
| instance_callback = (VkDebugReportCallbackEXT) ptr_instance; |
| if (util_CreateDebugReportCallback(ptr_instance, pNext, pAllocator, instance_callback)) { |
| loader_heap_free(ptr_instance, ptr_instance); |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| return VK_ERROR_OUT_OF_HOST_MEMORY; |
| } |
| } |
| pNext = (void *) ((VkInstanceCreateInfo *)pNext)->pNext; |
| } |
| |
| /* Due to implicit layers need to get layer list even if |
| * enabledLayerNameCount == 0 and VK_INSTANCE_LAYERS is unset. For now always |
| * get layer list (both instance and device) via loader_layer_scan(). */ |
| memset(&ptr_instance->instance_layer_list, 0, sizeof(ptr_instance->instance_layer_list)); |
| memset(&ptr_instance->device_layer_list, 0, sizeof(ptr_instance->device_layer_list)); |
| loader_layer_scan(ptr_instance, |
| &ptr_instance->instance_layer_list, |
| &ptr_instance->device_layer_list); |
| |
| /* validate the app requested layers to be enabled */ |
| if (pCreateInfo->enabledLayerNameCount > 0) { |
| res = loader_validate_layers(pCreateInfo->enabledLayerNameCount, |
| pCreateInfo->ppEnabledLayerNames, |
| &ptr_instance->instance_layer_list); |
| if (res != VK_SUCCESS) { |
| util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator); |
| loader_heap_free(ptr_instance, ptr_instance); |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| return res; |
| } |
| } |
| |
| /* Scan/discover all ICD libraries */ |
| memset(&ptr_instance->icd_libs, 0, sizeof(ptr_instance->icd_libs)); |
| loader_icd_scan(ptr_instance, &ptr_instance->icd_libs); |
| |
| /* get extensions from all ICD's, merge so no duplicates, then validate */ |
| loader_get_icd_loader_instance_extensions(ptr_instance, |
| &ptr_instance->icd_libs, |
| &ptr_instance->ext_list); |
| res = loader_validate_instance_extensions(&ptr_instance->ext_list, |
| &ptr_instance->instance_layer_list, |
| pCreateInfo); |
| if (res != VK_SUCCESS) { |
| loader_delete_layer_properties(ptr_instance, |
| &ptr_instance->device_layer_list); |
| loader_delete_layer_properties(ptr_instance, |
| &ptr_instance->instance_layer_list); |
| loader_scanned_icd_clear(ptr_instance, &ptr_instance->icd_libs); |
| loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *) |
| &ptr_instance->ext_list); |
| util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator); |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| loader_heap_free(ptr_instance, ptr_instance); |
| return res; |
| } |
| |
| ptr_instance->disp = loader_heap_alloc( |
| ptr_instance, |
| sizeof(VkLayerInstanceDispatchTable), |
| VK_SYSTEM_ALLOCATION_SCOPE_INSTANCE); |
| if (ptr_instance->disp == NULL) { |
| loader_delete_layer_properties(ptr_instance, |
| &ptr_instance->device_layer_list); |
| loader_delete_layer_properties(ptr_instance, |
| &ptr_instance->instance_layer_list); |
| loader_scanned_icd_clear(ptr_instance, |
| &ptr_instance->icd_libs); |
| loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *) |
| &ptr_instance->ext_list); |
| util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator); |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| loader_heap_free(ptr_instance, ptr_instance); |
| return VK_ERROR_OUT_OF_HOST_MEMORY; |
| } |
| memcpy(ptr_instance->disp, &instance_disp, sizeof(instance_disp)); |
| ptr_instance->next = loader.instances; |
| loader.instances = ptr_instance; |
| |
| /* activate any layers on instance chain */ |
| res = loader_enable_instance_layers(ptr_instance, |
| pCreateInfo, |
| &ptr_instance->instance_layer_list); |
| if (res != VK_SUCCESS) { |
| loader_delete_layer_properties(ptr_instance, |
| &ptr_instance->device_layer_list); |
| loader_delete_layer_properties(ptr_instance, |
| &ptr_instance->instance_layer_list); |
| loader_scanned_icd_clear(ptr_instance, |
| &ptr_instance->icd_libs); |
| loader_destroy_generic_list(ptr_instance, (struct loader_generic_list *) |
| &ptr_instance->ext_list); |
| loader.instances = ptr_instance->next; |
| util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator); |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| loader_heap_free(ptr_instance, ptr_instance->disp); |
| loader_heap_free(ptr_instance, ptr_instance); |
| return res; |
| } |
| loader_activate_instance_layers(ptr_instance); |
| |
| wsi_create_instance(ptr_instance, pCreateInfo); |
| debug_report_create_instance(ptr_instance, pCreateInfo); |
| |
| |
| *pInstance = (VkInstance) ptr_instance; |
| |
| res = ptr_instance->disp->CreateInstance(pCreateInfo, pAllocator, pInstance); |
| |
| /* |
| * Finally have the layers in place and everyone has seen |
| * the CreateInstance command go by. This allows the layer's |
| * GetInstanceProcAddr functions to return valid extension functions |
| * if enabled. |
| */ |
| loader_activate_instance_layer_extensions(ptr_instance); |
| |
| /* Remove temporary debug_report callback */ |
| util_DestroyDebugReportCallback(ptr_instance, instance_callback, pAllocator); |
| |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| return res; |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyInstance( |
| VkInstance instance, |
| const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| struct loader_instance *ptr_instance = NULL; |
| disp = loader_get_instance_dispatch(instance); |
| |
| loader_platform_thread_lock_mutex(&loader_lock); |
| |
| /* TODO: Do we need a temporary callback here to catch cleanup issues? */ |
| |
| ptr_instance = loader_get_instance(instance); |
| disp->DestroyInstance(instance, pAllocator); |
| |
| loader_deactivate_instance_layers(ptr_instance); |
| loader_heap_free(ptr_instance, ptr_instance->disp); |
| loader_heap_free(ptr_instance, ptr_instance); |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumeratePhysicalDevices( |
| VkInstance instance, |
| uint32_t* pPhysicalDeviceCount, |
| VkPhysicalDevice* pPhysicalDevices) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| VkResult res; |
| disp = loader_get_instance_dispatch(instance); |
| |
| loader_platform_thread_lock_mutex(&loader_lock); |
| res = disp->EnumeratePhysicalDevices(instance, pPhysicalDeviceCount, |
| pPhysicalDevices); |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| return res; |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures( |
| VkPhysicalDevice gpu, |
| VkPhysicalDeviceFeatures *pFeatures) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| |
| disp = loader_get_instance_dispatch(gpu); |
| disp->GetPhysicalDeviceFeatures(gpu, pFeatures); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties( |
| VkPhysicalDevice gpu, |
| VkFormat format, |
| VkFormatProperties *pFormatInfo) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| |
| disp = loader_get_instance_dispatch(gpu); |
| disp->GetPhysicalDeviceFormatProperties(gpu, format, pFormatInfo); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, VkImageCreateFlags flags, VkImageFormatProperties* pImageFormatProperties) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| |
| disp = loader_get_instance_dispatch(physicalDevice); |
| return disp->GetPhysicalDeviceImageFormatProperties(physicalDevice, format, type, tiling, usage, flags, pImageFormatProperties); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties( |
| VkPhysicalDevice gpu, |
| VkPhysicalDeviceProperties* pProperties) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| |
| disp = loader_get_instance_dispatch(gpu); |
| disp->GetPhysicalDeviceProperties(gpu, pProperties); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties( |
| VkPhysicalDevice gpu, |
| uint32_t* pQueueFamilyPropertyCount, |
| VkQueueFamilyProperties* pQueueProperties) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| |
| disp = loader_get_instance_dispatch(gpu); |
| disp->GetPhysicalDeviceQueueFamilyProperties(gpu, pQueueFamilyPropertyCount, pQueueProperties); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties( |
| VkPhysicalDevice gpu, |
| VkPhysicalDeviceMemoryProperties* pMemoryProperties) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| |
| disp = loader_get_instance_dispatch(gpu); |
| disp->GetPhysicalDeviceMemoryProperties(gpu, pMemoryProperties); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDevice( |
| VkPhysicalDevice gpu, |
| const VkDeviceCreateInfo* pCreateInfo, |
| const VkAllocationCallbacks* pAllocator, |
| VkDevice* pDevice) |
| { |
| VkResult res; |
| |
| loader_platform_thread_lock_mutex(&loader_lock); |
| |
| res = loader_CreateDevice(gpu, pCreateInfo, pAllocator, pDevice); |
| |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| return res; |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDevice(VkDevice device, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| struct loader_device *dev; |
| struct loader_icd *icd = loader_get_icd_and_device(device, &dev); |
| const struct loader_instance *inst = icd->this_instance; |
| disp = loader_get_dispatch(device); |
| |
| loader_platform_thread_lock_mutex(&loader_lock); |
| disp->DestroyDevice(device, pAllocator); |
| dev->device = NULL; |
| loader_remove_logical_device(inst, icd, dev); |
| |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceExtensionProperties( |
| VkPhysicalDevice physicalDevice, |
| const char* pLayerName, |
| uint32_t* pPropertyCount, |
| VkExtensionProperties* pProperties) |
| { |
| VkResult res; |
| |
| loader_platform_thread_lock_mutex(&loader_lock); |
| |
| /* If pLayerName == NULL, then querying ICD extensions, pass this call |
| down the instance chain which will terminate in the ICD. This allows |
| layers to filter the extensions coming back up the chain. |
| If pLayerName != NULL then get layer extensions from manifest file. */ |
| if (pLayerName == NULL || strlen(pLayerName) == 0) { |
| const VkLayerInstanceDispatchTable *disp; |
| |
| disp = loader_get_instance_dispatch(physicalDevice); |
| res = disp->EnumerateDeviceExtensionProperties(physicalDevice, NULL, pPropertyCount, pProperties); |
| } else { |
| res = loader_EnumerateDeviceExtensionProperties(physicalDevice, pLayerName, pPropertyCount, pProperties); |
| } |
| |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| return res; |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEnumerateDeviceLayerProperties( |
| VkPhysicalDevice physicalDevice, |
| uint32_t* pPropertyCount, |
| VkLayerProperties* pProperties) |
| { |
| VkResult res; |
| |
| loader_platform_thread_lock_mutex(&loader_lock); |
| |
| /* Don't dispatch this call down the instance chain, want all device layers |
| enumerated and instance chain may not contain all device layers */ |
| res = loader_EnumerateDeviceLayerProperties(physicalDevice, pPropertyCount, pProperties); |
| loader_platform_thread_unlock_mutex(&loader_lock); |
| return res; |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceQueue(VkDevice device, uint32_t queueNodeIndex, uint32_t queueIndex, VkQueue* pQueue) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->GetDeviceQueue(device, queueNodeIndex, queueIndex, pQueue); |
| loader_set_dispatch(*pQueue, disp); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueSubmit(VkQueue queue, uint32_t submitCount, const VkSubmitInfo* pSubmits, VkFence fence) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(queue); |
| |
| return disp->QueueSubmit(queue, submitCount, pSubmits, fence); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueWaitIdle(VkQueue queue) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(queue); |
| |
| return disp->QueueWaitIdle(queue); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkDeviceWaitIdle(VkDevice device) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->DeviceWaitIdle(device); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateMemory(VkDevice device, const VkMemoryAllocateInfo* pAllocateInfo, const VkAllocationCallbacks* pAllocator, VkDeviceMemory* pMemory) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->AllocateMemory(device, pAllocateInfo, pAllocator, pMemory); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeMemory(VkDevice device, VkDeviceMemory mem, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->FreeMemory(device, mem, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMapMemory(VkDevice device, VkDeviceMemory mem, VkDeviceSize offset, VkDeviceSize size, VkFlags flags, void** ppData) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->MapMemory(device, mem, offset, size, flags, ppData); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUnmapMemory(VkDevice device, VkDeviceMemory mem) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->UnmapMemory(device, mem); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFlushMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->FlushMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkInvalidateMappedMemoryRanges(VkDevice device, uint32_t memoryRangeCount, const VkMappedMemoryRange* pMemoryRanges) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->InvalidateMappedMemoryRanges(device, memoryRangeCount, pMemoryRanges); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetDeviceMemoryCommitment(VkDevice device, VkDeviceMemory memory, VkDeviceSize* pCommittedMemoryInBytes) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->GetDeviceMemoryCommitment(device, memory, pCommittedMemoryInBytes); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindBufferMemory(VkDevice device, VkBuffer buffer, VkDeviceMemory mem, VkDeviceSize offset) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->BindBufferMemory(device, buffer, mem, offset); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBindImageMemory(VkDevice device, VkImage image, VkDeviceMemory mem, VkDeviceSize offset) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->BindImageMemory(device, image, mem, offset); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetBufferMemoryRequirements(VkDevice device, VkBuffer buffer, VkMemoryRequirements* pMemoryRequirements) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->GetBufferMemoryRequirements(device, buffer, pMemoryRequirements); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageMemoryRequirements(VkDevice device, VkImage image, VkMemoryRequirements* pMemoryRequirements) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->GetImageMemoryRequirements(device, image, pMemoryRequirements); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSparseMemoryRequirements(VkDevice device, VkImage image, uint32_t* pSparseMemoryRequirementCount, VkSparseImageMemoryRequirements* pSparseMemoryRequirements) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->GetImageSparseMemoryRequirements(device, image, pSparseMemoryRequirementCount, pSparseMemoryRequirements); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties(VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkSampleCountFlagBits samples, VkImageUsageFlags usage, VkImageTiling tiling, uint32_t* pPropertyCount, VkSparseImageFormatProperties* pProperties) |
| { |
| const VkLayerInstanceDispatchTable *disp; |
| |
| disp = loader_get_instance_dispatch(physicalDevice); |
| |
| disp->GetPhysicalDeviceSparseImageFormatProperties(physicalDevice, format, type, samples, usage, tiling, pPropertyCount, pProperties); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkQueueBindSparse(VkQueue queue, uint32_t bindInfoCount, const VkBindSparseInfo* pBindInfo, VkFence fence) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(queue); |
| |
| return disp->QueueBindSparse(queue, bindInfoCount, pBindInfo, fence); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFence(VkDevice device, const VkFenceCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFence* pFence) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateFence(device, pCreateInfo, pAllocator, pFence); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFence(VkDevice device, VkFence fence, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyFence(device, fence, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->ResetFences(device, fenceCount, pFences); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetFenceStatus(VkDevice device, VkFence fence) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->GetFenceStatus(device, fence); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkWaitForFences(VkDevice device, uint32_t fenceCount, const VkFence* pFences, VkBool32 waitAll, uint64_t timeout) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->WaitForFences(device, fenceCount, pFences, waitAll, timeout); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSemaphore(VkDevice device, const VkSemaphoreCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSemaphore* pSemaphore) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateSemaphore(device, pCreateInfo, pAllocator, pSemaphore); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySemaphore(VkDevice device, VkSemaphore semaphore, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroySemaphore(device, semaphore, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateEvent(VkDevice device, const VkEventCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkEvent* pEvent) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateEvent(device, pCreateInfo, pAllocator, pEvent); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyEvent(VkDevice device, VkEvent event, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyEvent(device, event, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetEventStatus(VkDevice device, VkEvent event) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->GetEventStatus(device, event); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkSetEvent(VkDevice device, VkEvent event) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->SetEvent(device, event); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetEvent(VkDevice device, VkEvent event) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->ResetEvent(device, event); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateQueryPool(VkDevice device, const VkQueryPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkQueryPool* pQueryPool) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateQueryPool(device, pCreateInfo, pAllocator, pQueryPool); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyQueryPool(VkDevice device, VkQueryPool queryPool, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyQueryPool(device, queryPool, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetQueryPoolResults(VkDevice device, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, size_t dataSize, void* pData, VkDeviceSize stride, VkQueryResultFlags flags) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->GetQueryPoolResults(device, queryPool, firstQuery, queryCount, dataSize, pData, stride, flags); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBuffer(VkDevice device, const VkBufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBuffer* pBuffer) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateBuffer(device, pCreateInfo, pAllocator, pBuffer); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBuffer(VkDevice device, VkBuffer buffer, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyBuffer(device, buffer, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateBufferView(VkDevice device, const VkBufferViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkBufferView* pView) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateBufferView(device, pCreateInfo, pAllocator, pView); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyBufferView(VkDevice device, VkBufferView bufferView, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyBufferView(device, bufferView, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImage(VkDevice device, const VkImageCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImage* pImage) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateImage(device, pCreateInfo, pAllocator, pImage); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImage(VkDevice device, VkImage image, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyImage(device, image, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetImageSubresourceLayout(VkDevice device, VkImage image, const VkImageSubresource* pSubresource, VkSubresourceLayout* pLayout) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->GetImageSubresourceLayout(device, image, pSubresource, pLayout); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateImageView(VkDevice device, const VkImageViewCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkImageView* pView) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateImageView(device, pCreateInfo, pAllocator, pView); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyImageView(VkDevice device, VkImageView imageView, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyImageView(device, imageView, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateShaderModule(VkDevice device, const VkShaderModuleCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkShaderModule* pShader) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateShaderModule(device, pCreateInfo, pAllocator, pShader); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyShaderModule(VkDevice device, VkShaderModule shaderModule, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyShaderModule(device, shaderModule, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineCache(VkDevice device, const VkPipelineCacheCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineCache* pPipelineCache) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreatePipelineCache(device, pCreateInfo, pAllocator, pPipelineCache); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineCache(VkDevice device, VkPipelineCache pipelineCache, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyPipelineCache(device, pipelineCache, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkGetPipelineCacheData(VkDevice device, VkPipelineCache pipelineCache, size_t* pDataSize, void* pData) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->GetPipelineCacheData(device, pipelineCache, pDataSize, pData); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkMergePipelineCaches(VkDevice device, VkPipelineCache dstCache, uint32_t srcCacheCount, const VkPipelineCache* pSrcCaches) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->MergePipelineCaches(device, dstCache, srcCacheCount, pSrcCaches); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateGraphicsPipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkGraphicsPipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateGraphicsPipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateComputePipelines(VkDevice device, VkPipelineCache pipelineCache, uint32_t createInfoCount, const VkComputePipelineCreateInfo* pCreateInfos, const VkAllocationCallbacks* pAllocator, VkPipeline* pPipelines) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateComputePipelines(device, pipelineCache, createInfoCount, pCreateInfos, pAllocator, pPipelines); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipeline(VkDevice device, VkPipeline pipeline, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyPipeline(device, pipeline, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreatePipelineLayout(VkDevice device, const VkPipelineLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkPipelineLayout* pPipelineLayout) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreatePipelineLayout(device, pCreateInfo, pAllocator, pPipelineLayout); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyPipelineLayout(VkDevice device, VkPipelineLayout pipelineLayout, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyPipelineLayout(device, pipelineLayout, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateSampler(VkDevice device, const VkSamplerCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkSampler* pSampler) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateSampler(device, pCreateInfo, pAllocator, pSampler); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroySampler(VkDevice device, VkSampler sampler, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroySampler(device, sampler, pAllocator); |
| } |
| |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorSetLayout(VkDevice device, const VkDescriptorSetLayoutCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorSetLayout* pSetLayout) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateDescriptorSetLayout(device, pCreateInfo, pAllocator, pSetLayout); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorSetLayout(VkDevice device, VkDescriptorSetLayout descriptorSetLayout, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyDescriptorSetLayout(device, descriptorSetLayout, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateDescriptorPool(VkDevice device, const VkDescriptorPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkDescriptorPool* pDescriptorPool) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateDescriptorPool(device, pCreateInfo, pAllocator, pDescriptorPool); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyDescriptorPool(device, descriptorPool, pAllocator); |
| } |
| |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetDescriptorPool(VkDevice device, VkDescriptorPool descriptorPool, VkDescriptorPoolResetFlags flags) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->ResetDescriptorPool(device, descriptorPool, flags); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateDescriptorSets(VkDevice device, const VkDescriptorSetAllocateInfo* pAllocateInfo, VkDescriptorSet* pDescriptorSets) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->AllocateDescriptorSets(device, pAllocateInfo, pDescriptorSets); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkFreeDescriptorSets(VkDevice device, VkDescriptorPool descriptorPool, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->FreeDescriptorSets(device, descriptorPool, descriptorSetCount, pDescriptorSets); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkUpdateDescriptorSets(VkDevice device, uint32_t descriptorWriteCount, const VkWriteDescriptorSet* pDescriptorWrites, uint32_t descriptorCopyCount, const VkCopyDescriptorSet* pDescriptorCopies) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->UpdateDescriptorSets(device, descriptorWriteCount, pDescriptorWrites, descriptorCopyCount, pDescriptorCopies); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateFramebuffer(VkDevice device, const VkFramebufferCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkFramebuffer* pFramebuffer) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateFramebuffer(device, pCreateInfo, pAllocator, pFramebuffer); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyFramebuffer(VkDevice device, VkFramebuffer framebuffer, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyFramebuffer(device, framebuffer, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateRenderPass(VkDevice device, const VkRenderPassCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkRenderPass* pRenderPass) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateRenderPass(device, pCreateInfo, pAllocator, pRenderPass); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyRenderPass(VkDevice device, VkRenderPass renderPass, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyRenderPass(device, renderPass, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkGetRenderAreaGranularity(VkDevice device, VkRenderPass renderPass, VkExtent2D* pGranularity) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->GetRenderAreaGranularity(device, renderPass, pGranularity); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkCreateCommandPool(VkDevice device, const VkCommandPoolCreateInfo* pCreateInfo, const VkAllocationCallbacks* pAllocator, VkCommandPool* pCommandPool) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->CreateCommandPool(device, pCreateInfo, pAllocator, pCommandPool); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkDestroyCommandPool(VkDevice device, VkCommandPool commandPool, const VkAllocationCallbacks* pAllocator) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->DestroyCommandPool(device, commandPool, pAllocator); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandPool(VkDevice device, VkCommandPool commandPool, VkCommandPoolResetFlags flags) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| return disp->ResetCommandPool(device, commandPool, flags); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkAllocateCommandBuffers( |
| VkDevice device, |
| const VkCommandBufferAllocateInfo* pAllocateInfo, |
| VkCommandBuffer* pCommandBuffers) |
| { |
| const VkLayerDispatchTable *disp; |
| VkResult res; |
| |
| disp = loader_get_dispatch(device); |
| |
| res = disp->AllocateCommandBuffers(device, pAllocateInfo, pCommandBuffers); |
| if (res == VK_SUCCESS) { |
| for (uint32_t i =0; i < pAllocateInfo->bufferCount; i++) { |
| if (pCommandBuffers[i]) { |
| loader_init_dispatch(pCommandBuffers[i], disp); |
| } |
| } |
| } |
| |
| return res; |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkFreeCommandBuffers( |
| VkDevice device, |
| VkCommandPool commandPool, |
| uint32_t commandBufferCount, |
| const VkCommandBuffer* pCommandBuffers) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(device); |
| |
| disp->FreeCommandBuffers(device, commandPool, commandBufferCount, pCommandBuffers); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkBeginCommandBuffer(VkCommandBuffer commandBuffer, const VkCommandBufferBeginInfo* pBeginInfo) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| return disp->BeginCommandBuffer(commandBuffer, pBeginInfo); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkEndCommandBuffer(VkCommandBuffer commandBuffer) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| return disp->EndCommandBuffer(commandBuffer); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR VkResult VKAPI_CALL vkResetCommandBuffer(VkCommandBuffer commandBuffer, VkCommandBufferResetFlags flags) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| return disp->ResetCommandBuffer(commandBuffer, flags); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindPipeline(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipeline pipeline) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdBindPipeline(commandBuffer, pipelineBindPoint, pipeline); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetViewport(VkCommandBuffer commandBuffer, uint32_t firstViewport, uint32_t viewportCount, const VkViewport* pViewports) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetViewport(commandBuffer, firstViewport, viewportCount, pViewports); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetScissor(VkCommandBuffer commandBuffer, uint32_t firstScissor, uint32_t scissorCount, const VkRect2D* pScissors) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetScissor(commandBuffer, firstScissor, scissorCount, pScissors); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetLineWidth(VkCommandBuffer commandBuffer, float lineWidth) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetLineWidth(commandBuffer, lineWidth); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBias(VkCommandBuffer commandBuffer, float depthBiasConstantFactor, float depthBiasClamp, float depthBiasSlopeFactor) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetDepthBias(commandBuffer, depthBiasConstantFactor, depthBiasClamp, depthBiasSlopeFactor); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetBlendConstants(VkCommandBuffer commandBuffer, const float blendConstants[4]) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetBlendConstants(commandBuffer, blendConstants); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetDepthBounds(VkCommandBuffer commandBuffer, float minDepthBounds, float maxDepthBounds) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetDepthBounds(commandBuffer, minDepthBounds, maxDepthBounds); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilCompareMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t compareMask) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetStencilCompareMask(commandBuffer, faceMask, compareMask); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilWriteMask(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t writeMask) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetStencilWriteMask(commandBuffer, faceMask, writeMask); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetStencilReference(VkCommandBuffer commandBuffer, VkStencilFaceFlags faceMask, uint32_t reference) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetStencilReference(commandBuffer, faceMask, reference); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindDescriptorSets(VkCommandBuffer commandBuffer, VkPipelineBindPoint pipelineBindPoint, VkPipelineLayout layout, uint32_t firstSet, uint32_t descriptorSetCount, const VkDescriptorSet* pDescriptorSets, uint32_t dynamicOffsetCount, const uint32_t* pDynamicOffsets) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdBindDescriptorSets(commandBuffer, pipelineBindPoint, layout, firstSet, descriptorSetCount, pDescriptorSets, dynamicOffsetCount, pDynamicOffsets); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindIndexBuffer(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, VkIndexType indexType) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdBindIndexBuffer(commandBuffer, buffer, offset, indexType); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBindVertexBuffers(VkCommandBuffer commandBuffer, uint32_t firstBinding, uint32_t bindingCount, const VkBuffer* pBuffers, const VkDeviceSize* pOffsets) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdBindVertexBuffers(commandBuffer, firstBinding, bindingCount, pBuffers, pOffsets); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDraw(VkCommandBuffer commandBuffer, uint32_t vertexCount, uint32_t instanceCount, uint32_t firstVertex, uint32_t firstInstance) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdDraw(commandBuffer, vertexCount, instanceCount, firstVertex, firstInstance); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexed(VkCommandBuffer commandBuffer, uint32_t indexCount, uint32_t instanceCount, uint32_t firstIndex, int32_t vertexOffset, uint32_t firstInstance) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdDrawIndexed(commandBuffer, indexCount, instanceCount, firstIndex, vertexOffset, firstInstance); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdDrawIndirect(commandBuffer, buffer, offset, drawCount, stride); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, uint32_t drawCount, uint32_t stride) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdDrawIndexedIndirect(commandBuffer, buffer, offset, drawCount, stride); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatch(VkCommandBuffer commandBuffer, uint32_t x, uint32_t y, uint32_t z) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdDispatch(commandBuffer, x, y, z); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdDispatchIndirect(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdDispatchIndirect(commandBuffer, buffer, offset); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBuffer(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferCopy* pRegions) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdCopyBuffer(commandBuffer, srcBuffer, dstBuffer, regionCount, pRegions); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageCopy* pRegions) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdCopyImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBlitImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageBlit* pRegions, VkFilter filter) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdBlitImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions, filter); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyBufferToImage(VkCommandBuffer commandBuffer, VkBuffer srcBuffer, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkBufferImageCopy* pRegions) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdCopyBufferToImage(commandBuffer, srcBuffer, dstImage, dstImageLayout, regionCount, pRegions); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyImageToBuffer(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkBuffer dstBuffer, uint32_t regionCount, const VkBufferImageCopy* pRegions) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdCopyImageToBuffer(commandBuffer, srcImage, srcImageLayout, dstBuffer, regionCount, pRegions); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdUpdateBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize dataSize, const uint32_t* pData) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdUpdateBuffer(commandBuffer, dstBuffer, dstOffset, dataSize, pData); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdFillBuffer(VkCommandBuffer commandBuffer, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize size, uint32_t data) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdFillBuffer(commandBuffer, dstBuffer, dstOffset, size, data); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearColorImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearColorValue* pColor, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdClearColorImage(commandBuffer, image, imageLayout, pColor, rangeCount, pRanges); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearDepthStencilImage(VkCommandBuffer commandBuffer, VkImage image, VkImageLayout imageLayout, const VkClearDepthStencilValue* pDepthStencil, uint32_t rangeCount, const VkImageSubresourceRange* pRanges) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdClearDepthStencilImage(commandBuffer, image, imageLayout, pDepthStencil, rangeCount, pRanges); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdClearAttachments(VkCommandBuffer commandBuffer, uint32_t attachmentCount, const VkClearAttachment* pAttachments, uint32_t rectCount, const VkClearRect* pRects) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdClearAttachments(commandBuffer, attachmentCount, pAttachments, rectCount, pRects); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResolveImage(VkCommandBuffer commandBuffer, VkImage srcImage, VkImageLayout srcImageLayout, VkImage dstImage, VkImageLayout dstImageLayout, uint32_t regionCount, const VkImageResolve* pRegions) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdResolveImage(commandBuffer, srcImage, srcImageLayout, dstImage, dstImageLayout, regionCount, pRegions); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdSetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdSetEvent(commandBuffer, event, stageMask); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetEvent(VkCommandBuffer commandBuffer, VkEvent event, VkPipelineStageFlags stageMask) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdResetEvent(commandBuffer, event, stageMask); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWaitEvents(VkCommandBuffer commandBuffer, uint32_t eventCount, const VkEvent* pEvents, VkPipelineStageFlags sourceStageMask, VkPipelineStageFlags dstStageMask, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdWaitEvents(commandBuffer, eventCount, pEvents, sourceStageMask, dstStageMask, memoryBarrierCount, ppMemoryBarriers); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPipelineBarrier(VkCommandBuffer commandBuffer, VkPipelineStageFlags srcStageMask, VkPipelineStageFlags dstStageMask, VkDependencyFlags dependencyFlags, uint32_t memoryBarrierCount, const void* const* ppMemoryBarriers) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdPipelineBarrier(commandBuffer, srcStageMask, dstStageMask, dependencyFlags, memoryBarrierCount, ppMemoryBarriers); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot, VkFlags flags) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdBeginQuery(commandBuffer, queryPool, slot, flags); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndQuery(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t slot) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdEndQuery(commandBuffer, queryPool, slot); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdResetQueryPool(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdResetQueryPool(commandBuffer, queryPool, firstQuery, queryCount); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdWriteTimestamp(VkCommandBuffer commandBuffer, VkPipelineStageFlagBits pipelineStage, VkQueryPool queryPool, uint32_t slot) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdWriteTimestamp(commandBuffer, pipelineStage, queryPool, slot); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdCopyQueryPoolResults(VkCommandBuffer commandBuffer, VkQueryPool queryPool, uint32_t firstQuery, uint32_t queryCount, VkBuffer dstBuffer, VkDeviceSize dstOffset, VkDeviceSize stride, VkFlags flags) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdCopyQueryPoolResults(commandBuffer, queryPool, firstQuery, queryCount, dstBuffer, dstOffset, stride, flags); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdPushConstants(VkCommandBuffer commandBuffer, VkPipelineLayout layout, VkShaderStageFlags stageFlags, uint32_t offset, uint32_t size, const void* pValues) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdPushConstants(commandBuffer, layout, stageFlags, offset, size, pValues); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdBeginRenderPass(VkCommandBuffer commandBuffer, const VkRenderPassBeginInfo* pRenderPassBegin, VkSubpassContents contents) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdBeginRenderPass(commandBuffer, pRenderPassBegin, contents); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdNextSubpass(VkCommandBuffer commandBuffer, VkSubpassContents contents) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdNextSubpass(commandBuffer, contents); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdEndRenderPass(VkCommandBuffer commandBuffer) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdEndRenderPass(commandBuffer); |
| } |
| |
| LOADER_EXPORT VKAPI_ATTR void VKAPI_CALL vkCmdExecuteCommands(VkCommandBuffer commandBuffer, uint32_t commandBuffersCount, const VkCommandBuffer* pCommandBuffers) |
| { |
| const VkLayerDispatchTable *disp; |
| |
| disp = loader_get_dispatch(commandBuffer); |
| |
| disp->CmdExecuteCommands(commandBuffer, commandBuffersCount, pCommandBuffers); |
| } |