| /* |
| * Copyright (c) 2015-2016 The Khronos Group Inc. |
| * Copyright (c) 2015-2016 Valve Corporation |
| * Copyright (c) 2015-2016 LunarG, Inc. |
| * |
| * Licensed under the Apache License, Version 2.0 (the "License"); |
| * you may not use this file except in compliance with the License. |
| * You may obtain a copy of the License at |
| * |
| * http://www.apache.org/licenses/LICENSE-2.0 |
| * |
| * Unless required by applicable law or agreed to in writing, software |
| * distributed under the License is distributed on an "AS IS" BASIS, |
| * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. |
| * See the License for the specific language governing permissions and |
| * limitations under the License. |
| * |
| * Author: Mark Lobodzinski <mark@lunarg.com> |
| */ |
| |
| #define _GNU_SOURCE |
| #include <stdio.h> |
| #include <stdlib.h> |
| #include <string.h> |
| #include "vk_loader_platform.h" |
| #include "loader.h" |
| #include "extensions.h" |
| #include "table_ops.h" |
| #include <vulkan/vk_icd.h> |
| #include "wsi.h" |
| |
| // Definitions for the VK_KHR_get_physical_device_properties2 extension |
| |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures2KHR *pFeatures) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| disp->GetPhysicalDeviceFeatures2KHR(unwrapped_phys_dev, pFeatures); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFeatures2KHR(VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceFeatures2KHR *pFeatures) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetPhysicalDeviceFeatures2KHR) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceFeatures2KHR"); |
| } |
| icd_term->GetPhysicalDeviceFeatures2KHR(phys_dev_term->phys_dev, pFeatures); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties2KHR *pProperties) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| disp->GetPhysicalDeviceProperties2KHR(unwrapped_phys_dev, pProperties); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceProperties2KHR(VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceProperties2KHR *pProperties) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetPhysicalDeviceProperties2KHR) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceProperties2KHR"); |
| } |
| icd_term->GetPhysicalDeviceProperties2KHR(phys_dev_term->phys_dev, pProperties); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, |
| VkFormatProperties2KHR *pFormatProperties) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| disp->GetPhysicalDeviceFormatProperties2KHR(unwrapped_phys_dev, format, pFormatProperties); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceFormatProperties2KHR(VkPhysicalDevice physicalDevice, VkFormat format, |
| VkFormatProperties2KHR *pFormatProperties) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetPhysicalDeviceFormatProperties2KHR) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceFormatProperties2KHR"); |
| } |
| icd_term->GetPhysicalDeviceFormatProperties2KHR(phys_dev_term->phys_dev, format, pFormatProperties); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceImageFormatProperties2KHR( |
| VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo, |
| VkImageFormatProperties2KHR *pImageFormatProperties) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| return disp->GetPhysicalDeviceImageFormatProperties2KHR(unwrapped_phys_dev, pImageFormatInfo, pImageFormatProperties); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceImageFormatProperties2KHR( |
| VkPhysicalDevice physicalDevice, const VkPhysicalDeviceImageFormatInfo2KHR *pImageFormatInfo, |
| VkImageFormatProperties2KHR *pImageFormatProperties) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetPhysicalDeviceImageFormatProperties2KHR) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceImageFormatProperties2KHR"); |
| } |
| return icd_term->GetPhysicalDeviceImageFormatProperties2KHR(phys_dev_term->phys_dev, pImageFormatInfo, pImageFormatProperties); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceQueueFamilyProperties2KHR(VkPhysicalDevice physicalDevice, |
| uint32_t *pQueueFamilyPropertyCount, |
| VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| disp->GetPhysicalDeviceQueueFamilyProperties2KHR(unwrapped_phys_dev, pQueueFamilyPropertyCount, pQueueFamilyProperties); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceQueueFamilyProperties2KHR( |
| VkPhysicalDevice physicalDevice, uint32_t *pQueueFamilyPropertyCount, VkQueueFamilyProperties2KHR *pQueueFamilyProperties) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetPhysicalDeviceQueueFamilyProperties2KHR) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceQueueFamilyProperties2KHR"); |
| } |
| icd_term->GetPhysicalDeviceQueueFamilyProperties2KHR(phys_dev_term->phys_dev, pQueueFamilyPropertyCount, |
| pQueueFamilyProperties); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceMemoryProperties2KHR(VkPhysicalDevice physicalDevice, |
| VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| disp->GetPhysicalDeviceMemoryProperties2KHR(unwrapped_phys_dev, pMemoryProperties); |
| } |
| VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceMemoryProperties2KHR( |
| VkPhysicalDevice physicalDevice, VkPhysicalDeviceMemoryProperties2KHR *pMemoryProperties) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetPhysicalDeviceMemoryProperties2KHR) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceMemoryProperties2KHR"); |
| } |
| icd_term->GetPhysicalDeviceMemoryProperties2KHR(phys_dev_term->phys_dev, pMemoryProperties); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceSparseImageFormatProperties2KHR( |
| VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, |
| VkSparseImageFormatProperties2KHR *pProperties) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| disp->GetPhysicalDeviceSparseImageFormatProperties2KHR(unwrapped_phys_dev, pFormatInfo, pPropertyCount, pProperties); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceSparseImageFormatProperties2KHR( |
| VkPhysicalDevice physicalDevice, const VkPhysicalDeviceSparseImageFormatInfo2KHR *pFormatInfo, uint32_t *pPropertyCount, |
| VkSparseImageFormatProperties2KHR *pProperties) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetPhysicalDeviceSparseImageFormatProperties2KHR) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceSparseImageFormatProperties2KHR"); |
| } |
| icd_term->GetPhysicalDeviceSparseImageFormatProperties2KHR(phys_dev_term->phys_dev, pFormatInfo, pPropertyCount, pProperties); |
| } |
| |
| // Definitions for the VK_KHR_maintenance1 extension |
| |
| VKAPI_ATTR void VKAPI_CALL vkTrimCommandPoolKHR(VkDevice device, VkCommandPool commandPool, VkCommandPoolTrimFlagsKHR flags) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| disp->TrimCommandPoolKHR(device, commandPool, flags); |
| } |
| |
| // Definitions for the VK_EXT_acquire_xlib_display extension |
| |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| VKAPI_ATTR VkResult VKAPI_CALL vkAcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, VkDisplayKHR display) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| return disp->AcquireXlibDisplayEXT(unwrapped_phys_dev, dpy, display); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL terminator_AcquireXlibDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, |
| VkDisplayKHR display) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->AcquireXlibDisplayEXT) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkAcquireXlibDisplayEXT"); |
| } |
| return icd_term->AcquireXlibDisplayEXT(phys_dev_term->phys_dev, dpy, display); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, |
| VkDisplayKHR *pDisplay) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| return disp->GetRandROutputDisplayEXT(unwrapped_phys_dev, dpy, rrOutput, pDisplay); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL terminator_GetRandROutputDisplayEXT(VkPhysicalDevice physicalDevice, Display *dpy, RROutput rrOutput, |
| VkDisplayKHR *pDisplay) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetRandROutputDisplayEXT) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetRandROutputDisplayEXT"); |
| } |
| return icd_term->GetRandROutputDisplayEXT(phys_dev_term->phys_dev, dpy, rrOutput, pDisplay); |
| } |
| #endif /* VK_USE_PLATFORM_XLIB_XRANDR_EXT */ |
| |
| // Definitions for the VK_EXT_debug_marker extension commands which |
| // need to have a terminator function |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| // If this is a physical device, we have to replace it with the proper one |
| // for the next call. |
| if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) { |
| struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pTagInfo->object; |
| pTagInfo->object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev; |
| } |
| return disp->DebugMarkerSetObjectTagEXT(device, pTagInfo); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectTagEXT(VkDevice device, VkDebugMarkerObjectTagInfoEXT *pTagInfo) { |
| uint32_t icd_index = 0; |
| struct loader_device *dev; |
| struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index); |
| if (NULL != icd_term && NULL != icd_term->DebugMarkerSetObjectTagEXT) { |
| // If this is a physical device, we have to replace it with the proper |
| // one for the next call. |
| if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pTagInfo->object; |
| pTagInfo->object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev; |
| |
| // If this is a KHR_surface, and the ICD has created its own, we |
| // have to replace it with the proper one for the next call. |
| } else if (pTagInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) { |
| if (NULL != icd_term && NULL != icd_term->CreateSwapchainKHR) { |
| VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pTagInfo->object; |
| if (NULL != icd_surface->real_icd_surfaces) { |
| pTagInfo->object = (uint64_t)icd_surface->real_icd_surfaces[icd_index]; |
| } |
| } |
| } |
| return icd_term->DebugMarkerSetObjectTagEXT(device, pTagInfo); |
| } else { |
| return VK_SUCCESS; |
| } |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkDebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| // If this is a physical device, we have to replace it with the proper one |
| // for the next call. |
| if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) { |
| struct loader_physical_device_tramp *phys_dev_tramp = (struct loader_physical_device_tramp *)(uintptr_t)pNameInfo->object; |
| pNameInfo->object = (uint64_t)(uintptr_t)phys_dev_tramp->phys_dev; |
| } |
| return disp->DebugMarkerSetObjectNameEXT(device, pNameInfo); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL terminator_DebugMarkerSetObjectNameEXT(VkDevice device, VkDebugMarkerObjectNameInfoEXT *pNameInfo) { |
| uint32_t icd_index = 0; |
| struct loader_device *dev; |
| struct loader_icd_term *icd_term = loader_get_icd_and_device(device, &dev, &icd_index); |
| if (NULL != icd_term && NULL != icd_term->DebugMarkerSetObjectNameEXT) { |
| // If this is a physical device, we have to replace it with the proper |
| // one for the next call. |
| if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_PHYSICAL_DEVICE_EXT) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)(uintptr_t)pNameInfo->object; |
| pNameInfo->object = (uint64_t)(uintptr_t)phys_dev_term->phys_dev; |
| |
| // If this is a KHR_surface, and the ICD has created its own, we |
| // have to replace it with the proper one for the next call. |
| } else if (pNameInfo->objectType == VK_DEBUG_REPORT_OBJECT_TYPE_SURFACE_KHR_EXT) { |
| if (NULL != icd_term && NULL != icd_term->CreateSwapchainKHR) { |
| VkIcdSurface *icd_surface = (VkIcdSurface *)(uintptr_t)pNameInfo->object; |
| if (NULL != icd_surface->real_icd_surfaces) { |
| pNameInfo->object = (uint64_t)(uintptr_t)icd_surface->real_icd_surfaces[icd_index]; |
| } |
| } |
| } |
| return icd_term->DebugMarkerSetObjectNameEXT(device, pNameInfo); |
| } else { |
| return VK_SUCCESS; |
| } |
| } |
| |
| // Definitions for the VK_EXT_direct_mode_display extension |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| return disp->ReleaseDisplayEXT(unwrapped_phys_dev, display); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL terminator_ReleaseDisplayEXT(VkPhysicalDevice physicalDevice, VkDisplayKHR display) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->ReleaseDisplayEXT) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkReleaseDisplayEXT"); |
| } |
| return icd_term->ReleaseDisplayEXT(phys_dev_term->phys_dev, display); |
| } |
| |
| // Definitions for the VK_EXT_display_surface_counter extension |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceSurfaceCapabilities2EXT(VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, |
| VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| return disp->GetPhysicalDeviceSurfaceCapabilities2EXT(unwrapped_phys_dev, surface, pSurfaceCapabilities); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceSurfaceCapabilities2EXT( |
| VkPhysicalDevice physicalDevice, VkSurfaceKHR surface, VkSurfaceCapabilities2EXT *pSurfaceCapabilities) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL != icd_term) { |
| if (NULL == icd_term->GetPhysicalDeviceSurfaceCapabilities2EXT) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceSurfaceCapabilities2EXT"); |
| } |
| VkIcdSurface *icd_surface = (VkIcdSurface *)(surface); |
| uint8_t icd_index = phys_dev_term->icd_index; |
| if (NULL != icd_surface->real_icd_surfaces) { |
| if (NULL != (void *)icd_surface->real_icd_surfaces[icd_index]) { |
| return icd_term->GetPhysicalDeviceSurfaceCapabilities2EXT( |
| phys_dev_term->phys_dev, icd_surface->real_icd_surfaces[icd_index], pSurfaceCapabilities); |
| } |
| } |
| } |
| return icd_term->GetPhysicalDeviceSurfaceCapabilities2EXT(phys_dev_term->phys_dev, surface, pSurfaceCapabilities); |
| } |
| |
| // Definitions for the VK_AMD_draw_indirect_count extension |
| |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, |
| VkBuffer countBuffer, VkDeviceSize countBufferOffset, uint32_t maxDrawCount, |
| uint32_t stride) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); |
| disp->CmdDrawIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkCmdDrawIndexedIndirectCountAMD(VkCommandBuffer commandBuffer, VkBuffer buffer, VkDeviceSize offset, |
| VkBuffer countBuffer, VkDeviceSize countBufferOffset, |
| uint32_t maxDrawCount, uint32_t stride) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); |
| disp->CmdDrawIndexedIndirectCountAMD(commandBuffer, buffer, offset, countBuffer, countBufferOffset, maxDrawCount, stride); |
| } |
| |
| // Definitions for the VK_NV_external_memory_capabilities extension |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetPhysicalDeviceExternalImageFormatPropertiesNV( |
| VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, |
| VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, |
| VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| |
| return disp->GetPhysicalDeviceExternalImageFormatPropertiesNV(unwrapped_phys_dev, format, type, tiling, usage, flags, |
| externalHandleType, pExternalImageFormatProperties); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL terminator_GetPhysicalDeviceExternalImageFormatPropertiesNV( |
| VkPhysicalDevice physicalDevice, VkFormat format, VkImageType type, VkImageTiling tiling, VkImageUsageFlags usage, |
| VkImageCreateFlags flags, VkExternalMemoryHandleTypeFlagsNV externalHandleType, |
| VkExternalImageFormatPropertiesNV *pExternalImageFormatProperties) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| |
| if (!icd_term->GetPhysicalDeviceExternalImageFormatPropertiesNV) { |
| if (externalHandleType) { |
| return VK_ERROR_FORMAT_NOT_SUPPORTED; |
| } |
| |
| if (!icd_term->GetPhysicalDeviceImageFormatProperties) { |
| return VK_ERROR_INITIALIZATION_FAILED; |
| } |
| |
| pExternalImageFormatProperties->externalMemoryFeatures = 0; |
| pExternalImageFormatProperties->exportFromImportedHandleTypes = 0; |
| pExternalImageFormatProperties->compatibleHandleTypes = 0; |
| |
| return icd_term->GetPhysicalDeviceImageFormatProperties(phys_dev_term->phys_dev, format, type, tiling, usage, flags, |
| &pExternalImageFormatProperties->imageFormatProperties); |
| } |
| |
| return icd_term->GetPhysicalDeviceExternalImageFormatPropertiesNV(phys_dev_term->phys_dev, format, type, tiling, usage, flags, |
| externalHandleType, pExternalImageFormatProperties); |
| } |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| // Definitions for the VK_NV_external_memory_win32 extension |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkGetMemoryWin32HandleNV(VkDevice device, VkDeviceMemory memory, |
| VkExternalMemoryHandleTypeFlagsNV handleType, HANDLE *pHandle) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| return disp->GetMemoryWin32HandleNV(device, memory, handleType, pHandle); |
| } |
| |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| // Definitions for the VK_NVX_device_generated_commands |
| |
| VKAPI_ATTR void VKAPI_CALL vkCmdProcessCommandsNVX(VkCommandBuffer commandBuffer, |
| const VkCmdProcessCommandsInfoNVX *pProcessCommandsInfo) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); |
| disp->CmdProcessCommandsNVX(commandBuffer, pProcessCommandsInfo); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkCmdReserveSpaceForCommandsNVX(VkCommandBuffer commandBuffer, |
| const VkCmdReserveSpaceForCommandsInfoNVX *pReserveSpaceInfo) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(commandBuffer); |
| disp->CmdReserveSpaceForCommandsNVX(commandBuffer, pReserveSpaceInfo); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateIndirectCommandsLayoutNVX(VkDevice device, |
| const VkIndirectCommandsLayoutCreateInfoNVX *pCreateInfo, |
| const VkAllocationCallbacks *pAllocator, |
| VkIndirectCommandsLayoutNVX *pIndirectCommandsLayout) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| return disp->CreateIndirectCommandsLayoutNVX(device, pCreateInfo, pAllocator, pIndirectCommandsLayout); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkDestroyIndirectCommandsLayoutNVX(VkDevice device, VkIndirectCommandsLayoutNVX indirectCommandsLayout, |
| const VkAllocationCallbacks *pAllocator) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| disp->DestroyIndirectCommandsLayoutNVX(device, indirectCommandsLayout, pAllocator); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkCreateObjectTableNVX(VkDevice device, const VkObjectTableCreateInfoNVX *pCreateInfo, |
| const VkAllocationCallbacks *pAllocator, VkObjectTableNVX *pObjectTable) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| return disp->CreateObjectTableNVX(device, pCreateInfo, pAllocator, pObjectTable); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkDestroyObjectTableNVX(VkDevice device, VkObjectTableNVX objectTable, |
| const VkAllocationCallbacks *pAllocator) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| disp->DestroyObjectTableNVX(device, objectTable, pAllocator); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkRegisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, |
| const VkObjectTableEntryNVX *const *ppObjectTableEntries, |
| const uint32_t *pObjectIndices) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| return disp->RegisterObjectsNVX(device, objectTable, objectCount, ppObjectTableEntries, pObjectIndices); |
| } |
| |
| VKAPI_ATTR VkResult VKAPI_CALL vkUnregisterObjectsNVX(VkDevice device, VkObjectTableNVX objectTable, uint32_t objectCount, |
| const VkObjectEntryTypeNVX *pObjectEntryTypes, |
| const uint32_t *pObjectIndices) { |
| const VkLayerDispatchTable *disp = loader_get_dispatch(device); |
| return disp->UnregisterObjectsNVX(device, objectTable, objectCount, pObjectEntryTypes, pObjectIndices); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX(VkPhysicalDevice physicalDevice, |
| VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, |
| VkDeviceGeneratedCommandsLimitsNVX *pLimits) { |
| const VkLayerInstanceDispatchTable *disp; |
| VkPhysicalDevice unwrapped_phys_dev = loader_unwrap_physical_device(physicalDevice); |
| disp = loader_get_instance_layer_dispatch(physicalDevice); |
| disp->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(unwrapped_phys_dev, pFeatures, pLimits); |
| } |
| |
| VKAPI_ATTR void VKAPI_CALL terminator_GetPhysicalDeviceGeneratedCommandsPropertiesNVX( |
| VkPhysicalDevice physicalDevice, VkDeviceGeneratedCommandsFeaturesNVX *pFeatures, VkDeviceGeneratedCommandsLimitsNVX *pLimits) { |
| struct loader_physical_device_term *phys_dev_term = (struct loader_physical_device_term *)physicalDevice; |
| struct loader_icd_term *icd_term = phys_dev_term->this_icd_term; |
| if (NULL == icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX) { |
| loader_log(icd_term->this_instance, VK_DEBUG_REPORT_ERROR_BIT_EXT, 0, |
| "ICD associated with VkPhysicalDevice does not support " |
| "vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX"); |
| } else { |
| icd_term->GetPhysicalDeviceGeneratedCommandsPropertiesNVX(phys_dev_term->phys_dev, pFeatures, pLimits); |
| } |
| } |
| |
| // GPA helpers for extensions |
| |
| bool extension_instance_gpa(struct loader_instance *ptr_instance, const char *name, void **addr) { |
| *addr = NULL; |
| |
| // Functions for the VK_KHR_get_physical_device_properties2 extension |
| |
| if (!strcmp("vkGetPhysicalDeviceFeatures2KHR", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1) |
| ? (void *)vkGetPhysicalDeviceFeatures2KHR |
| : NULL; |
| return true; |
| } |
| if (!strcmp("vkGetPhysicalDeviceProperties2KHR", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1) |
| ? (void *)vkGetPhysicalDeviceProperties2KHR |
| : NULL; |
| return true; |
| } |
| if (!strcmp("vkGetPhysicalDeviceFormatProperties2KHR", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1) |
| ? (void *)vkGetPhysicalDeviceFormatProperties2KHR |
| : NULL; |
| return true; |
| } |
| if (!strcmp("vkGetPhysicalDeviceImageFormatProperties2KHR", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1) |
| ? (void *)vkGetPhysicalDeviceImageFormatProperties2KHR |
| : NULL; |
| return true; |
| } |
| if (!strcmp("vkGetPhysicalDeviceQueueFamilyProperties2KHR", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1) |
| ? (void *)vkGetPhysicalDeviceQueueFamilyProperties2KHR |
| : NULL; |
| return true; |
| } |
| if (!strcmp("vkGetPhysicalDeviceMemoryProperties2KHR", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1) |
| ? (void *)vkGetPhysicalDeviceMemoryProperties2KHR |
| : NULL; |
| return true; |
| } |
| if (!strcmp("vkGetPhysicalDeviceSparseImageFormatProperties2KHR", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 == 1) |
| ? (void *)vkGetPhysicalDeviceSparseImageFormatProperties2KHR |
| : NULL; |
| return true; |
| } |
| |
| // Functions for the VK_KHR_maintenance1 extension |
| |
| if (!strcmp("vkTrimCommandPoolKHR", name)) { |
| *addr = (void *)vkTrimCommandPoolKHR; |
| return true; |
| } |
| |
| // Functions for the VK_EXT_acquire_xlib_display extension |
| |
| #ifdef VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| if (!strcmp("vkAcquireXlibDisplayEXT", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display == 1) ? (void *)vkAcquireXlibDisplayEXT : NULL; |
| return true; |
| } |
| |
| if (!strcmp("vkGetRandROutputDisplayEXT", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.ext_acquire_xlib_display == 1) ? (void *)vkGetRandROutputDisplayEXT : NULL; |
| return true; |
| } |
| |
| #endif // VK_USE_PLATFORM_XLIB_XRANDR_EXT |
| |
| // Definitions for the VK_EXT_debug_marker extension commands which |
| // need to have a terminator function. Since these are device |
| // commands, we always need to return a valid value for them. |
| |
| if (!strcmp("vkDebugMarkerSetObjectTagEXT", name)) { |
| *addr = (void *)vkDebugMarkerSetObjectTagEXT; |
| return true; |
| } |
| if (!strcmp("vkDebugMarkerSetObjectNameEXT", name)) { |
| *addr = (void *)vkDebugMarkerSetObjectNameEXT; |
| return true; |
| } |
| |
| // Functions for the VK_EXT_direct_mode_display extension |
| |
| if (!strcmp("vkReleaseDisplayEXT", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.ext_direct_mode_display == 1) ? (void *)vkReleaseDisplayEXT : NULL; |
| return true; |
| } |
| |
| // Functions for the VK_EXT_display_surface_counter extension |
| |
| if (!strcmp("vkGetPhysicalDeviceSurfaceCapabilities2EXT", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.ext_display_surface_counter == 1) |
| ? (void *)vkGetPhysicalDeviceSurfaceCapabilities2EXT |
| : NULL; |
| return true; |
| } |
| |
| // Functions for the VK_AMD_draw_indirect_count extension |
| |
| if (!strcmp("vkCmdDrawIndirectCountAMD", name)) { |
| *addr = (void *)vkCmdDrawIndirectCountAMD; |
| return true; |
| } |
| if (!strcmp("vkCmdDrawIndexedIndirectCountAMD", name)) { |
| *addr = (void *)vkCmdDrawIndexedIndirectCountAMD; |
| return true; |
| } |
| // Functions for the VK_NV_external_memory_capabilities extension |
| |
| if (!strcmp("vkGetPhysicalDeviceExternalImageFormatPropertiesNV", name)) { |
| *addr = (ptr_instance->enabled_known_extensions.nv_external_memory_capabilities == 1) |
| ? (void *)vkGetPhysicalDeviceExternalImageFormatPropertiesNV |
| : NULL; |
| return true; |
| } |
| |
| #ifdef VK_USE_PLATFORM_WIN32_KHR |
| |
| // Functions for the VK_NV_external_memory_win32 extension |
| if (!strcmp("vkGetMemoryWin32HandleNV", name)) { |
| *addr = (void *)vkGetMemoryWin32HandleNV; |
| return true; |
| } |
| |
| #endif // VK_USE_PLATFORM_WIN32_KHR |
| |
| // Functions for the VK_NVX_device_generated_commands extension |
| |
| if (!strcmp("vkCmdProcessCommandsNVX", name)) { |
| *addr = (void *)vkCmdProcessCommandsNVX; |
| return true; |
| } |
| if (!strcmp("vkCmdReserveSpaceForCommandsNVX", name)) { |
| *addr = (void *)vkCmdReserveSpaceForCommandsNVX; |
| return true; |
| } |
| if (!strcmp("vkCreateIndirectCommandsLayoutNVX", name)) { |
| *addr = (void *)vkCreateIndirectCommandsLayoutNVX; |
| return true; |
| } |
| if (!strcmp("vkDestroyIndirectCommandsLayoutNVX", name)) { |
| *addr = (void *)vkDestroyIndirectCommandsLayoutNVX; |
| return true; |
| } |
| if (!strcmp("vkCreateObjectTableNVX", name)) { |
| *addr = (void *)vkCreateObjectTableNVX; |
| return true; |
| } |
| if (!strcmp("vkDestroyObjectTableNVX", name)) { |
| *addr = (void *)vkDestroyObjectTableNVX; |
| return true; |
| } |
| if (!strcmp("vkRegisterObjectsNVX", name)) { |
| *addr = (void *)vkRegisterObjectsNVX; |
| return true; |
| } |
| if (!strcmp("vkUnregisterObjectsNVX", name)) { |
| *addr = (void *)vkUnregisterObjectsNVX; |
| return true; |
| } |
| if (!strcmp("vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX", name)) { |
| *addr = (void *)vkGetPhysicalDeviceGeneratedCommandsPropertiesNVX; |
| return true; |
| } |
| |
| return false; |
| } |
| |
| void extensions_create_instance(struct loader_instance *ptr_instance, const VkInstanceCreateInfo *pCreateInfo) { |
| for (uint32_t i = 0; i < pCreateInfo->enabledExtensionCount; i++) { |
| if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_KHR_GET_PHYSICAL_DEVICE_PROPERTIES_2_EXTENSION_NAME)) { |
| ptr_instance->enabled_known_extensions.khr_get_physical_device_properties2 = 1; |
| #ifdef VK_USE_PLATFORM_XLIB_KHR |
| } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_ACQUIRE_XLIB_DISPLAY_EXTENSION_NAME)) { |
| ptr_instance->enabled_known_extensions.ext_acquire_xlib_display = 1; |
| #endif |
| } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DIRECT_MODE_DISPLAY_EXTENSION_NAME)) { |
| ptr_instance->enabled_known_extensions.ext_direct_mode_display = 1; |
| } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_EXT_DISPLAY_SURFACE_COUNTER_EXTENSION_NAME)) { |
| ptr_instance->enabled_known_extensions.ext_display_surface_counter = 1; |
| } else if (0 == strcmp(pCreateInfo->ppEnabledExtensionNames[i], VK_NV_EXTERNAL_MEMORY_CAPABILITIES_EXTENSION_NAME)) { |
| ptr_instance->enabled_known_extensions.nv_external_memory_capabilities = 1; |
| } |
| } |
| } |