ShuriZma
/
dolphin
mirror of https://github.com/dolphin-emu/dolphin.git
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

Vulkan: Support runtime selection of WSI

This commit is contained in:
Stenzek 2018-10-24 14:47:48 +10:00
parent c41f32bcf8
commit f9869cb216
8 changed files with 155 additions and 179 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

78
Source/Core/VideoBackends/Vulkan/SwapChain.cpp
View File

@ -18,16 +18,12 @@
#if defined(VK_USE_PLATFORM_XLIB_KHR) #if defined(VK_USE_PLATFORM_XLIB_KHR)
#include <X11/Xlib.h> #include <X11/Xlib.h>
#elif defined(VK_USE_PLATFORM_XCB_KHR)
#include <X11/Xlib-xcb.h>
#include <X11/Xlib.h>
#endif #endif
namespace Vulkan namespace Vulkan
{ {
SwapChain::SwapChain(void* display_handle, void* native_handle, VkSurfaceKHR surface, bool vsync) SwapChain::SwapChain(const WindowSystemInfo& wsi, VkSurfaceKHR surface, bool vsync)
: m_display_handle(display_handle), m_native_handle(native_handle), m_surface(surface), : m_wsi(wsi), m_surface(surface), m_vsync_enabled(vsync)
m_vsync_enabled(vsync)
{ {
} }
@ -39,15 +35,17 @@ SwapChain::~SwapChain()
DestroySemaphores(); DestroySemaphores();
} }
VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, void* display_handle, void* hwnd) VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, const WindowSystemInfo& wsi)
{ {
#if defined(VK_USE_PLATFORM_WIN32_KHR) #if defined(VK_USE_PLATFORM_WIN32_KHR)
if (wsi.type == WindowSystemType::Windows)
{
VkWin32SurfaceCreateInfoKHR surface_create_info = { VkWin32SurfaceCreateInfoKHR surface_create_info = {
VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, // VkStructureType sType VK_STRUCTURE_TYPE_WIN32_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void* pNext nullptr, // const void* pNext
0, // VkWin32SurfaceCreateFlagsKHR flags 0, // VkWin32SurfaceCreateFlagsKHR flags
nullptr, // HINSTANCE hinstance nullptr, // HINSTANCE hinstance
reinterpret_cast<HWND>(hwnd) // HWND hwnd reinterpret_cast<HWND>(wsi.render_surface) // HWND hwnd
}; };
VkSurfaceKHR surface; VkSurfaceKHR surface;
@ -59,14 +57,18 @@ VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, void* display_h
} }
return surface; return surface;
}
#endif
#elif defined(VK_USE_PLATFORM_XLIB_KHR) #if defined(VK_USE_PLATFORM_XLIB_KHR)
if (wsi.type == WindowSystemType::X11)
{
VkXlibSurfaceCreateInfoKHR surface_create_info = { VkXlibSurfaceCreateInfoKHR surface_create_info = {
VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, // VkStructureType sType VK_STRUCTURE_TYPE_XLIB_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void* pNext nullptr, // const void* pNext
0, // VkXlibSurfaceCreateFlagsKHR flags 0, // VkXlibSurfaceCreateFlagsKHR flags
static_cast<Display*>(display_handle), // Display* dpy static_cast<Display*>(wsi.display_connection), // Display* dpy
reinterpret_cast<Window>(hwnd) // Window window reinterpret_cast<Window>(wsi.render_surface) // Window window
}; };
VkSurfaceKHR surface; VkSurfaceKHR surface;
@ -78,35 +80,17 @@ VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, void* display_h
} }
return surface; return surface;
#elif defined(VK_USE_PLATFORM_XCB_KHR)
// If we ever switch to using xcb, we should pass the display handle as well.
xcb_connection_t* connection = XGetXCBConnection(display_handle);
VkXcbSurfaceCreateInfoKHR surface_create_info = {
VK_STRUCTURE_TYPE_XCB_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void* pNext
0, // VkXcbSurfaceCreateFlagsKHR flags
connection, // xcb_connection_t* connection
static_cast<xcb_window_t>(reinterpret_cast<uintptr_t>(hwnd)) // xcb_window_t window
};
VkSurfaceKHR surface;
VkResult res = vkCreateXcbSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
if (res != VK_SUCCESS)
{
LOG_VULKAN_ERROR(res, "vkCreateXcbSurfaceKHR failed: ");
return VK_NULL_HANDLE;
} }
#endif
return surface; #if defined(VK_USE_PLATFORM_ANDROID_KHR)
if (wsi.type == WindowSystemType::Android)
#elif defined(VK_USE_PLATFORM_ANDROID_KHR) {
VkAndroidSurfaceCreateInfoKHR surface_create_info = { VkAndroidSurfaceCreateInfoKHR surface_create_info = {
VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, // VkStructureType sType VK_STRUCTURE_TYPE_ANDROID_SURFACE_CREATE_INFO_KHR, // VkStructureType sType
nullptr, // const void* pNext nullptr, // const void* pNext
0, // VkAndroidSurfaceCreateFlagsKHR flags 0, // VkAndroidSurfaceCreateFlagsKHR flags
reinterpret_cast<ANativeWindow*>(hwnd) // ANativeWindow* window reinterpret_cast<ANativeWindow*>(wsi.render_surface) // ANativeWindow* window
}; };
VkSurfaceKHR surface; VkSurfaceKHR surface;
@ -118,10 +102,14 @@ VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, void* display_h
} }
return surface; return surface;
}
#endif
#elif defined(VK_USE_PLATFORM_MACOS_MVK) #if defined(VK_USE_PLATFORM_MACOS_MVK)
if (wsi.type == WindowSystemType::MacOS)
{
VkMacOSSurfaceCreateInfoMVK surface_create_info = { VkMacOSSurfaceCreateInfoMVK surface_create_info = {
VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, nullptr, 0, hwnd}; VK_STRUCTURE_TYPE_MACOS_SURFACE_CREATE_INFO_MVK, nullptr, 0, wsi.render_surface};
VkSurfaceKHR surface; VkSurfaceKHR surface;
VkResult res = vkCreateMacOSSurfaceMVK(instance, &surface_create_info, nullptr, &surface); VkResult res = vkCreateMacOSSurfaceMVK(instance, &surface_create_info, nullptr, &surface);
@ -132,17 +120,16 @@ VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, void* display_h
} }
return surface; return surface;
#else }
return VK_NULL_HANDLE;
#endif #endif
return VK_NULL_HANDLE;
} }
std::unique_ptr<SwapChain> SwapChain::Create(void* display_handle, void* native_handle, std::unique_ptr<SwapChain> SwapChain::Create(const WindowSystemInfo& wsi, VkSurfaceKHR surface,
VkSurfaceKHR surface, bool vsync) bool vsync)
{ {
std::unique_ptr<SwapChain> swap_chain = std::unique_ptr<SwapChain> swap_chain = std::make_unique<SwapChain>(wsi, surface, vsync);
std::make_unique<SwapChain>(display_handle, native_handle, surface, vsync);
if (!swap_chain->CreateSemaphores() || !swap_chain->CreateSwapChain() || if (!swap_chain->CreateSemaphores() || !swap_chain->CreateSwapChain() ||
!swap_chain->SetupSwapChainImages()) !swap_chain->SetupSwapChainImages())
{ {
@ -531,9 +518,8 @@ bool SwapChain::RecreateSurface(void* native_handle)
DestroySurface(); DestroySurface();
// Re-create the surface with the new native handle // Re-create the surface with the new native handle
m_native_handle = native_handle; m_wsi.render_surface = native_handle;
m_surface = m_surface = CreateVulkanSurface(g_vulkan_context->GetVulkanInstance(), m_wsi);
CreateVulkanSurface(g_vulkan_context->GetVulkanInstance(), m_display_handle, native_handle);
if (m_surface == VK_NULL_HANDLE) if (m_surface == VK_NULL_HANDLE)
return false; return false;

14
Source/Core/VideoBackends/Vulkan/SwapChain.h
View File

@ -8,6 +8,7 @@
#include <vector> #include <vector>
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "Common/WindowSystemInfo.h"
#include "VideoBackends/Vulkan/Constants.h" #include "VideoBackends/Vulkan/Constants.h"
#include "VideoBackends/Vulkan/Texture2D.h" #include "VideoBackends/Vulkan/Texture2D.h"
#include "VideoCommon/TextureConfig.h" #include "VideoCommon/TextureConfig.h"
@ -20,18 +21,16 @@ class ObjectCache;
class SwapChain class SwapChain
{ {
public: public:
SwapChain(void* display_handle, void* native_handle, VkSurfaceKHR surface, bool vsync); SwapChain(const WindowSystemInfo& wsi, VkSurfaceKHR surface, bool vsync);
~SwapChain(); ~SwapChain();
// Creates a vulkan-renderable surface for the specified window handle. // Creates a vulkan-renderable surface for the specified window handle.
static VkSurfaceKHR CreateVulkanSurface(VkInstance instance, void* display_handle, void* hwnd); static VkSurfaceKHR CreateVulkanSurface(VkInstance instance, const WindowSystemInfo& wsi);
// Create a new swap chain from a pre-existing surface. // Create a new swap chain from a pre-existing surface.
static std::unique_ptr<SwapChain> Create(void* display_handle, void* native_handle, static std::unique_ptr<SwapChain> Create(const WindowSystemInfo& wsi, VkSurfaceKHR surface,
VkSurfaceKHR surface, bool vsync); bool vsync);
void* GetDisplayHandle() const { return m_display_handle; }
void* GetNativeHandle() const { return m_native_handle; }
VkSurfaceKHR GetSurface() const { return m_surface; } VkSurfaceKHR GetSurface() const { return m_surface; }
VkSurfaceFormatKHR GetSurfaceFormat() const { return m_surface_format; } VkSurfaceFormatKHR GetSurfaceFormat() const { return m_surface_format; }
AbstractTextureFormat GetTextureFormat() const { return m_texture_format; } AbstractTextureFormat GetTextureFormat() const { return m_texture_format; }
@ -89,8 +88,7 @@ private:
VkFramebuffer framebuffer; VkFramebuffer framebuffer;
}; };
void* m_display_handle; WindowSystemInfo m_wsi;
void* m_native_handle;
VkSurfaceKHR m_surface = VK_NULL_HANDLE; VkSurfaceKHR m_surface = VK_NULL_HANDLE;
VkSurfaceFormatKHR m_surface_format = {}; VkSurfaceFormatKHR m_surface_format = {};
VkPresentModeKHR m_present_mode = VK_PRESENT_MODE_RANGE_SIZE_KHR; VkPresentModeKHR m_present_mode = VK_PRESENT_MODE_RANGE_SIZE_KHR;

43
Source/Core/VideoBackends/Vulkan/VulkanContext.cpp
View File

@ -84,11 +84,11 @@ bool VulkanContext::CheckValidationLayerAvailablility()
}) != layer_list.end()); }) != layer_list.end());
} }
VkInstance VulkanContext::CreateVulkanInstance(bool enable_surface, bool enable_debug_report, VkInstance VulkanContext::CreateVulkanInstance(WindowSystemType wstype, bool enable_debug_report,
bool enable_validation_layer) bool enable_validation_layer)
{ {
ExtensionList enabled_extensions; ExtensionList enabled_extensions;
if (!SelectInstanceExtensions(&enabled_extensions, enable_surface, enable_debug_report)) if (!SelectInstanceExtensions(&enabled_extensions, wstype, enable_debug_report))
return VK_NULL_HANDLE; return VK_NULL_HANDLE;
VkApplicationInfo app_info = {}; VkApplicationInfo app_info = {};
@ -129,7 +129,7 @@ VkInstance VulkanContext::CreateVulkanInstance(bool enable_surface, bool enable_
return instance; return instance;
} }
bool VulkanContext::SelectInstanceExtensions(ExtensionList* extension_list, bool enable_surface, bool VulkanContext::SelectInstanceExtensions(ExtensionList* extension_list, WindowSystemType wstype,
bool enable_debug_report) bool enable_debug_report)
{ {
u32 extension_count = 0; u32 extension_count = 0;
@ -172,24 +172,39 @@ bool VulkanContext::SelectInstanceExtensions(ExtensionList* extension_list, bool
}; };
// Common extensions // Common extensions
if (enable_surface && !SupportsExtension(VK_KHR_SURFACE_EXTENSION_NAME, true)) if (wstype != WindowSystemType::Headless &&
!SupportsExtension(VK_KHR_SURFACE_EXTENSION_NAME, true))
{
return false; return false;
}
#if defined(VK_USE_PLATFORM_WIN32_KHR) #if defined(VK_USE_PLATFORM_WIN32_KHR)
if (enable_surface && !SupportsExtension(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, true)) if (wstype == WindowSystemType::Windows &&
!SupportsExtension(VK_KHR_WIN32_SURFACE_EXTENSION_NAME, true))
{
return false; return false;
#elif defined(VK_USE_PLATFORM_XLIB_KHR) }
if (enable_surface && !SupportsExtension(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, true)) #endif
#if defined(VK_USE_PLATFORM_XLIB_KHR)
if (wstype == WindowSystemType::X11 &&
!SupportsExtension(VK_KHR_XLIB_SURFACE_EXTENSION_NAME, true))
{
return false; return false;
#elif defined(VK_USE_PLATFORM_XCB_KHR) }
if (enable_surface && !SupportsExtension(VK_KHR_XCB_SURFACE_EXTENSION_NAME, true)) #endif
#if defined(VK_USE_PLATFORM_ANDROID_KHR)
if (wstype == WindowSystemType::Android &&
!SupportsExtension(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, true))
{
return false; return false;
#elif defined(VK_USE_PLATFORM_ANDROID_KHR) }
if (enable_surface && !SupportsExtension(VK_KHR_ANDROID_SURFACE_EXTENSION_NAME, true)) #endif
return false; #if defined(VK_USE_PLATFORM_MACOS_MVK)
#elif defined(VK_USE_PLATFORM_MACOS_MVK) if (wstype == WindowSystemType::MacOS &&
if (enable_surface && !SupportsExtension(VK_MVK_MACOS_SURFACE_EXTENSION_NAME, true)) !SupportsExtension(VK_MVK_MACOS_SURFACE_EXTENSION_NAME, true))
{
return false; return false;
}
#endif #endif
// VK_EXT_debug_report // VK_EXT_debug_report

5
Source/Core/VideoBackends/Vulkan/VulkanContext.h
View File

@ -8,6 +8,7 @@
#include <vector> #include <vector>
#include "Common/CommonTypes.h" #include "Common/CommonTypes.h"
#include "Common/WindowSystemInfo.h"
#include "VideoBackends/Vulkan/Constants.h" #include "VideoBackends/Vulkan/Constants.h"
#include "VideoCommon/VideoConfig.h" #include "VideoCommon/VideoConfig.h"
@ -23,7 +24,7 @@ public:
static bool CheckValidationLayerAvailablility(); static bool CheckValidationLayerAvailablility();
// Helper method to create a Vulkan instance. // Helper method to create a Vulkan instance.
static VkInstance CreateVulkanInstance(bool enable_surface, bool enable_debug_report, static VkInstance CreateVulkanInstance(WindowSystemType wstype, bool enable_debug_report,
bool enable_validation_layer); bool enable_validation_layer);
// Returns a list of Vulkan-compatible GPUs. // Returns a list of Vulkan-compatible GPUs.
@ -109,7 +110,7 @@ public:
private: private:
using ExtensionList = std::vector<const char*>; using ExtensionList = std::vector<const char*>;
static bool SelectInstanceExtensions(ExtensionList* extension_list, bool enable_surface, static bool SelectInstanceExtensions(ExtensionList* extension_list, WindowSystemType wstype,
bool enable_debug_report); bool enable_debug_report);
bool SelectDeviceExtensions(ExtensionList* extension_list, bool enable_surface); bool SelectDeviceExtensions(ExtensionList* extension_list, bool enable_surface);
bool SelectDeviceFeatures(); bool SelectDeviceFeatures();

19
Source/Core/VideoBackends/Vulkan/VulkanEntryPoints.inl
View File

@ -39,28 +39,21 @@ VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceSurfaceFormatsKHR, false)
VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceSurfacePresentModesKHR, false) VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceSurfacePresentModesKHR, false)
#if defined(VK_USE_PLATFORM_WIN32_KHR) #if defined(VK_USE_PLATFORM_WIN32_KHR)
VULKAN_INSTANCE_ENTRY_POINT(vkCreateWin32SurfaceKHR, false) VULKAN_INSTANCE_ENTRY_POINT(vkCreateWin32SurfaceKHR, false)
VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceWin32PresentationSupportKHR, false) VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceWin32PresentationSupportKHR, false)
#endif
#elif defined(VK_USE_PLATFORM_XLIB_KHR) #if defined(VK_USE_PLATFORM_XLIB_KHR)
VULKAN_INSTANCE_ENTRY_POINT(vkCreateXlibSurfaceKHR, false) VULKAN_INSTANCE_ENTRY_POINT(vkCreateXlibSurfaceKHR, false)
VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceXlibPresentationSupportKHR, false) VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceXlibPresentationSupportKHR, false)
#endif
#elif defined(VK_USE_PLATFORM_XCB_KHR) #if defined(VK_USE_PLATFORM_ANDROID_KHR)
VULKAN_INSTANCE_ENTRY_POINT(vkCreateXcbSurfaceKHR, false)
VULKAN_INSTANCE_ENTRY_POINT(vkGetPhysicalDeviceXcbPresentationSupportKHR, false)
#elif defined(VK_USE_PLATFORM_ANDROID_KHR)
VULKAN_INSTANCE_ENTRY_POINT(vkCreateAndroidSurfaceKHR, false) VULKAN_INSTANCE_ENTRY_POINT(vkCreateAndroidSurfaceKHR, false)
#endif
#elif defined(VK_USE_PLATFORM_MACOS_MVK) #if defined(VK_USE_PLATFORM_MACOS_MVK)
VULKAN_INSTANCE_ENTRY_POINT(vkCreateMacOSSurfaceMVK, false) VULKAN_INSTANCE_ENTRY_POINT(vkCreateMacOSSurfaceMVK, false)
#endif #endif
VULKAN_INSTANCE_ENTRY_POINT(vkCreateDebugReportCallbackEXT, false) VULKAN_INSTANCE_ENTRY_POINT(vkCreateDebugReportCallbackEXT, false)

26
Source/Core/VideoBackends/Vulkan/VulkanLoader.cpp
View File

@ -13,11 +13,9 @@
#include "VideoBackends/Vulkan/VulkanLoader.h" #include "VideoBackends/Vulkan/VulkanLoader.h"
#if defined(VK_USE_PLATFORM_WIN32_KHR) #if defined(_WIN32)
#include <Windows.h> #include <Windows.h>
#elif defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_XCB_KHR) || \ #else
defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(VK_USE_PLATFORM_MACOS_MVK) || \
defined(USE_HEADLESS)
#include <dlfcn.h> #include <dlfcn.h>
#endif #endif
@ -42,7 +40,7 @@ static void ResetVulkanLibraryFunctionPointers()
#undef VULKAN_MODULE_ENTRY_POINT #undef VULKAN_MODULE_ENTRY_POINT
} }
#if defined(VK_USE_PLATFORM_WIN32_KHR) #if defined(_WIN32)
static HMODULE vulkan_module; static HMODULE vulkan_module;
static std::atomic_int vulkan_module_ref_count = {0}; static std::atomic_int vulkan_module_ref_count = {0};
@ -100,9 +98,7 @@ void UnloadVulkanLibrary()
vulkan_module = nullptr; vulkan_module = nullptr;
} }
#elif defined(VK_USE_PLATFORM_XLIB_KHR) || defined(VK_USE_PLATFORM_XCB_KHR) || \ #else
defined(VK_USE_PLATFORM_ANDROID_KHR) || defined(VK_USE_PLATFORM_MACOS_MVK) || \
defined(USE_HEADLESS)
static void* vulkan_module; static void* vulkan_module;
static std::atomic_int vulkan_module_ref_count = {0}; static std::atomic_int vulkan_module_ref_count = {0};
@ -181,20 +177,6 @@ void UnloadVulkanLibrary()
vulkan_module = nullptr; vulkan_module = nullptr;
} }
#else
//#warning Unknown platform, not compiling loader.
bool LoadVulkanLibrary()
{
return false;
}
void UnloadVulkanLibrary()
{
ResetVulkanLibraryFunctionPointers();
}
#endif #endif
bool LoadVulkanInstanceFunctions(VkInstance instance) bool LoadVulkanInstanceFunctions(VkInstance instance)

17
Source/Core/VideoBackends/Vulkan/VulkanLoader.h
View File

@ -8,17 +8,18 @@
#if defined(WIN32) #if defined(WIN32)
#define VK_USE_PLATFORM_WIN32_KHR #define VK_USE_PLATFORM_WIN32_KHR
#elif defined(HAVE_X11) #endif
// Currently we're getting xlib handles passed to the backend.
// If this ever changes to xcb, it's a simple change here. #if defined(HAVE_X11)
#define VK_USE_PLATFORM_XLIB_KHR #define VK_USE_PLATFORM_XLIB_KHR
//#define VK_USE_PLATFORM_XCB_KHR #endif
#elif defined(ANDROID)
#if defined(ANDROID)
#define VK_USE_PLATFORM_ANDROID_KHR #define VK_USE_PLATFORM_ANDROID_KHR
#elif defined(__APPLE__) #endif
#if defined(__APPLE__)
#define VK_USE_PLATFORM_MACOS_MVK #define VK_USE_PLATFORM_MACOS_MVK
#else
//#warning Unknown platform
#endif #endif
#include "vulkan/vulkan.h" #include "vulkan/vulkan.h"

14
Source/Core/VideoBackends/Vulkan/main.cpp
View File

@ -36,7 +36,8 @@ void VideoBackend::InitBackendInfo()
if (LoadVulkanLibrary()) if (LoadVulkanLibrary())
{ {
VkInstance temp_instance = VulkanContext::CreateVulkanInstance(false, false, false); VkInstance temp_instance =
VulkanContext::CreateVulkanInstance(WindowSystemType::Headless, false, false);
if (temp_instance) if (temp_instance)
{ {
if (LoadVulkanInstanceFunctions(temp_instance)) if (LoadVulkanInstanceFunctions(temp_instance))
@ -111,10 +112,10 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
// Create Vulkan instance, needed before we can create a surface, or enumerate devices. // Create Vulkan instance, needed before we can create a surface, or enumerate devices.
// We use this instance to fill in backend info, then re-use it for the actual device. // We use this instance to fill in backend info, then re-use it for the actual device.
bool enable_surface = wsi.render_surface != nullptr; bool enable_surface = wsi.type != WindowSystemType::Headless;
bool enable_debug_reports = ShouldEnableDebugReports(enable_validation_layer); bool enable_debug_reports = ShouldEnableDebugReports(enable_validation_layer);
VkInstance instance = VulkanContext::CreateVulkanInstance(enable_surface, enable_debug_reports, VkInstance instance =
enable_validation_layer); VulkanContext::CreateVulkanInstance(wsi.type, enable_debug_reports, enable_validation_layer);
if (instance == VK_NULL_HANDLE) if (instance == VK_NULL_HANDLE)
{ {
PanicAlert("Failed to create Vulkan instance."); PanicAlert("Failed to create Vulkan instance.");
@ -150,7 +151,7 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
VkSurfaceKHR surface = VK_NULL_HANDLE; VkSurfaceKHR surface = VK_NULL_HANDLE;
if (enable_surface) if (enable_surface)
{ {
surface = SwapChain::CreateVulkanSurface(instance, wsi.display_connection, wsi.render_surface); surface = SwapChain::CreateVulkanSurface(instance, wsi);
if (surface == VK_NULL_HANDLE) if (surface == VK_NULL_HANDLE)
{ {
PanicAlert("Failed to create Vulkan surface."); PanicAlert("Failed to create Vulkan surface.");
@ -213,8 +214,7 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
std::unique_ptr<SwapChain> swap_chain; std::unique_ptr<SwapChain> swap_chain;
if (surface != VK_NULL_HANDLE) if (surface != VK_NULL_HANDLE)
{ {
swap_chain = SwapChain::Create(wsi.display_connection, wsi.render_surface, surface, swap_chain = SwapChain::Create(wsi, surface, g_ActiveConfig.bVSyncActive);
g_ActiveConfig.bVSyncActive);
if (!swap_chain) if (!swap_chain)
{ {
PanicAlert("Failed to create Vulkan swap chain."); PanicAlert("Failed to create Vulkan swap chain.");