diff --git a/CMakeLists.txt b/CMakeLists.txt
index d9805c8779..09456ae554 100644
--- a/CMakeLists.txt
+++ b/CMakeLists.txt
@@ -2907,7 +2907,7 @@ endif()
# Platform-independent options
if(SDL_VIDEO)
- if(SDL_OFFSCREEN AND SDL_VIDEO_OPENGL_EGL)
+ if(SDL_OFFSCREEN)
set(SDL_VIDEO_DRIVER_OFFSCREEN 1)
sdl_glob_sources("${SDL3_SOURCE_DIR}/src/video/offscreen/*.c")
set(HAVE_OFFSCREEN TRUE)
diff --git a/VisualC/SDL/SDL.vcxproj b/VisualC/SDL/SDL.vcxproj
index e0b31fe5e2..95f782b518 100644
--- a/VisualC/SDL/SDL.vcxproj
+++ b/VisualC/SDL/SDL.vcxproj
@@ -447,6 +447,12 @@
+
+
+
+
+
+
@@ -656,6 +662,12 @@
+
+
+
+
+
+
diff --git a/VisualC/SDL/SDL.vcxproj.filters b/VisualC/SDL/SDL.vcxproj.filters
index 103ce22d25..c38962d176 100644
--- a/VisualC/SDL/SDL.vcxproj.filters
+++ b/VisualC/SDL/SDL.vcxproj.filters
@@ -199,6 +199,9 @@
{00008dfdfa0190856fbf3c7db52d0000}
+
+ {748cf015-00b8-4e71-ac48-02e947e4d93d}
+
@@ -871,6 +874,24 @@
render\vulkan
+
+ video\offscreen
+
+
+ video\offscreen
+
+
+ video\offscreen
+
+
+ video\offscreen
+
+
+ video\offscreen
+
+
+ video\offscreen
+
@@ -1479,6 +1500,24 @@
render\vulkan
+
+ video\offscreen
+
+
+ video\offscreen
+
+
+ video\offscreen
+
+
+ video\offscreen
+
+
+ video\offscreen
+
+
+ video\offscreen
+
diff --git a/include/build_config/SDL_build_config_macos.h b/include/build_config/SDL_build_config_macos.h
index ea7eb56a6f..02cd3ae4c3 100644
--- a/include/build_config/SDL_build_config_macos.h
+++ b/include/build_config/SDL_build_config_macos.h
@@ -183,6 +183,7 @@
/* Enable various video drivers */
#define SDL_VIDEO_DRIVER_COCOA 1
#define SDL_VIDEO_DRIVER_DUMMY 1
+#define SDL_VIDEO_DRIVER_OFFSCREEN 1
#undef SDL_VIDEO_DRIVER_X11
#define SDL_VIDEO_DRIVER_X11_DYNAMIC "/opt/X11/lib/libX11.6.dylib"
#define SDL_VIDEO_DRIVER_X11_DYNAMIC_XEXT "/opt/X11/lib/libXext.6.dylib"
diff --git a/include/build_config/SDL_build_config_windows.h b/include/build_config/SDL_build_config_windows.h
index 92ca5f11bf..f147afe0c2 100644
--- a/include/build_config/SDL_build_config_windows.h
+++ b/include/build_config/SDL_build_config_windows.h
@@ -268,7 +268,8 @@ typedef unsigned int uintptr_t;
#define SDL_TIMER_WINDOWS 1
/* Enable various video drivers */
-#define SDL_VIDEO_DRIVER_DUMMY 1
+#define SDL_VIDEO_DRIVER_DUMMY 1
+#define SDL_VIDEO_DRIVER_OFFSCREEN 1
#define SDL_VIDEO_DRIVER_WINDOWS 1
#ifndef SDL_VIDEO_RENDER_D3D
diff --git a/src/video/offscreen/SDL_offscreenvideo.c b/src/video/offscreen/SDL_offscreenvideo.c
index 6e659ca99e..9d2cec86fc 100644
--- a/src/video/offscreen/SDL_offscreenvideo.c
+++ b/src/video/offscreen/SDL_offscreenvideo.c
@@ -34,6 +34,7 @@
#include "SDL_offscreenevents_c.h"
#include "SDL_offscreenframebuffer_c.h"
#include "SDL_offscreenopengles.h"
+#include "SDL_offscreenvulkan.h"
#include "SDL_offscreenwindow.h"
#define OFFSCREENVID_DRIVER_NAME "offscreen"
@@ -83,6 +84,14 @@ static SDL_VideoDevice *OFFSCREEN_CreateDevice(void)
device->GL_SetSwapInterval = OFFSCREEN_GLES_SetSwapInterval;
#endif
+#ifdef SDL_VIDEO_VULKAN
+ device->Vulkan_LoadLibrary = OFFSCREEN_Vulkan_LoadLibrary;
+ device->Vulkan_UnloadLibrary = OFFSCREEN_Vulkan_UnloadLibrary;
+ device->Vulkan_GetInstanceExtensions = OFFSCREEN_Vulkan_GetInstanceExtensions;
+ device->Vulkan_CreateSurface = OFFSCREEN_Vulkan_CreateSurface;
+ device->Vulkan_DestroySurface = OFFSCREEN_Vulkan_DestroySurface;
+#endif
+
/* "Window" */
device->CreateSDLWindow = OFFSCREEN_CreateWindow;
device->DestroyWindow = OFFSCREEN_DestroyWindow;
diff --git a/src/video/offscreen/SDL_offscreenvulkan.c b/src/video/offscreen/SDL_offscreenvulkan.c
new file mode 100644
index 0000000000..bf5c7910ff
--- /dev/null
+++ b/src/video/offscreen/SDL_offscreenvulkan.c
@@ -0,0 +1,267 @@
+/*
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2024 Sam Lantinga
+
+ 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
+
+/* 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
diff --git a/src/video/offscreen/SDL_offscreenvulkan.h b/src/video/offscreen/SDL_offscreenvulkan.h
new file mode 100644
index 0000000000..bbcafa5f2a
--- /dev/null
+++ b/src/video/offscreen/SDL_offscreenvulkan.h
@@ -0,0 +1,38 @@
+/*
+ Simple DirectMedia Layer
+ Copyright (C) 1997-2024 Sam Lantinga
+
+ 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"
+
+#ifndef SDL_offscreenvulkan_h
+#define SDL_offscreenvulkan_h
+
+#if defined(SDL_VIDEO_DRIVER_OFFSCREEN) && defined(SDL_VIDEO_VULKAN)
+
+#include "../SDL_sysvideo.h"
+
+extern int OFFSCREEN_Vulkan_LoadLibrary(SDL_VideoDevice *_this, const char *path);
+extern void OFFSCREEN_Vulkan_UnloadLibrary(SDL_VideoDevice *_this);
+extern char const *const *OFFSCREEN_Vulkan_GetInstanceExtensions(SDL_VideoDevice *_this, Uint32 *count);
+extern SDL_bool OFFSCREEN_Vulkan_CreateSurface(SDL_VideoDevice *_this, SDL_Window *window, VkInstance instance, const struct VkAllocationCallbacks *allocator, VkSurfaceKHR *surface);
+extern void OFFSCREEN_Vulkan_DestroySurface(SDL_VideoDevice *_this, VkInstance instance, VkSurfaceKHR surface, const struct VkAllocationCallbacks *allocator);
+
+#endif /* SDL_VIDEO_DRIVER_OFFSCREEN && SDL_VIDEO_VULKAN */
+
+#endif /* SDL_offscreenvulkan_h */