Vulkan DRM/KMS Support

CMakeLists.txt

@@ -105,6 +105,7 @@ option(USE_DISCORD_PRESENCE "Enables Discord Rich Presence, show the current gam
 option(USE_MGBA "Enables GBA controllers emulation using libmgba" ON)
 option(ENABLE_AUTOUPDATE "Enables support for automatic updates" ON)
 option(USE_RETRO_ACHIEVEMENTS "Enables integration with retroachievements.org" ON)
+option(ENABLE_DRM "Enables DRM support" ON)
 
 # Maintainers: if you consider blanket disabling this for your users, please
 # consider the following points:
@@ -501,6 +502,10 @@ if (OPENGL_GL)
   include_directories(${OPENGL_INCLUDE_DIR})
 endif()
 
+if(ENABLE_DRM)
+  add_definitions(-DHAVE_DRM)
+endif()
+
 if(ENABLE_X11)
   pkg_check_modules(X11 x11 IMPORTED_TARGET)
   if(X11_FOUND)

Source/Core/Common/WindowSystemInfo.h

@@ -13,6 +13,7 @@ enum class WindowSystemType
   Wayland,
   FBDev,
   Haiku,
+  DRM,
 };
 
 struct WindowSystemInfo

Source/Core/Core/Config/GraphicsSettings.cpp

@@ -89,7 +89,7 @@ const Info<bool> GFX_DISABLE_FOG{{System::GFX, "Settings", "DisableFog"}, false}
 const Info<bool> GFX_BORDERLESS_FULLSCREEN{{System::GFX, "Settings", "BorderlessFullscreen"},
                                            false};
 const Info<bool> GFX_ENABLE_VALIDATION_LAYER{{System::GFX, "Settings", "EnableValidationLayer"},
-                                             false};
+                                             true};
 
 const Info<bool> GFX_BACKEND_MULTITHREADING{{System::GFX, "Settings", "BackendMultithreading"},
                                             true};

Source/Core/DolphinNoGUI/CMakeLists.txt

@@ -21,8 +21,10 @@ endif()
 
 if(${CMAKE_SYSTEM_NAME} STREQUAL "Linux")
   target_sources(dolphin-nogui PRIVATE PlatformFBDev.cpp)
+  target_sources(dolphin-nogui PRIVATE PlatformDRM.cpp)
 endif()
 
+
 set_target_properties(dolphin-nogui PROPERTIES OUTPUT_NAME dolphin-emu-nogui)
 
 target_link_libraries(dolphin-nogui

Source/Core/DolphinNoGUI/MainNoGUI.cpp

@@ -172,6 +172,11 @@ static std::unique_ptr<Platform> GetPlatform(const optparse::Values& options)
 {
   std::string platform_name = static_cast<const char*>(options.get("platform"));
 
+#if HAVE_DRM
+  if (platform_name == "drm" || platform_name.empty())
+    return Platform::CreateDRMPlatform();
+#endif
+
 #if HAVE_X11
   if (platform_name == "x11" || platform_name.empty())
     return Platform::CreateX11Platform();
@@ -215,6 +220,9 @@ int main(int argc, char* argv[])
             ,
             "fbdev"
 #endif
+#if HAVE_DRM
+        ,"drm"
+#endif
 #if HAVE_X11
             ,
             "x11"

Source/Core/DolphinNoGUI/Platform.h

@@ -30,6 +30,10 @@ class Platform
   // Request an immediate shutdown.
   void Stop();
 
+#if HAVE_DRM
+  static std::unique_ptr<Platform> CreateDRMPlatform();
+#endif
+
   static std::unique_ptr<Platform> CreateHeadlessPlatform();
 #ifdef HAVE_X11
   static std::unique_ptr<Platform> CreateX11Platform();

Source/Core/DolphinNoGUI/PlatformDRM.cpp

@@ -0,0 +1,64 @@
+// Copyright 2018 Dolphin Emulator Project
+// SPDX-License-Identifier: GPL-2.0-or-later
+
+#include <unistd.h>
+
+#include "DolphinNoGUI/Platform.h"
+
+#include "Common/MsgHandler.h"
+#include "Core/ConfigManager.h"
+#include "Core/Core.h"
+#include "Core/State.h"
+#include "Core/System.h"
+
+#include <climits>
+#include <cstdio>
+#include <thread>
+
+#include <fcntl.h>
+#include <sys/types.h>
+
+namespace
+{
+class PlatformDRM : public Platform
+{
+public:
+  void SetTitle(const std::string& string) override;
+  void MainLoop() override;
+
+  WindowSystemInfo GetWindowSystemInfo() const override;
+};
+
+
+void PlatformDRM::SetTitle(const std::string& string)
+{
+  std::fprintf(stdout, "%s\n", string.c_str());
+}
+
+void PlatformDRM::MainLoop()
+{
+  while (IsRunning())
+  {
+    UpdateRunningFlag();
+    Core::HostDispatchJobs(Core::System::GetInstance());
+
+    // TODO: Is this sleep appropriate?
+    std::this_thread::sleep_for(std::chrono::milliseconds(1));
+  }
+}
+
+WindowSystemInfo PlatformDRM::GetWindowSystemInfo() const
+{
+  WindowSystemInfo wsi;
+  wsi.type = WindowSystemType::DRM;
+  wsi.display_connection = nullptr;  // EGL_DEFAULT_DISPLAY
+  wsi.render_window = nullptr;
+  wsi.render_surface = nullptr;
+  return wsi;
+}
+}  // namespace
+
+std::unique_ptr<Platform> Platform::CreateDRMPlatform()
+{
+  return std::make_unique<PlatformDRM>();
+}

Source/Core/VideoBackends/Vulkan/CMakeLists.txt

@@ -57,12 +57,16 @@ endif()
 
 # Only include the Vulkan headers when building the Vulkan backend
 target_include_directories(videovulkan
-PRIVATE
-  ${CMAKE_SOURCE_DIR}/Externals/Vulkan-Headers/include
-  ${CMAKE_SOURCE_DIR}/Externals/VulkanMemoryAllocator/include
-  ${CMAKE_SOURCE_DIR}/Externals/libadrenotools/include
+        PRIVATE
+        ${CMAKE_SOURCE_DIR}/Externals/Vulkan-Headers/include
+        ${CMAKE_SOURCE_DIR}/Externals/VulkanMemoryAllocator/include
+        ${CMAKE_SOURCE_DIR}/Externals/libadrenotools/include
 )
 
+#find_package(volk REQUIRED)
+#target_link_directories(videovulkan PRIVATE volk::volk_headers)
+
+
 if(MSVC)
   # Add precompiled header
   target_link_libraries(videovulkan PRIVATE use_pch)

Source/Core/VideoBackends/Vulkan/VKMain.cpp

@@ -34,6 +34,7 @@ void VideoBackend::InitBackendInfo(const WindowSystemInfo& wsi)
 {
   VulkanContext::PopulateBackendInfo(&g_Config);
 
+
   if (LoadVulkanLibrary())
   {
     u32 vk_api_version = 0;
@@ -147,11 +148,20 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
   VulkanContext::PopulateBackendInfo(&g_Config);
   VulkanContext::PopulateBackendInfoAdapters(&g_Config, gpu_list);
 
+  // Since we haven't called InitializeShared yet, iAdapter may be out of range,
+  // so we have to check it ourselves.
+  size_t selected_adapter_index = static_cast<size_t>(g_Config.iAdapter);
+  if (selected_adapter_index >= gpu_list.size())
+  {
+    WARN_LOG_FMT(VIDEO, "Vulkan adapter index out of range, selecting first adapter.");
+    selected_adapter_index = 0;
+  }
+
   // We need the surface before we can create a device, as some parameters depend on it.
   VkSurfaceKHR surface = VK_NULL_HANDLE;
   if (enable_surface)
   {
-    surface = SwapChain::CreateVulkanSurface(instance, wsi);
+    surface = SwapChain::CreateVulkanSurface(instance, gpu_list[selected_adapter_index], wsi);
     if (surface == VK_NULL_HANDLE)
     {
       PanicAlertFmt("Failed to create Vulkan surface.");
@@ -161,15 +171,6 @@ bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
     }
   }
 
-  // Since we haven't called InitializeShared yet, iAdapter may be out of range,
-  // so we have to check it ourselves.
-  size_t selected_adapter_index = static_cast<size_t>(g_Config.iAdapter);
-  if (selected_adapter_index >= gpu_list.size())
-  {
-    WARN_LOG_FMT(VIDEO, "Vulkan adapter index out of range, selecting first adapter.");
-    selected_adapter_index = 0;
-  }
-
   // Now we can create the Vulkan device. VulkanContext takes ownership of the instance and surface.
   g_vulkan_context =
       VulkanContext::Create(instance, gpu_list[selected_adapter_index], surface, enable_debug_utils,

Source/Core/VideoBackends/Vulkan/VKSwapChain.cpp

@@ -36,8 +36,162 @@ SwapChain::~SwapChain()
   DestroySurface();
 }
 
-VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, const WindowSystemInfo& wsi)
+VkSurfaceKHR SwapChain::CreateVulkanSurface(VkInstance instance, VkPhysicalDevice physicalDevice, const WindowSystemInfo& wsi)
 {
+
+#if defined(VK_USE_PLATFORM_DISPLAY_KHR)
+if (wsi.type == WindowSystemType::DRM)
+{
+  // Get the first display
+  uint32_t display_count = 1;
+  VkDisplayPropertiesKHR display_props;
+  if (VkResult err = vkGetPhysicalDeviceDisplayPropertiesKHR(physicalDevice, &display_count, &display_props); err != VK_SUCCESS && err != VK_INCOMPLETE)
+  {
+    LOG_VULKAN_ERROR(err, "vkGetPhysicalDeviceDisplayPropertiesKHR failed: ");
+    return VK_NULL_HANDLE;
+  }
+
+  // Get the first mode of the display
+  uint32_t mode_count = 0;
+  if (VkResult err = vkGetDisplayModePropertiesKHR(physicalDevice, display_props.display, &mode_count, nullptr); err != VK_SUCCESS)
+  {
+    LOG_VULKAN_ERROR(err, "vkGetDisplayModePropertiesKHR failed: ");
+    return VK_NULL_HANDLE;
+  }
+
+  if (mode_count == 0)
+  {
+    ERROR_LOG_FMT(VIDEO, "Cannot find any mode for the display!");
+    return VK_NULL_HANDLE;
+  }
+
+  VkDisplayModePropertiesKHR mode_props;
+  mode_count = 1;
+  if (VkResult err = vkGetDisplayModePropertiesKHR(physicalDevice, display_props.display, &mode_count, &mode_props); err != VK_SUCCESS && err != VK_INCOMPLETE)
+  {
+    LOG_VULKAN_ERROR(err, "vkGetDisplayModePropertiesKHR failed: ");
+    return VK_NULL_HANDLE;
+  }
+
+  // Get the list of planes
+  uint32_t plane_count = 0;
+  if (VkResult err = vkGetPhysicalDeviceDisplayPlanePropertiesKHR(physicalDevice, &plane_count, nullptr); err != VK_SUCCESS)
+  {
+    LOG_VULKAN_ERROR(err, "vkGetPhysicalDeviceDisplayPlanePropertiesKHR failed: ");
+    return VK_NULL_HANDLE;
+  }
+
+  if (plane_count == 0)
+  {
+    ERROR_LOG_FMT(VIDEO, "No display planes found!");
+    return VK_NULL_HANDLE;
+  }
+
+  // Find a plane compatible with the display
+  // Find a plane compatible with the display
+  uint32_t compatible_plane_index = UINT32_MAX;
+
+  for (uint32_t plane_index = 0; plane_index < plane_count; plane_index++)
+  {
+    // Query the number of displays supported by the plane
+    display_count = 0;
+    VkResult err = vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, plane_index, &display_count, nullptr);
+    if (err != VK_SUCCESS)
+    {
+      LOG_VULKAN_ERROR(err, "vkGetDisplayPlaneSupportedDisplaysKHR (count query) failed: ");
+      return VK_NULL_HANDLE;
+    }
+
+    if (display_count == 0)
+      continue; // Skip planes that support no displays
+
+    // Allocate memory to hold the supported displays
+    std::vector<VkDisplayKHR> displays(display_count);
+    err = vkGetDisplayPlaneSupportedDisplaysKHR(physicalDevice, plane_index, &display_count, displays.data());
+    if (err != VK_SUCCESS)
+    {
+      LOG_VULKAN_ERROR(err, "vkGetDisplayPlaneSupportedDisplaysKHR (fetch displays) failed: ");
+      return VK_NULL_HANDLE;
+    }
+
+    // Check if the target display is among the supported displays
+    for (const auto& display : displays)
+    {
+      if (display == display_props.display)
+      {
+        compatible_plane_index = plane_index;
+        break;
+      }
+    }
+
+    if (compatible_plane_index != UINT32_MAX)
+      break; // Exit early if a compatible plane is found
+  }
+
+  if (compatible_plane_index == UINT32_MAX)
+  {
+    ERROR_LOG_FMT(VIDEO, "No compatible plane found for the display!");
+    return VK_NULL_HANDLE;
+  }
+
+
+  if (compatible_plane_index == UINT32_MAX)
+  {
+    ERROR_LOG_FMT(VIDEO, "No compatible plane found for the display!");
+    return VK_NULL_HANDLE;
+  }
+
+  // Get capabilities of the compatible plane
+  VkDisplayPlaneCapabilitiesKHR planeCaps;
+  if (VkResult err = vkGetDisplayPlaneCapabilitiesKHR(physicalDevice, mode_props.displayMode, compatible_plane_index, &planeCaps); err != VK_SUCCESS)
+  {
+    LOG_VULKAN_ERROR(err, "vkGetDisplayPlaneCapabilitiesKHR failed: ");
+    return VK_NULL_HANDLE;
+  }
+
+  // Find a supported alpha mode
+  VkDisplayPlaneAlphaFlagBitsKHR alphaMode = VK_DISPLAY_PLANE_ALPHA_OPAQUE_BIT_KHR;
+  VkDisplayPlaneAlphaFlagBitsKHR alphaModes[] = {
+    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,
+  };
+
+  for (uint32_t i = 0; i < sizeof(alphaModes) / sizeof(alphaModes[0]); ++i)
+  {
+    if (planeCaps.supportedAlpha & alphaModes[i])
+    {
+      alphaMode = alphaModes[i];
+      break;
+    }
+  }
+
+  // Create the display surface
+  VkDisplaySurfaceCreateInfoKHR surface_create_info = {};
+  surface_create_info.sType = VK_STRUCTURE_TYPE_DISPLAY_SURFACE_CREATE_INFO_KHR;
+  surface_create_info.displayMode = mode_props.displayMode;
+  surface_create_info.planeIndex = compatible_plane_index;
+  surface_create_info.planeStackIndex = 0;
+  surface_create_info.transform = VK_SURFACE_TRANSFORM_IDENTITY_BIT_KHR;
+  surface_create_info.globalAlpha = 1.0f;
+  surface_create_info.alphaMode = alphaMode;
+  surface_create_info.imageExtent.width = display_props.physicalResolution.width;
+  surface_create_info.imageExtent.height = display_props.physicalResolution.height;
+
+  VkSurfaceKHR surface;
+  VkResult res = vkCreateDisplayPlaneSurfaceKHR(instance, &surface_create_info, nullptr, &surface);
+  if (res != VK_SUCCESS)
+  {
+    LOG_VULKAN_ERROR(res, "vkCreateDisplayPlaneSurfaceKHR failed: ");
+    return VK_NULL_HANDLE;
+  }
+
+  return surface;
+}
+
+#endif
+
 #if defined(VK_USE_PLATFORM_WIN32_KHR)
   if (wsi.type == WindowSystemType::Windows)
   {
@@ -583,7 +737,7 @@ bool SwapChain::RecreateSurface(void* native_handle)
 
   // Re-create the surface with the new native handle
   m_wsi.render_surface = native_handle;
-  m_surface = CreateVulkanSurface(g_vulkan_context->GetVulkanInstance(), m_wsi);
+  m_surface = CreateVulkanSurface(g_vulkan_context->GetVulkanInstance(), g_vulkan_context->GetPhysicalDevice(), m_wsi);
   if (m_surface == VK_NULL_HANDLE)
     return false;
 

Source/Core/VideoBackends/Vulkan/VKSwapChain.h

@@ -25,7 +25,7 @@ class SwapChain
   ~SwapChain();
 
   // Creates a vulkan-renderable surface for the specified window handle.
-  static VkSurfaceKHR CreateVulkanSurface(VkInstance instance, const WindowSystemInfo& wsi);
+  static VkSurfaceKHR CreateVulkanSurface(VkInstance instance, VkPhysicalDevice physicalDevice, const WindowSystemInfo &wsi);
 
   // Create a new swap chain from a pre-existing surface.
   static std::unique_ptr<SwapChain> Create(const WindowSystemInfo& wsi, VkSurfaceKHR surface,