encounter
/
SDL
mirror of https://github.com/encounter/SDL.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

SDL_vulkan_utils: minor code clean-up

This commit is contained in:
Sylvain Becker 2021-02-03 09:51:42 +01:00
parent c0166a29b7
commit 549bc13362
1 changed files with 147 additions and 187 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

334
src/video/SDL_vulkan_utils.c
View File

@ -23,97 +23,95 @@
#include "SDL_vulkan_internal.h" #include "SDL_vulkan_internal.h"
#include "SDL_error.h" #include "SDL_error.h"
/* !!! FIXME: this file doesn't match coding standards for SDL (brace position, etc). */
#if SDL_VIDEO_VULKAN #if SDL_VIDEO_VULKAN
const char *SDL_Vulkan_GetResultString(VkResult result) const char *SDL_Vulkan_GetResultString(VkResult result)
{ {
switch((int)result) switch ((int)result) {
{ case VK_SUCCESS:
case VK_SUCCESS: return "VK_SUCCESS";
return "VK_SUCCESS"; case VK_NOT_READY:
case VK_NOT_READY: return "VK_NOT_READY";
return "VK_NOT_READY"; case VK_TIMEOUT:
case VK_TIMEOUT: return "VK_TIMEOUT";
return "VK_TIMEOUT"; case VK_EVENT_SET:
case VK_EVENT_SET: return "VK_EVENT_SET";
return "VK_EVENT_SET"; case VK_EVENT_RESET:
case VK_EVENT_RESET: return "VK_EVENT_RESET";
return "VK_EVENT_RESET"; case VK_INCOMPLETE:
case VK_INCOMPLETE: return "VK_INCOMPLETE";
return "VK_INCOMPLETE"; case VK_ERROR_OUT_OF_HOST_MEMORY:
case VK_ERROR_OUT_OF_HOST_MEMORY: return "VK_ERROR_OUT_OF_HOST_MEMORY";
return "VK_ERROR_OUT_OF_HOST_MEMORY"; case VK_ERROR_OUT_OF_DEVICE_MEMORY:
case VK_ERROR_OUT_OF_DEVICE_MEMORY: return "VK_ERROR_OUT_OF_DEVICE_MEMORY";
return "VK_ERROR_OUT_OF_DEVICE_MEMORY"; case VK_ERROR_INITIALIZATION_FAILED:
case VK_ERROR_INITIALIZATION_FAILED: return "VK_ERROR_INITIALIZATION_FAILED";
return "VK_ERROR_INITIALIZATION_FAILED"; case VK_ERROR_DEVICE_LOST:
case VK_ERROR_DEVICE_LOST: return "VK_ERROR_DEVICE_LOST";
return "VK_ERROR_DEVICE_LOST"; case VK_ERROR_MEMORY_MAP_FAILED:
case VK_ERROR_MEMORY_MAP_FAILED: return "VK_ERROR_MEMORY_MAP_FAILED";
return "VK_ERROR_MEMORY_MAP_FAILED"; case VK_ERROR_LAYER_NOT_PRESENT:
case VK_ERROR_LAYER_NOT_PRESENT: return "VK_ERROR_LAYER_NOT_PRESENT";
return "VK_ERROR_LAYER_NOT_PRESENT"; case VK_ERROR_EXTENSION_NOT_PRESENT:
case VK_ERROR_EXTENSION_NOT_PRESENT: return "VK_ERROR_EXTENSION_NOT_PRESENT";
return "VK_ERROR_EXTENSION_NOT_PRESENT"; case VK_ERROR_FEATURE_NOT_PRESENT:
case VK_ERROR_FEATURE_NOT_PRESENT: return "VK_ERROR_FEATURE_NOT_PRESENT";
return "VK_ERROR_FEATURE_NOT_PRESENT"; case VK_ERROR_INCOMPATIBLE_DRIVER:
case VK_ERROR_INCOMPATIBLE_DRIVER: return "VK_ERROR_INCOMPATIBLE_DRIVER";
return "VK_ERROR_INCOMPATIBLE_DRIVER"; case VK_ERROR_TOO_MANY_OBJECTS:
case VK_ERROR_TOO_MANY_OBJECTS: return "VK_ERROR_TOO_MANY_OBJECTS";
return "VK_ERROR_TOO_MANY_OBJECTS"; case VK_ERROR_FORMAT_NOT_SUPPORTED:
case VK_ERROR_FORMAT_NOT_SUPPORTED: return "VK_ERROR_FORMAT_NOT_SUPPORTED";
return "VK_ERROR_FORMAT_NOT_SUPPORTED"; case VK_ERROR_FRAGMENTED_POOL:
case VK_ERROR_FRAGMENTED_POOL: return "VK_ERROR_FRAGMENTED_POOL";
return "VK_ERROR_FRAGMENTED_POOL"; case VK_ERROR_UNKNOWN:
case VK_ERROR_UNKNOWN: return "VK_ERROR_UNKNOWN";
return "VK_ERROR_UNKNOWN"; case VK_ERROR_OUT_OF_POOL_MEMORY:
case VK_ERROR_OUT_OF_POOL_MEMORY: return "VK_ERROR_OUT_OF_POOL_MEMORY";
return "VK_ERROR_OUT_OF_POOL_MEMORY"; case VK_ERROR_INVALID_EXTERNAL_HANDLE:
case VK_ERROR_INVALID_EXTERNAL_HANDLE: return "VK_ERROR_INVALID_EXTERNAL_HANDLE";
return "VK_ERROR_INVALID_EXTERNAL_HANDLE"; case VK_ERROR_FRAGMENTATION:
case VK_ERROR_FRAGMENTATION: return "VK_ERROR_FRAGMENTATION";
return "VK_ERROR_FRAGMENTATION"; case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS:
case VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS: return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS";
return "VK_ERROR_INVALID_OPAQUE_CAPTURE_ADDRESS"; case VK_ERROR_SURFACE_LOST_KHR:
case VK_ERROR_SURFACE_LOST_KHR: return "VK_ERROR_SURFACE_LOST_KHR";
return "VK_ERROR_SURFACE_LOST_KHR"; case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR:
case VK_ERROR_NATIVE_WINDOW_IN_USE_KHR: return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR";
return "VK_ERROR_NATIVE_WINDOW_IN_USE_KHR"; case VK_SUBOPTIMAL_KHR:
case VK_SUBOPTIMAL_KHR: return "VK_SUBOPTIMAL_KHR";
return "VK_SUBOPTIMAL_KHR"; case VK_ERROR_OUT_OF_DATE_KHR:
case VK_ERROR_OUT_OF_DATE_KHR: return "VK_ERROR_OUT_OF_DATE_KHR";
return "VK_ERROR_OUT_OF_DATE_KHR"; case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR:
case VK_ERROR_INCOMPATIBLE_DISPLAY_KHR: return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR";
return "VK_ERROR_INCOMPATIBLE_DISPLAY_KHR"; case VK_ERROR_VALIDATION_FAILED_EXT:
case VK_ERROR_VALIDATION_FAILED_EXT: return "VK_ERROR_VALIDATION_FAILED_EXT";
return "VK_ERROR_VALIDATION_FAILED_EXT"; case VK_ERROR_INVALID_SHADER_NV:
case VK_ERROR_INVALID_SHADER_NV: return "VK_ERROR_INVALID_SHADER_NV";
return "VK_ERROR_INVALID_SHADER_NV"; case VK_ERROR_INCOMPATIBLE_VERSION_KHR:
case VK_ERROR_INCOMPATIBLE_VERSION_KHR: return "VK_ERROR_INCOMPATIBLE_VERSION_KHR";
return "VK_ERROR_INCOMPATIBLE_VERSION_KHR"; case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT:
case VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT: return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT";
return "VK_ERROR_INVALID_DRM_FORMAT_MODIFIER_PLANE_LAYOUT_EXT"; case VK_ERROR_NOT_PERMITTED_EXT:
case VK_ERROR_NOT_PERMITTED_EXT: return "VK_ERROR_NOT_PERMITTED_EXT";
return "VK_ERROR_NOT_PERMITTED_EXT"; case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT:
case VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT: return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT";
return "VK_ERROR_FULL_SCREEN_EXCLUSIVE_MODE_LOST_EXT"; case VK_THREAD_IDLE_KHR:
case VK_THREAD_IDLE_KHR: return "VK_THREAD_IDLE_KHR";
return "VK_THREAD_IDLE_KHR"; case VK_THREAD_DONE_KHR:
case VK_THREAD_DONE_KHR: return "VK_THREAD_DONE_KHR";
return "VK_THREAD_DONE_KHR"; case VK_OPERATION_DEFERRED_KHR:
case VK_OPERATION_DEFERRED_KHR: return "VK_OPERATION_DEFERRED_KHR";
return "VK_OPERATION_DEFERRED_KHR"; case VK_OPERATION_NOT_DEFERRED_KHR:
case VK_OPERATION_NOT_DEFERRED_KHR: return "VK_OPERATION_NOT_DEFERRED_KHR";
return "VK_OPERATION_NOT_DEFERRED_KHR"; case VK_PIPELINE_COMPILE_REQUIRED_EXT:
case VK_PIPELINE_COMPILE_REQUIRED_EXT: return "VK_PIPELINE_COMPILE_REQUIRED_EXT";
return "VK_PIPELINE_COMPILE_REQUIRED_EXT"; default:
default: break;
break;
} }
if(result < 0) if (result < 0) {
return "VK_ERROR_<Unknown>"; return "VK_ERROR_<Unknown>";
}
return "VK_<Unknown>"; return "VK_<Unknown>";
} }
@ -124,11 +122,9 @@ VkExtensionProperties *SDL_Vulkan_CreateInstanceExtensionsList(
Uint32 count = 0; Uint32 count = 0;
VkResult result = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL); VkResult result = vkEnumerateInstanceExtensionProperties(NULL, &count, NULL);
VkExtensionProperties *retval; VkExtensionProperties *retval;
if(result == VK_ERROR_INCOMPATIBLE_DRIVER)
{ if (result == VK_ERROR_INCOMPATIBLE_DRIVER) {
/* Avoid the ERR_MAX_STRLEN limit by passing part of the message /* Avoid the ERR_MAX_STRLEN limit by passing part of the message as a string argument. */
* as a string argument.
*/
SDL_SetError( SDL_SetError(
"You probably don't have a working Vulkan driver installed. %s %s %s(%d)", "You probably don't have a working Vulkan driver installed. %s %s %s(%d)",
"Getting Vulkan extensions failed:", "Getting Vulkan extensions failed:",
@ -136,9 +132,7 @@ VkExtensionProperties *SDL_Vulkan_CreateInstanceExtensionsList(
SDL_Vulkan_GetResultString(result), SDL_Vulkan_GetResultString(result),
(int)result); (int)result);
return NULL; return NULL;
} } else if (result != VK_SUCCESS) {
else if(result != VK_SUCCESS)
{
SDL_SetError( SDL_SetError(
"Getting Vulkan extensions failed: vkEnumerateInstanceExtensionProperties returned " "Getting Vulkan extensions failed: vkEnumerateInstanceExtensionProperties returned "
"%s(%d)", "%s(%d)",
@ -146,22 +140,20 @@ VkExtensionProperties *SDL_Vulkan_CreateInstanceExtensionsList(
(int)result); (int)result);
return NULL; return NULL;
} }
if(count == 0)
{ if (count == 0) {
retval = SDL_calloc(1, sizeof(VkExtensionProperties)); // so we can return non-null retval = SDL_calloc(1, sizeof(VkExtensionProperties)); // so we can return non-null
} } else {
else
{
retval = SDL_calloc(count, sizeof(VkExtensionProperties)); retval = SDL_calloc(count, sizeof(VkExtensionProperties));
} }
if(!retval)
{ if (!retval) {
SDL_OutOfMemory(); SDL_OutOfMemory();
return NULL; return NULL;
} }
result = vkEnumerateInstanceExtensionProperties(NULL, &count, retval); result = vkEnumerateInstanceExtensionProperties(NULL, &count, retval);
if(result != VK_SUCCESS) if (result != VK_SUCCESS) {
{
SDL_SetError( SDL_SetError(
"Getting Vulkan extensions failed: vkEnumerateInstanceExtensionProperties returned " "Getting Vulkan extensions failed: vkEnumerateInstanceExtensionProperties returned "
"%s(%d)", "%s(%d)",
@ -186,6 +178,7 @@ SDL_bool SDL_Vulkan_GetInstanceExtensions_Helper(unsigned *userCount,
SDL_SetError("Output array for SDL_Vulkan_GetInstanceExtensions needs to be at least %d big", nameCount); SDL_SetError("Output array for SDL_Vulkan_GetInstanceExtensions needs to be at least %d big", nameCount);
return SDL_FALSE; return SDL_FALSE;
} }
for (i = 0; i < nameCount; i++) { for (i = 0; i < nameCount; i++) {
userNames[i] = names[i]; userNames[i] = names[i];
} }
@ -226,55 +219,47 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
const char *chosenDisplayId; const char *chosenDisplayId;
int displayId = 0; /* Counting from physical device 0, display 0 */ int displayId = 0; /* Counting from physical device 0, display 0 */
if(!vkEnumeratePhysicalDevices || if (!vkEnumeratePhysicalDevices ||
!vkGetPhysicalDeviceDisplayPropertiesKHR || !vkGetPhysicalDeviceDisplayPropertiesKHR ||
!vkGetDisplayModePropertiesKHR || !vkGetDisplayModePropertiesKHR ||
!vkGetPhysicalDeviceDisplayPlanePropertiesKHR || !vkGetPhysicalDeviceDisplayPlanePropertiesKHR ||
!vkGetDisplayPlaneCapabilitiesKHR || !vkGetDisplayPlaneCapabilitiesKHR ||
!vkGetDisplayPlaneSupportedDisplaysKHR || !vkGetDisplayPlaneSupportedDisplaysKHR ||
!vkCreateDisplayPlaneSurfaceKHR) !vkCreateDisplayPlaneSurfaceKHR) {
{ SDL_SetError(VK_KHR_DISPLAY_EXTENSION_NAME " extension is not enabled in the Vulkan instance.");
SDL_SetError(VK_KHR_DISPLAY_EXTENSION_NAME
" extension is not enabled in the Vulkan instance.");
goto error; goto error;
} }
if ((chosenDisplayId = SDL_getenv("SDL_VULKAN_DISPLAY")) != NULL) if ((chosenDisplayId = SDL_getenv("SDL_VULKAN_DISPLAY")) != NULL) {
{
displayId = SDL_atoi(chosenDisplayId); displayId = SDL_atoi(chosenDisplayId);
} }
/* Enumerate physical devices */ /* Enumerate physical devices */
result = result = vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, NULL);
vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, NULL); if (result != VK_SUCCESS) {
if(result != VK_SUCCESS)
{
SDL_SetError("Could not enumerate Vulkan physical devices"); SDL_SetError("Could not enumerate Vulkan physical devices");
goto error; goto error;
} }
if(physicalDeviceCount == 0)
{ if (physicalDeviceCount == 0) {
SDL_SetError("No Vulkan physical devices"); SDL_SetError("No Vulkan physical devices");
goto error; goto error;
} }
physicalDevices = SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount); physicalDevices = SDL_malloc(sizeof(VkPhysicalDevice) * physicalDeviceCount);
if(!physicalDevices) if (!physicalDevices) {
{
SDL_OutOfMemory(); SDL_OutOfMemory();
goto error; goto error;
} }
result =
vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices); result = vkEnumeratePhysicalDevices(instance, &physicalDeviceCount, physicalDevices);
if(result != VK_SUCCESS) if (result != VK_SUCCESS) {
{
SDL_SetError("Error enumerating physical devices"); SDL_SetError("Error enumerating physical devices");
goto error; goto error;
} }
for(physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount; for (physicalDeviceIndex = 0; physicalDeviceIndex < physicalDeviceCount; physicalDeviceIndex++) {
physicalDeviceIndex++) VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
{
VkPhysicalDevice physicalDevice = physicalDevices[physicalDeviceIndex];
uint32_t displayPropertiesCount = 0; uint32_t displayPropertiesCount = 0;
VkDisplayPropertiesKHR *displayProperties = NULL; VkDisplayPropertiesKHR *displayProperties = NULL;
uint32_t displayModePropertiesCount = 0; uint32_t displayModePropertiesCount = 0;
@ -290,32 +275,27 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
VkDisplayPlaneCapabilitiesKHR planeCaps; VkDisplayPlaneCapabilitiesKHR planeCaps;
/* Get information about the physical displays */ /* Get information about the physical displays */
result = result = vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, NULL);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, NULL); if (result != VK_SUCCESS || displayPropertiesCount == 0) {
if (result != VK_SUCCESS || displayPropertiesCount == 0)
{
/* This device has no physical device display properties, move on to next. */ /* This device has no physical device display properties, move on to next. */
continue; continue;
} }
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display properties for device %u: %u", SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display properties for device %u: %u",
physicalDeviceIndex, displayPropertiesCount); physicalDeviceIndex, displayPropertiesCount);
if ( (displayId < 0) || (((uint32_t) displayId) >= displayPropertiesCount) ) if (displayId < 0 || (uint32_t) displayId >= displayPropertiesCount) {
{
/* Display id specified was higher than number of available displays, move to next physical device. */ /* Display id specified was higher than number of available displays, move to next physical device. */
displayId -= displayPropertiesCount; displayId -= displayPropertiesCount;
continue; continue;
} }
displayProperties = SDL_malloc(sizeof(VkDisplayPropertiesKHR) * displayPropertiesCount); displayProperties = SDL_malloc(sizeof(VkDisplayPropertiesKHR) * displayPropertiesCount);
if(!displayProperties) if (!displayProperties) {
{
SDL_OutOfMemory(); SDL_OutOfMemory();
goto error; goto error;
} }
result = result = vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, displayProperties);
vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &displayPropertiesCount, displayProperties);
if (result != VK_SUCCESS || displayPropertiesCount == 0) { if (result != VK_SUCCESS || displayPropertiesCount == 0) {
SDL_free(displayProperties); SDL_free(displayProperties);
SDL_SetError("Error enumerating physical device displays"); SDL_SetError("Error enumerating physical device displays");
@ -331,8 +311,7 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
displayProperties = NULL; displayProperties = NULL;
/* Get display mode properties for the chosen display */ /* Get display mode properties for the chosen display */
result = result = vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, NULL);
vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, NULL);
if (result != VK_SUCCESS || displayModePropertiesCount == 0) if (result != VK_SUCCESS || displayModePropertiesCount == 0)
{ {
SDL_SetError("Error enumerating display modes"); SDL_SetError("Error enumerating display modes");
@ -341,14 +320,12 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display modes: %u", displayModePropertiesCount); SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display modes: %u", displayModePropertiesCount);
displayModeProperties = SDL_malloc(sizeof(VkDisplayModePropertiesKHR) * displayModePropertiesCount); displayModeProperties = SDL_malloc(sizeof(VkDisplayModePropertiesKHR) * displayModePropertiesCount);
if(!displayModeProperties) if (!displayModeProperties) {
{
SDL_OutOfMemory(); SDL_OutOfMemory();
goto error; goto error;
} }
result = result = vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, displayModeProperties);
vkGetDisplayModePropertiesKHR(physicalDevice, display, &displayModePropertiesCount, displayModeProperties);
if (result != VK_SUCCESS || displayModePropertiesCount == 0) { if (result != VK_SUCCESS || displayModePropertiesCount == 0) {
SDL_SetError("Error enumerating display modes"); SDL_SetError("Error enumerating display modes");
SDL_free(displayModeProperties); SDL_free(displayModeProperties);
@ -356,18 +333,16 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
} }
/* Try to find a display mode that matches the native resolution */ /* Try to find a display mode that matches the native resolution */
for (i = 0; i < displayModePropertiesCount; ++i) for (i = 0; i < displayModePropertiesCount; ++i) {
{
if (displayModeProperties[i].parameters.visibleRegion.width == extent.width && if (displayModeProperties[i].parameters.visibleRegion.width == extent.width &&
displayModeProperties[i].parameters.visibleRegion.height == extent.height && displayModeProperties[i].parameters.visibleRegion.height == extent.height &&
displayModeProperties[i].parameters.refreshRate > refreshRate) displayModeProperties[i].parameters.refreshRate > refreshRate) {
{
bestMatchIndex = i; bestMatchIndex = i;
refreshRate = displayModeProperties[i].parameters.refreshRate; refreshRate = displayModeProperties[i].parameters.refreshRate;
} }
} }
if (bestMatchIndex < 0)
{ if (bestMatchIndex < 0) {
SDL_SetError("Found no matching display mode"); SDL_SetError("Found no matching display mode");
SDL_free(displayModeProperties); SDL_free(displayModeProperties);
goto error; goto error;
@ -384,62 +359,53 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
displayModeProperties = NULL; displayModeProperties = NULL;
/* Try to find a plane index that supports our display */ /* Try to find a plane index that supports our display */
result = result = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, NULL);
vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, NULL); if (result != VK_SUCCESS || displayPlanePropertiesCount == 0) {
if (result != VK_SUCCESS || displayPlanePropertiesCount == 0)
{
SDL_SetError("Error enumerating display planes"); SDL_SetError("Error enumerating display planes");
goto error; goto error;
} }
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display planes: %u", displayPlanePropertiesCount); SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of display planes: %u", displayPlanePropertiesCount);
displayPlaneProperties = SDL_malloc(sizeof(VkDisplayPlanePropertiesKHR) * displayPlanePropertiesCount); displayPlaneProperties = SDL_malloc(sizeof(VkDisplayPlanePropertiesKHR) * displayPlanePropertiesCount);
if(!displayPlaneProperties) if (!displayPlaneProperties) {
{
SDL_OutOfMemory(); SDL_OutOfMemory();
goto error; goto error;
} }
result = result = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, displayPlaneProperties);
vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &displayPlanePropertiesCount, displayPlaneProperties); if (result != VK_SUCCESS || displayPlanePropertiesCount == 0) {
if (result != VK_SUCCESS || displayPlanePropertiesCount == 0)
{
SDL_SetError("Error enumerating display plane properties"); SDL_SetError("Error enumerating display plane properties");
SDL_free(displayPlaneProperties); SDL_free(displayPlaneProperties);
goto error; goto error;
} }
for (i = 0; i < displayPlanePropertiesCount; ++i) for (i = 0; i < displayPlanePropertiesCount; ++i) {
{
uint32_t planeSupportedDisplaysCount = 0; uint32_t planeSupportedDisplaysCount = 0;
VkDisplayKHR *planeSupportedDisplays = NULL; VkDisplayKHR *planeSupportedDisplays = NULL;
uint32_t j; uint32_t j;
/* Check if plane is attached to a display, if not, continue. */ /* Check if plane is attached to a display, if not, continue. */
if (displayPlaneProperties[i].currentDisplay == VK_NULL_HANDLE) if (displayPlaneProperties[i].currentDisplay == VK_NULL_HANDLE) {
continue; continue;
}
/* Check supported displays for this plane. */ /* Check supported displays for this plane. */
result = result = vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, NULL);
vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, NULL); if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0) {
if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0)
{
continue; /* No supported displays, on to next plane. */ 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); SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Number of supported displays for plane %u: %u", i, planeSupportedDisplaysCount);
planeSupportedDisplays = SDL_malloc(sizeof(VkDisplayKHR) * planeSupportedDisplaysCount); planeSupportedDisplays = SDL_malloc(sizeof(VkDisplayKHR) * planeSupportedDisplaysCount);
if(!planeSupportedDisplays) if (!planeSupportedDisplays) {
{
SDL_free(displayPlaneProperties); SDL_free(displayPlaneProperties);
SDL_OutOfMemory(); SDL_OutOfMemory();
goto error; goto error;
} }
result = result = vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, planeSupportedDisplays);
vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, i, &planeSupportedDisplaysCount, planeSupportedDisplays); if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0) {
if (result != VK_SUCCESS || planeSupportedDisplaysCount == 0)
{
SDL_SetError("Error enumerating supported displays, or no supported displays"); SDL_SetError("Error enumerating supported displays, or no supported displays");
SDL_free(planeSupportedDisplays); SDL_free(planeSupportedDisplays);
SDL_free(displayPlaneProperties); SDL_free(displayPlaneProperties);
@ -447,20 +413,19 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
} }
for (j = 0; j < planeSupportedDisplaysCount && planeSupportedDisplays[j] != display; ++j) for (j = 0; j < planeSupportedDisplaysCount && planeSupportedDisplays[j] != display; ++j)
; {
}
SDL_free(planeSupportedDisplays); SDL_free(planeSupportedDisplays);
planeSupportedDisplays = NULL; planeSupportedDisplays = NULL;
if (j == planeSupportedDisplaysCount) if (j == planeSupportedDisplaysCount) {
{
/* This display is not supported for this plane, move on. */ /* This display is not supported for this plane, move on. */
continue; continue;
} }
result = vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, createInfo.displayMode, i, &planeCaps); result = vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, createInfo.displayMode, i, &planeCaps);
if (result != VK_SUCCESS) if (result != VK_SUCCESS) {
{
SDL_SetError("Error getting display plane capabilities"); SDL_SetError("Error getting display plane capabilities");
SDL_free(displayPlaneProperties); SDL_free(displayPlaneProperties);
goto error; goto error;
@ -468,8 +433,7 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
/* Check if plane fulfills extent requirements. */ /* Check if plane fulfills extent requirements. */
if (extent.width >= planeCaps.minDstExtent.width && extent.height >= planeCaps.minDstExtent.height && if (extent.width >= planeCaps.minDstExtent.width && extent.height >= planeCaps.minDstExtent.height &&
extent.width <= planeCaps.maxDstExtent.width && extent.height <= planeCaps.maxDstExtent.height) extent.width <= planeCaps.maxDstExtent.width && extent.height <= planeCaps.maxDstExtent.height) {
{
/* If it does, choose this plane. */ /* 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, 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.minDstExtent.width, planeCaps.minDstExtent.height,
@ -479,8 +443,7 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
} }
} }
if (planeIndex < 0) if (planeIndex < 0) {
{
SDL_SetError("No plane supports the selected resolution"); SDL_SetError("No plane supports the selected resolution");
SDL_free(displayPlaneProperties); SDL_free(displayPlaneProperties);
goto error; goto error;
@ -509,8 +472,7 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
SDL_free(physicalDevices); SDL_free(physicalDevices);
physicalDevices = NULL; physicalDevices = NULL;
if (physicalDeviceIndex == physicalDeviceCount) if (physicalDeviceIndex == physicalDeviceCount) {
{
SDL_SetError("No usable displays found or requested display out of range"); SDL_SetError("No usable displays found or requested display out of range");
return SDL_FALSE; return SDL_FALSE;
} }
@ -519,16 +481,14 @@ SDL_bool SDL_Vulkan_Display_CreateSurface(void *vkGetInstanceProcAddr_,
createInfo.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR; createInfo.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
createInfo.globalAlpha = 1.0f; createInfo.globalAlpha = 1.0f;
result = vkCreateDisplayPlaneSurfaceKHR(instance, &createInfo, result = vkCreateDisplayPlaneSurfaceKHR(instance, &createInfo, NULL, surface);
NULL, surface); if (result != VK_SUCCESS) {
if(result != VK_SUCCESS) SDL_SetError("vkCreateDisplayPlaneSurfaceKHR failed: %s", SDL_Vulkan_GetResultString(result));
{
SDL_SetError("vkCreateDisplayPlaneSurfaceKHR failed: %s",
SDL_Vulkan_GetResultString(result));
return SDL_FALSE; return SDL_FALSE;
} }
SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Created surface"); SDL_LogDebug(SDL_LOG_CATEGORY_VIDEO, "vulkandisplay: Created surface");
return SDL_TRUE; return SDL_TRUE;
error: error:
SDL_free(physicalDevices); SDL_free(physicalDevices);
return SDL_FALSE; return SDL_FALSE;