|
|
@@ -0,0 +1,267 @@
|
|
|
+/*
|
|
|
+ Simple DirectMedia Layer
|
|
|
+ Copyright (C) 1997-2024 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
|
|
|
+ arising from the use of this software.
|
|
|
+
|
|
|
+ Permission is granted to anyone to use this software for any purpose,
|
|
|
+ including commercial applications, and to alter it and redistribute it
|
|
|
+ freely, subject to the following restrictions:
|
|
|
+
|
|
|
+ 1. The origin of this software must not be misrepresented; you must not
|
|
|
+ claim that you wrote the original software. If you use this software
|
|
|
+ in a product, an acknowledgment in the product documentation would be
|
|
|
+ appreciated but is not required.
|
|
|
+ 2. Altered source versions must be plainly marked as such, and must not be
|
|
|
+ misrepresented as being the original software.
|
|
|
+ 3. This notice may not be removed or altered from any source distribution.
|
|
|
+*/
|
|
|
+#include "SDL_internal.h"
|
|
|
+
|
|
|
+#if defined(SDL_VIDEO_VULKAN) && defined(SDL_VIDEO_DRIVER_OFFSCREEN)
|
|
|
+
|
|
|
+#include "../SDL_sysvideo.h"
|
|
|
+#include "../SDL_vulkan_internal.h"
|
|
|
+
|
|
|
+
|
|
|
+static const char *s_defaultPaths[] = {
|
|
|
+#if defined(SDL_PLATFORM_WINDOWS)
|
|
|
+ "vulkan-1.dll"
|
|
|
+#elif defined(SDL_PLATFORM_APPLE)
|
|
|
+ "vulkan.framework/vulkan",
|
|
|
+ "libvulkan.1.dylib",
|
|
|
+ "libvulkan.dylib",
|
|
|
+ "MoltenVK.framework/MoltenVK",
|
|
|
+ "libMoltenVK.dylib"
|
|
|
+#elif defined(SDL_PLATFORM_OPENBSD)
|
|
|
+ "libvulkan.so"
|
|
|
+#else
|
|
|
+ "libvulkan.so.1"
|
|
|
+#endif
|
|
|
+};
|
|
|
+
|
|
|
+#if defined( SDL_PLATFORM_APPLE )
|
|
|
+#include <dlfcn.h>
|
|
|
+
|
|
|
+/* Since libSDL is most likely a .dylib, need RTLD_DEFAULT not RTLD_SELF. */
|
|
|
+#define DEFAULT_HANDLE RTLD_DEFAULT
|
|
|
+#endif
|
|
|
+
|
|
|
+/*Should the whole driver fail if it can't create a surface? Rendering to an offscreen buffer is still possible without a surface.
|
|
|
+ At the time of writing. I need the driver to minimally work even if the surface extension isn't present.
|
|
|
+ And account for the inability to create a surface on the consumer side.
|
|
|
+ So for now I'm targeting my specific use case -Dave Kircher*/
|
|
|
+#define HEADLESS_SURFACE_EXTENSION_REQUIRED_TO_LOAD 0
|
|
|
+
|
|
|
+
|
|
|
+int OFFSCREEN_Vulkan_LoadLibrary(SDL_VideoDevice *_this, const char *path)
|
|
|
+{
|
|
|
+ VkExtensionProperties *extensions = NULL;
|
|
|
+ Uint32 extensionCount = 0;
|
|
|
+ SDL_bool hasSurfaceExtension = SDL_FALSE;
|
|
|
+ SDL_bool hasHeadlessSurfaceExtension = SDL_FALSE;
|
|
|
+ PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr = NULL;
|
|
|
+ Uint32 i;
|
|
|
+ const char **paths;
|
|
|
+ const char *foundPath = NULL;
|
|
|
+ Uint32 numPaths;
|
|
|
+
|
|
|
+ if (_this->vulkan_config.loader_handle) {
|
|
|
+ return SDL_SetError("Vulkan already loaded");
|
|
|
+ }
|
|
|
+
|
|
|
+ /* Load the Vulkan loader library */
|
|
|
+ if (!path) {
|
|
|
+ path = SDL_getenv("SDL_VULKAN_LIBRARY");
|
|
|
+ }
|
|
|
+
|
|
|
+#if defined(SDL_PLATFORM_APPLE)
|
|
|
+ if (!path) {
|
|
|
+ /* Handle the case where Vulkan Portability is linked statically. */
|
|
|
+ vkGetInstanceProcAddr =
|
|
|
+ (PFN_vkGetInstanceProcAddr)dlsym(DEFAULT_HANDLE,
|
|
|
+ "vkGetInstanceProcAddr");
|
|
|
+ }
|
|
|
+
|
|
|
+ if (vkGetInstanceProcAddr) {
|
|
|
+ _this->vulkan_config.loader_handle = DEFAULT_HANDLE;
|
|
|
+ } else
|
|
|
+#endif
|
|
|
+ {
|
|
|
+ if (path) {
|
|
|
+ paths = &path;
|
|
|
+ numPaths = 1;
|
|
|
+ } else {
|
|
|
+ paths = s_defaultPaths;
|
|
|
+ numPaths = SDL_arraysize(s_defaultPaths);
|
|
|
+ }
|
|
|
+
|
|
|
+ for (i = 0; i < numPaths && _this->vulkan_config.loader_handle == NULL; i++) {
|
|
|
+ foundPath = paths[i];
|
|
|
+ _this->vulkan_config.loader_handle = SDL_LoadObject(foundPath);
|
|
|
+ }
|
|
|
+
|
|
|
+ if (_this->vulkan_config.loader_handle == NULL) {
|
|
|
+ return SDL_SetError("Failed to load Vulkan Portability library");
|
|
|
+ }
|
|
|
+
|
|
|
+ SDL_strlcpy(_this->vulkan_config.loader_path, foundPath,
|
|
|
+ SDL_arraysize(_this->vulkan_config.loader_path));
|
|
|
+ vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)SDL_LoadFunction(
|
|
|
+ _this->vulkan_config.loader_handle, "vkGetInstanceProcAddr");
|
|
|
+
|
|
|
+ if (!vkGetInstanceProcAddr) {
|
|
|
+ SDL_SetError("Failed to load vkGetInstanceProcAddr from Vulkan Portability library");
|
|
|
+ goto fail;
|
|
|
+ }
|
|
|
+ }
|
|
|
+
|
|
|
+ _this->vulkan_config.vkGetInstanceProcAddr = (void *)vkGetInstanceProcAddr;
|
|
|
+ _this->vulkan_config.vkEnumerateInstanceExtensionProperties =
|
|
|
+ (void *)((PFN_vkGetInstanceProcAddr)_this->vulkan_config.vkGetInstanceProcAddr)(
|
|
|
+ VK_NULL_HANDLE, "vkEnumerateInstanceExtensionProperties");
|
|
|
+ if (!_this->vulkan_config.vkEnumerateInstanceExtensionProperties) {
|
|
|
+ goto fail;
|
|
|
+ }
|
|
|
+ extensions = SDL_Vulkan_CreateInstanceExtensionsList(
|
|
|
+ (PFN_vkEnumerateInstanceExtensionProperties)
|
|
|
+ _this->vulkan_config.vkEnumerateInstanceExtensionProperties,
|
|
|
+ &extensionCount);
|
|
|
+ if (!extensions) {
|
|
|
+ goto fail;
|
|
|
+ }
|
|
|
+ for (i = 0; i < extensionCount; i++) {
|
|
|
+ if (SDL_strcmp(VK_KHR_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) {
|
|
|
+ hasSurfaceExtension = SDL_TRUE;
|
|
|
+ } else if (SDL_strcmp(VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME, extensions[i].extensionName) == 0) {
|
|
|
+ hasHeadlessSurfaceExtension = SDL_TRUE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ SDL_free(extensions);
|
|
|
+ if (!hasSurfaceExtension) {
|
|
|
+ SDL_SetError("Installed Vulkan doesn't implement the " VK_KHR_SURFACE_EXTENSION_NAME " extension");
|
|
|
+ goto fail;
|
|
|
+ }
|
|
|
+ if (!hasHeadlessSurfaceExtension) {
|
|
|
+#if (HEADLESS_SURFACE_EXTENSION_REQUIRED_TO_LOAD != 0)
|
|
|
+ SDL_SetError("Installed Vulkan doesn't implement the " VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME " extension");
|
|
|
+ goto fail;
|
|
|
+#else
|
|
|
+ /*Let's at least leave a breadcrumb for people to find if they have issues*/
|
|
|
+ SDL_Log("Installed Vulkan doesn't implement the " VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME " extension");
|
|
|
+#endif
|
|
|
+ }
|
|
|
+ return 0;
|
|
|
+
|
|
|
+fail:
|
|
|
+ SDL_UnloadObject(_this->vulkan_config.loader_handle);
|
|
|
+ _this->vulkan_config.loader_handle = NULL;
|
|
|
+ return -1;
|
|
|
+}
|
|
|
+
|
|
|
+void OFFSCREEN_Vulkan_UnloadLibrary(SDL_VideoDevice *_this)
|
|
|
+{
|
|
|
+ if (_this->vulkan_config.loader_handle) {
|
|
|
+ SDL_UnloadObject(_this->vulkan_config.loader_handle);
|
|
|
+ _this->vulkan_config.loader_handle = NULL;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+char const *const *OFFSCREEN_Vulkan_GetInstanceExtensions(SDL_VideoDevice *_this,
|
|
|
+ Uint32 *count)
|
|
|
+{
|
|
|
+#if (HEADLESS_SURFACE_EXTENSION_REQUIRED_TO_LOAD == 0)
|
|
|
+ VkExtensionProperties *enumerateExtensions = NULL;
|
|
|
+ Uint32 enumerateExtensionCount = 0;
|
|
|
+ SDL_bool hasHeadlessSurfaceExtension = SDL_FALSE;
|
|
|
+ Uint32 i;
|
|
|
+#endif
|
|
|
+
|
|
|
+ static const char *const returnExtensions[] = { VK_KHR_SURFACE_EXTENSION_NAME, VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME };
|
|
|
+ if (count) {
|
|
|
+# if (HEADLESS_SURFACE_EXTENSION_REQUIRED_TO_LOAD == 0)
|
|
|
+ {
|
|
|
+ /* In optional mode, only return VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME if it's already supported by the instance
|
|
|
+ There's probably a better way to cache the presence of the extension during OFFSCREEN_Vulkan_LoadLibrary().
|
|
|
+ But both SDL_VideoData and SDL_VideoDevice::vulkan_config seem like I'd need to touch a bunch of code to do properly.
|
|
|
+ And I want a smaller footprint for the first pass*/
|
|
|
+ if ( _this->vulkan_config.vkEnumerateInstanceExtensionProperties ) {
|
|
|
+ enumerateExtensions = SDL_Vulkan_CreateInstanceExtensionsList(
|
|
|
+ (PFN_vkEnumerateInstanceExtensionProperties)
|
|
|
+ _this->vulkan_config.vkEnumerateInstanceExtensionProperties,
|
|
|
+ &enumerateExtensionCount);
|
|
|
+ for (i = 0; i < enumerateExtensionCount; i++) {
|
|
|
+ if (SDL_strcmp(VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME, enumerateExtensions[i].extensionName) == 0) {
|
|
|
+ hasHeadlessSurfaceExtension = SDL_TRUE;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ SDL_free(enumerateExtensions);
|
|
|
+ }
|
|
|
+ if ( hasHeadlessSurfaceExtension == SDL_TRUE ) {
|
|
|
+ *count = SDL_arraysize(returnExtensions);
|
|
|
+ } else {
|
|
|
+ *count = SDL_arraysize(returnExtensions) - 1; /*assumes VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME is last*/
|
|
|
+ }
|
|
|
+ }
|
|
|
+# else
|
|
|
+ {
|
|
|
+ *count = SDL_arraysize(returnExtensions);
|
|
|
+ }
|
|
|
+# endif
|
|
|
+ }
|
|
|
+ return returnExtensions;
|
|
|
+}
|
|
|
+
|
|
|
+SDL_bool OFFSCREEN_Vulkan_CreateSurface(SDL_VideoDevice *_this,
|
|
|
+ SDL_Window *window,
|
|
|
+ VkInstance instance,
|
|
|
+ const struct VkAllocationCallbacks *allocator,
|
|
|
+ VkSurfaceKHR *surface)
|
|
|
+{
|
|
|
+ surface = NULL;
|
|
|
+
|
|
|
+ PFN_vkGetInstanceProcAddr vkGetInstanceProcAddr;
|
|
|
+ if (!_this->vulkan_config.loader_handle) {
|
|
|
+ SDL_SetError("Vulkan is not loaded");
|
|
|
+ return SDL_FALSE;
|
|
|
+ }
|
|
|
+ vkGetInstanceProcAddr = (PFN_vkGetInstanceProcAddr)_this->vulkan_config.vkGetInstanceProcAddr;
|
|
|
+ {
|
|
|
+ PFN_vkCreateHeadlessSurfaceEXT vkCreateHeadlessSurfaceEXT =
|
|
|
+ (PFN_vkCreateHeadlessSurfaceEXT)vkGetInstanceProcAddr(instance,
|
|
|
+ "vkCreateHeadlessSurfaceEXT");
|
|
|
+ VkHeadlessSurfaceCreateInfoEXT createInfo;
|
|
|
+ VkResult result;
|
|
|
+ if (!vkCreateHeadlessSurfaceEXT) {
|
|
|
+ /*This may be surprising to the consumer when HEADLESS_SURFACE_EXTENSION_REQUIRED_TO_LOAD == 0
|
|
|
+ But this is the tradeoff for allowing offscreen rendering to a buffer to continue working without requiring the extension during driver load*/
|
|
|
+ SDL_SetError(VK_EXT_HEADLESS_SURFACE_EXTENSION_NAME
|
|
|
+ " extension is not enabled in the Vulkan instance.");
|
|
|
+ return SDL_FALSE;
|
|
|
+ }
|
|
|
+ SDL_zero(createInfo);
|
|
|
+ createInfo.sType = VK_STRUCTURE_TYPE_HEADLESS_SURFACE_CREATE_INFO_EXT;
|
|
|
+ createInfo.pNext = NULL;
|
|
|
+ createInfo.flags = 0;
|
|
|
+ result = vkCreateHeadlessSurfaceEXT(instance, &createInfo, allocator, surface);
|
|
|
+ if (result != VK_SUCCESS) {
|
|
|
+ SDL_SetError("vkCreateHeadlessSurfaceEXT failed: %s", SDL_Vulkan_GetResultString(result));
|
|
|
+ return SDL_FALSE;
|
|
|
+ }
|
|
|
+ return SDL_TRUE;
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+void OFFSCREEN_Vulkan_DestroySurface(SDL_VideoDevice *_this,
|
|
|
+ VkInstance instance,
|
|
|
+ VkSurfaceKHR surface,
|
|
|
+ const struct VkAllocationCallbacks *allocator)
|
|
|
+{
|
|
|
+ if (_this->vulkan_config.loader_handle) {
|
|
|
+ SDL_Vulkan_DestroySurface_Internal(_this->vulkan_config.vkGetInstanceProcAddr, instance, surface, allocator);
|
|
|
+ }
|
|
|
+}
|
|
|
+
|
|
|
+#endif
|
Sam Lantinga