From 03f8528315fa46c95991a34f3325d7b33ae5538c Mon Sep 17 00:00:00 2001
From: Edward Rudd <urkle@outoforder.cc>
Date: Sat, 02 May 2020 21:48:36 +0000
Subject: [PATCH] Update source to SDL2 2.0.12
---
source/src/video/SDL_vulkan_utils.c | 345 +++++++++++++++++++++++++++++++++++++++++++++++++++++++++
1 files changed, 344 insertions(+), 1 deletions(-)
diff --git a/source/src/video/SDL_vulkan_utils.c b/source/src/video/SDL_vulkan_utils.c
index 1b242f1..472acfa 100644
--- a/source/src/video/SDL_vulkan_utils.c
+++ b/source/src/video/SDL_vulkan_utils.c
@@ -1,6 +1,6 @@
/*
Simple DirectMedia Layer
- Copyright (C) 1997-2018 Sam Lantinga <slouken@libsdl.org>
+ Copyright (C) 1997-2020 Sam Lantinga <slouken@libsdl.org>
This software is provided 'as-is', without any express or implied
warranty. In no event will the authors be held liable for any damages
@@ -22,6 +22,9 @@
#include "SDL_vulkan_internal.h"
#include "SDL_error.h"
+#include "SDL_log.h"
+
+/* !!! FIXME: this file doesn't match coding standards for SDL (brace position, etc). */
#if SDL_VIDEO_VULKAN
@@ -167,6 +170,346 @@
return SDL_TRUE;
}
+/* Alpha modes, in order of preference */
+static const VkDisplayPlaneAlphaFlagBitsKHR alphaModes[4] = {
+ VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR,
+ VK_DISPLAY_PLANE_ALPHA_GLOBAL_BIT_KHR,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_BIT_KHR,
+ VK_DISPLAY_PLANE_ALPHA_PER_PIXEL_PREMULTIPLIED_BIT_KHR,
+};
+
+SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
+ VkInstance instance,
+ VkSurfaceKHR *surface)
+{
+ PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr =
+ (PFN_vkGetInstanceProcAddr)vkGetInstanceProcAddr_;
+#define VULKAN_INSTANCE_FUNCTION(name) \
+ PFN_##name name = (PFN_##name)vkGetInstanceProcAddr((VkInstance)instance, #name)
+ VULKAN_INSTANCE_FUNCTION(vkEnumeratePhysicalDevices);
+ VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceDisplayPropertiesKHR);
+ VULKAN_INSTANCE_FUNCTION(vkGetDisplayModePropertiesKHR);
+ VULKAN_INSTANCE_FUNCTION(vkGetPhysicalDeviceDisplayPlanePropertiesKHR);
+ VULKAN_INSTANCE_FUNCTION(vkGetDisplayPlaneCapabilitiesKHR);
+ VULKAN_INSTANCE_FUNCTION(vkGetDisplayPlaneSupportedDisplaysKHR);
+ VULKAN_INSTANCE_FUNCTION(vkCreateDisplayPlaneSurfaceKHR);
+#undef VULKAN_INSTANCE_FUNCTION
+ VkDisplaySurfaceCreateInfoKHR createInfo;
+ VkResult result;
+ uint32_t physicalDeviceCount = 0;
+ VkPhysicalDevice *physicalDevices = NULL;
+ uint32_t physicalDeviceIndex;
+ const char *chosenDisplayId;
+ int displayId = 0; /* Counting from physical device 0, display 0 */
+
+ if(!vkEnumeratePhysicalDevices ||
+ !vkGetPhysicalDeviceDisplayPropertiesKHR ||
+ !vkGetDisplayModePropertiesKHR ||
+ !vkGetPhysicalDeviceDisplayPlanePropertiesKHR ||
+ !vkGetDisplayPlaneCapabilitiesKHR ||
+ !vkGetDisplayPlaneSupportedDisplaysKHR ||
+ !vkCreateDisplayPlaneSurfaceKHR)
+ {
+ SDL_SetError(VK_KHR_DISPLAY_EXTENSION_NAME
+ " extension is not enabled in the Vulkan instance.");
+ goto error;
+ }
+
+ if ((chosenDisplayId = SDL_getenv("SDL_VULKAN_DISPLAY")) != NULL)
+ {
+ displayId = SDL_atoi(chosenDisplayId);
+ }
+
+ /* Enumerate physical devices */
+ result =
+ vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, NULL);
+ if(result != VK_SUCCESS)
+ {
+ SDL_SetError("Could not enumerate Vulkan physical devices");
+ goto error;
+ }
+ if(physicalDeviceCount == 0)
+ {
+ SDL_SetError("No Vulkan physical devices");
+ goto error;
+ }
+ physicalDevices = SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
+ if(!physicalDevices)
+ {
+ SDL_OutOfMemory();
+ goto error;
+ }
+ result =
+ vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices);
+ if(result != VK_SUCCESS)
+ {
+ SDL_SetError("Error enumerating physical devices");
+ goto error;
+ }
+
+ for(physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount;
+ physicalDeviceIndex++)
+ {
+ VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
+ uint32_t displayPropertiesCount = 0;
+ VkDisplayPropertiesKHR *displayProperties = NULL;
+ uint32_t displayModePropertiesCount = 0;
+ VkDisplayModePropertiesKHR *displayModeProperties = NULL;
+ int bestMatchIndex = -1;
+ uint32_t refreshRate = 0;
+ uint32_t i;
+ uint32_t displayPlanePropertiesCount = 0;
+ int planeIndex = -1;
+ VkDisplayKHR display;
+ VkDisplayPlanePropertiesKHR *displayPlaneProperties = NULL;
+ VkExtent2D extent;
+ VkDisplayPlaneCapabilitiesKHR planeCaps;
+
+ /* Get information about the physical displays */
+ result =
+ vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, NULL);
+ if (result != VK_SUCCESS || displayPropertiesCount == 0)
+ {
+ /* This device has no physical device display properties, move on to next. */
+ continue;
+ }
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display properties for device %u: %u",
+ physicalDeviceIndex, displayPropertiesCount);
+
+ if ( (displayId < 0) || (((uint32_t) displayId) >= displayPropertiesCount) )
+ {
+ /* Display id specified was higher than number of available displays, move to next physical device. */
+ displayId -= displayPropertiesCount;
+ continue;
+ }
+
+ displayProperties = SDL_malloc(sizeof(VkDisplayPropertiesKHR) * displayPropertiesCount);
+ if(!displayProperties)
+ {
+ SDL_OutOfMemory();
+ goto error;
+ }
+
+ result =
+ vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, displayProperties);
+ if (result != VK_SUCCESS || displayPropertiesCount == 0) {
+ SDL_free(displayProperties);
+ SDL_SetError("Error enumerating physical device displays");
+ goto error;
+ }
+
+ display = displayProperties[displayId].display;
+ extent = displayProperties[displayId].physicalResolution;
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Display: %s Native resolution: %ux%u",
+ displayProperties[displayId].displayName, extent.width, extent.height);
+
+ SDL_free(displayProperties);
+ displayProperties = NULL;
+
+ /* Get display mode properties for the chosen display */
+ result =
+ vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, NULL);
+ if (result != VK_SUCCESS || displayModePropertiesCount == 0)
+ {
+ SDL_SetError("Error enumerating display modes");
+ goto error;
+ }
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display modes: %u", displayModePropertiesCount);
+
+ displayModeProperties = SDL_malloc(sizeof(VkDisplayModePropertiesKHR) * displayModePropertiesCount);
+ if(!displayModeProperties)
+ {
+ SDL_OutOfMemory();
+ goto error;
+ }
+
+ result =
+ vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, displayModeProperties);
+ if (result != VK_SUCCESS || displayModePropertiesCount == 0) {
+ SDL_SetError("Error enumerating display modes");
+ SDL_free(displayModeProperties);
+ goto error;
+ }
+
+ /* Try to find a display mode that matches the native resolution */
+ for (i = 0; i < displayModePropertiesCount; ++i)
+ {
+ if (displayModeProperties[i].parameters.visibleRegion.width == extent.width &&
+ displayModeProperties[i].parameters.visibleRegion.height == extent.height &&
+ displayModeProperties[i].parameters.refreshRate > refreshRate)
+ {
+ bestMatchIndex = i;
+ refreshRate = displayModeProperties[i].parameters.refreshRate;
+ }
+ }
+ if (bestMatchIndex < 0)
+ {
+ SDL_SetError("Found no matching display mode");
+ SDL_free(displayModeProperties);
+ goto error;
+ }
+
+ SDL_zero(createInfo);
+ createInfo.displayMode = displayModeProperties[bestMatchIndex].displayMode;
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Matching mode %ux%u with refresh rate %u",
+ displayModeProperties[bestMatchIndex].parameters.visibleRegion.width,
+ displayModeProperties[bestMatchIndex].parameters.visibleRegion.height,
+ refreshRate);
+
+ SDL_free(displayModeProperties);
+ displayModeProperties = NULL;
+
+ /* Try to find a plane index that supports our display */
+ result =
+ vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, NULL);
+ if (result != VK_SUCCESS || displayPlanePropertiesCount == 0)
+ {
+ SDL_SetError("Error enumerating display planes");
+ goto error;
+ }
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display planes: %u", displayPlanePropertiesCount);
+
+ displayPlaneProperties = SDL_malloc(sizeof(VkDisplayPlanePropertiesKHR) * displayPlanePropertiesCount);
+ if(!displayPlaneProperties)
+ {
+ SDL_OutOfMemory();
+ goto error;
+ }
+
+ result =
+ vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, displayPlaneProperties);
+ if (result != VK_SUCCESS || displayPlanePropertiesCount == 0)
+ {
+ SDL_SetError("Error enumerating display plane properties");
+ SDL_free(displayPlaneProperties);
+ goto error;
+ }
+
+ for (i = 0; i < displayPlanePropertiesCount; ++i)
+ {
+ uint32_t planeSupportedDisplaysCount = 0;
+ VkDisplayKHR *planeSupportedDisplays = NULL;
+ uint32_t j;
+
+ /* Check if plane is attached to a display, if not, continue. */
+ if (displayPlaneProperties[i].currentDisplay == VK_NULL_HANDLE)
+ continue;
+
+ /* Check supported displays for this plane. */
+ result =
+ vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, NULL);
+ if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0)
+ {
+ continue; /* No supported displays, on to next plane. */
+ }
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of supported displays for plane %u: %u", i, planeSupportedDisplaysCount);
+
+ planeSupportedDisplays = SDL_malloc(sizeof(VkDisplayKHR) * planeSupportedDisplaysCount);
+ if(!planeSupportedDisplays)
+ {
+ SDL_free(displayPlaneProperties);
+ SDL_OutOfMemory();
+ goto error;
+ }
+
+ result =
+ vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, planeSupportedDisplays);
+ if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0)
+ {
+ SDL_SetError("Error enumerating supported displays, or no supported displays");
+ SDL_free(planeSupportedDisplays);
+ SDL_free(displayPlaneProperties);
+ goto error;
+ }
+
+ for (j = 0; j < planeSupportedDisplaysCount && planeSupportedDisplays[j] != display; ++j)
+ ;
+
+ SDL_free(planeSupportedDisplays);
+ planeSupportedDisplays = NULL;
+
+ if (j == planeSupportedDisplaysCount)
+ {
+ /* This display is not supported for this plane, move on. */
+ continue;
+ }
+
+ result = vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, createInfo.displayMode, i, &planeCaps);
+ if (result != VK_SUCCESS)
+ {
+ SDL_SetError("Error getting display plane capabilities");
+ SDL_free(displayPlaneProperties);
+ goto error;
+ }
+
+ /* Check if plane fulfills extent requirements. */
+ if (extent.width >= planeCaps.minDstExtent.width && extent.height >= planeCaps.minDstExtent.height &&
+ extent.width <= planeCaps.maxDstExtent.width && extent.height <= planeCaps.maxDstExtent.height)
+ {
+ /* If it does, choose this plane. */
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Choosing plane %d, minimum extent %dx%d maximum extent %dx%d", i,
+ planeCaps.minDstExtent.width, planeCaps.minDstExtent.height,
+ planeCaps.maxDstExtent.width, planeCaps.maxDstExtent.height);
+ planeIndex = i;
+ break;
+ }
+ }
+
+ if (planeIndex < 0)
+ {
+ SDL_SetError("No plane supports the selected resolution");
+ SDL_free(displayPlaneProperties);
+ goto error;
+ }
+
+ createInfo.planeIndex = planeIndex;
+ createInfo.planeStackIndex = displayPlaneProperties[planeIndex].currentStackIndex;
+ SDL_free(displayPlaneProperties);
+ displayPlaneProperties = NULL;
+
+ /* Find a supported alpha mode. Not all planes support OPAQUE */
+ createInfo.alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
+ for (i = 0; i < SDL_arraysize(alphaModes); i++) {
+ if (planeCaps.supportedAlpha & alphaModes[i]) {
+ createInfo.alphaMode = alphaModes[i];
+ break;
+ }
+ }
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Chose alpha mode 0x%x", createInfo.alphaMode);
+
+ /* Found a match, finally! Fill in extent, and break from loop */
+ createInfo.imageExtent = extent;
+ break;
+ }
+
+ SDL_free(physicalDevices);
+ physicalDevices = NULL;
+
+ if (physicalDeviceIndex == physicalDeviceCount)
+ {
+ SDL_SetError("No usable displays found or requested display out of range");
+ return SDL_FALSE;
+ }
+
+ createInfo.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
+ createInfo.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+ createInfo.globalAlpha = 1.0f;
+
+ result = vkCreateDisplayPlaneSurfaceKHR(instance, &createInfo,
+ NULL, surface);
+ if(result != VK_SUCCESS)
+ {
+ SDL_SetError("vkCreateDisplayPlaneSurfaceKHR failed: %s",
+ SDL_Vulkan_GetResultString(result));
+ return SDL_FALSE;
+ }
+ SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Created surface");
+ return SDL_TRUE;
+error:
+ SDL_free(physicalDevices);
+ return SDL_FALSE;
+}
+
#endif
/* vi: set ts=4 sw=4 expandtab: */
--
Gitblit v1.9.3