From bcd934f2aa3167e3e0c0033281e6aa60e105231c Mon Sep 17 00:00:00 2001 From: Ben Davis Date: Fri, 25 Jun 2021 11:35:11 +0100 Subject: [PATCH] Add vulkan 1.1 function entrypoints Implement vkGetDeviceGroupSurfacePresentModesKHR, vkGetDeviceGroupPresentCapabilitiesKHR, vkAcquireNextImage2KHR and vkGetPhysicalDevicePresentRectanglesKHR function entrypoints in the layer. We assume that if the layer should not handle the surface the device or instance should handle it as appropriate and fallback to this implmentation. Change-Id: Iafc585d8738ad80413ad616d834d966f92c4f8cb Signed-off-by: Ben Davis --- layer/layer.cpp | 6 +++ layer/private_data.hpp | 8 +++- layer/swapchain_api.cpp | 100 ++++++++++++++++++++++++++++++++++++++++ layer/swapchain_api.hpp | 13 ++++++ 4 files changed, 125 insertions(+), 2 deletions(-) diff --git a/layer/layer.cpp b/layer/layer.cpp index b01a2c8..cff12b5 100644 --- a/layer/layer.cpp +++ b/layer/layer.cpp @@ -435,6 +435,10 @@ VK_LAYER_EXPORT PFN_vkVoidFunction VKAPI_CALL wsi_layer_vkGetDeviceProcAddr(VkDe GET_PROC_ADDR(vkAcquireNextImageKHR); GET_PROC_ADDR(vkQueuePresentKHR); + GET_PROC_ADDR(vkGetDeviceGroupSurfacePresentModesKHR); + GET_PROC_ADDR(vkGetDeviceGroupPresentCapabilitiesKHR); + GET_PROC_ADDR(vkAcquireNextImage2KHR); + return layer::device_private_data::get(device).disp.GetDeviceProcAddr(device, funcName); } @@ -460,6 +464,8 @@ VK_LAYER_EXPORT VKAPI_ATTR PFN_vkVoidFunction VKAPI_CALL wsi_layer_vkGetInstance GET_PROC_ADDR(vkEnumerateDeviceExtensionProperties); GET_PROC_ADDR(vkEnumerateInstanceLayerProperties); + GET_PROC_ADDR(vkGetPhysicalDevicePresentRectanglesKHR); + return layer::instance_private_data::get(instance).disp.GetInstanceProcAddr(instance, funcName); } } /* extern "C" */ diff --git a/layer/private_data.hpp b/layer/private_data.hpp index db8735b..205112c 100644 --- a/layer/private_data.hpp +++ b/layer/private_data.hpp @@ -58,7 +58,8 @@ namespace layer OPTIONAL(GetPhysicalDeviceSurfacePresentModesKHR) \ OPTIONAL(GetPhysicalDeviceSurfaceSupportKHR) \ OPTIONAL(GetPhysicalDeviceImageFormatProperties2KHR) \ - OPTIONAL(GetPhysicalDeviceFormatProperties2KHR) + OPTIONAL(GetPhysicalDeviceFormatProperties2KHR) \ + OPTIONAL(GetPhysicalDevicePresentRectanglesKHR) struct instance_dispatch_table { @@ -116,7 +117,10 @@ struct instance_dispatch_table OPTIONAL(AcquireNextImageKHR) \ OPTIONAL(QueuePresentKHR) \ OPTIONAL(GetMemoryFdPropertiesKHR) \ - OPTIONAL(BindImageMemory2KHR) + OPTIONAL(BindImageMemory2KHR) \ + OPTIONAL(GetDeviceGroupSurfacePresentModesKHR) \ + OPTIONAL(GetDeviceGroupPresentCapabilitiesKHR) \ + OPTIONAL(AcquireNextImage2KHR) struct device_dispatch_table { diff --git a/layer/swapchain_api.cpp b/layer/swapchain_api.cpp index 089597b..f10c0e3 100644 --- a/layer/swapchain_api.cpp +++ b/layer/swapchain_api.cpp @@ -166,4 +166,104 @@ VKAPI_ATTR VkResult wsi_layer_vkQueuePresentKHR(VkQueue queue, const VkPresentIn return ret; } +VKAPI_ATTR VkResult wsi_layer_vkGetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities) +{ + assert(pDeviceGroupPresentCapabilities != nullptr); + + pDeviceGroupPresentCapabilities->presentMask[0] = 1; + pDeviceGroupPresentCapabilities->modes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR; + + for (uint32_t i = 1; i < VK_MAX_DEVICE_GROUP_SIZE_KHR; i++) + { + pDeviceGroupPresentCapabilities->presentMask[i] = 0; + } + + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult wsi_layer_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR *pModes) +{ + assert(pModes != nullptr); + + auto &device_data = layer::device_private_data::get(device); + auto &instance = device_data.instance_data; + + if (!instance.should_layer_handle_surface(device_data.physical_device, surface)) + { + return device_data.disp.GetDeviceGroupSurfacePresentModesKHR(device, surface, pModes); + } + + *pModes = VK_DEVICE_GROUP_PRESENT_MODE_LOCAL_BIT_KHR; + return VK_SUCCESS; +} + +VKAPI_ATTR VkResult wsi_layer_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, uint32_t *pRectCount, + VkRect2D *pRects) +{ + assert(surface); + assert(pRectCount != nullptr); + + auto &instance = layer::instance_private_data::get(physicalDevice); + + if (!instance.should_layer_handle_surface(physicalDevice, surface)) + { + return instance.disp.GetPhysicalDevicePresentRectanglesKHR(physicalDevice, surface, pRectCount, pRects); + } + + VkResult result; + wsi::surface_properties *props = wsi::get_surface_properties(surface); + assert(props); + + if (nullptr == pRects) + { + *pRectCount = 1; + result = VK_SUCCESS; + } + else if (0 == *pRectCount) + { + result = VK_INCOMPLETE; + } + else + { + *pRectCount = 1; + + VkSurfaceCapabilitiesKHR surface_caps; + result = props->get_surface_capabilities(physicalDevice, surface, &surface_caps); + + if (result != VK_SUCCESS) + { + return result; + } + + pRects[0].offset.x = 0; + pRects[0].offset.y = 0; + pRects[0].extent = surface_caps.currentExtent; + } + + return result; +} + +VKAPI_ATTR VkResult wsi_layer_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, + uint32_t *pImageIndex) +{ + assert(pAcquireInfo != VK_NULL_HANDLE); + assert(pAcquireInfo->swapchain != VK_NULL_HANDLE); + assert(pAcquireInfo->semaphore != VK_NULL_HANDLE || pAcquireInfo->fence != VK_NULL_HANDLE); + assert(pImageIndex != nullptr); + + auto &device_data = layer::device_private_data::get(device); + + if (!device_data.layer_owns_swapchain(pAcquireInfo->swapchain)) + { + return device_data.disp.AcquireNextImage2KHR(device, pAcquireInfo, pImageIndex); + } + + wsi::swapchain_base *sc = reinterpret_cast(pAcquireInfo->swapchain); + + return sc->acquire_next_image(pAcquireInfo->timeout, pAcquireInfo->semaphore, pAcquireInfo->fence, pImageIndex); +} + } /* extern "C" */ diff --git a/layer/swapchain_api.hpp b/layer/swapchain_api.hpp index 231001b..0db72c8 100644 --- a/layer/swapchain_api.hpp +++ b/layer/swapchain_api.hpp @@ -49,4 +49,17 @@ extern "C" VKAPI_ATTR VkResult wsi_layer_vkQueuePresentKHR(VkQueue queue, const VkPresentInfoKHR *pPresentInfo); + /* 1.1 entrypoints */ + VKAPI_ATTR VkResult wsi_layer_vkGetDeviceGroupPresentCapabilitiesKHR( + VkDevice device, VkDeviceGroupPresentCapabilitiesKHR *pDeviceGroupPresentCapabilities); + + VKAPI_ATTR VkResult wsi_layer_vkGetDeviceGroupSurfacePresentModesKHR(VkDevice device, VkSurfaceKHR surface, + VkDeviceGroupPresentModeFlagsKHR *pModes); + + VKAPI_ATTR VkResult wsi_layer_vkGetPhysicalDevicePresentRectanglesKHR(VkPhysicalDevice physicalDevice, + VkSurfaceKHR surface, uint32_t *pRectCount, + VkRect2D *pRects); + + VKAPI_ATTR VkResult wsi_layer_vkAcquireNextImage2KHR(VkDevice device, const VkAcquireNextImageInfoKHR *pAcquireInfo, + uint32_t *pImageIndex); }