Fix typo

.github/workflows/Qt_Build.yml

@@ -105,7 +105,7 @@ jobs:
 
     - name: Install misc packages
       run: |
-       sudo apt-get update && sudo apt install libx11-dev libgl1-mesa-glx mesa-common-dev libfuse2
+       sudo apt-get update && sudo apt install libx11-dev libgl1-mesa-glx mesa-common-dev libfuse2 libwayland-dev
        sudo add-apt-repository -y ppa:savoury1/qt-6-2
        sudo apt update
        sudo apt install qt6-base-dev

CMakeLists.txt

@@ -225,6 +225,22 @@ set(THIRD_PARTY_SOURCE_FILES third_party/imgui/imgui.cpp
                              third_party/cityhash/cityhash.cpp
                              third_party/xxhash/xxhash.c
 )
+
+
+if(ENABLE_QT_GUI)
+    include_directories(third_party/duckstation)
+    set(THIRD_PARTY_SOURCE_FILES ${THIRD_PARTY_SOURCE_FILES} third_party/duckstation/window_info.cpp third_party/duckstation/gl/context.cpp)
+
+    if(APPLE)
+        set(THIRD_PARTY_SOURCE_FILES ${THIRD_PARTY_SOURCE_FILES} third_party/duckstation/gl/context_agl.mm)
+    elseif(WIN32)
+        set(THIRD_PARTY_SOURCE_FILES ${THIRD_PARTY_SOURCE_FILES} third_party/duckstation/gl/context_wgl.cpp)
+    else()
+        set(THIRD_PARTY_SOURCE_FILES ${THIRD_PARTY_SOURCE_FILES} third_party/duckstation/gl/context_egl.cpp third_party/duckstation/gl/context_egl_wayland.cpp
+        third_party/duckstation/gl/context_egl_x11.cpp third_party/duckstation/gl/context_glx.cpp third_party/duckstation/gl/x11_window.cpp)
+    endif()
+endif()
+
 source_group("Source Files\\Core" FILES ${SOURCE_FILES})
 source_group("Source Files\\Core\\Crypto" FILES ${CRYPTO_SOURCE_FILES})
 source_group("Source Files\\Core\\Filesystem" FILES ${FS_SOURCE_FILES})
@@ -304,9 +320,9 @@ if(ENABLE_VULKAN)
 
     if(GPU_DEBUG_INFO)
         # generate nonsemantic shader debug information with source
-        set( RENDERER_VK_HOST_SHADERS_FLAGS ${RENDERER_VK_HOST_SHADERS_FLAGS} -gVS)
+        set(RENDERER_VK_HOST_SHADERS_FLAGS ${RENDERER_VK_HOST_SHADERS_FLAGS} -gVS)
     else()
-        set( RENDERER_VK_HOST_SHADERS_FLAGS ${RENDERER_VK_HOST_SHADERS_FLAGS} -g0)
+        set(RENDERER_VK_HOST_SHADERS_FLAGS ${RENDERER_VK_HOST_SHADERS_FLAGS} -g0)
     endif()
 
     # Compile each vulkan shader into an .spv file
@@ -375,6 +391,11 @@ endif()
 if(ENABLE_QT_GUI)
     target_compile_definitions(Alber PUBLIC "PANDA3DS_FRONTEND_QT=1")
     target_link_libraries(Alber PRIVATE Qt6::Widgets)
+
+    if(LINUX OR FREEBSD)
+        find_package(X11 REQUIRED)
+        target_link_libraries(Alber PRIVATE ${X11_LIBRARIES})
+    endif()
 else()
     target_compile_definitions(Alber PUBLIC "PANDA3DS_FRONTEND_SDL=1")
 endif()

src/emulator.cpp

@@ -58,7 +58,7 @@ Emulator::Emulator()
 			Helpers::panic("OpenGL context creation failed: %s", SDL_GetError());
 		}
 
-		if (!gladLoadGL(reinterpret_cast<GLADloadfunc>(SDL_GL_GetProcAddress))) {
+		if (!gladLoadGLLoader(reinterpret_cast<GLADloadproc>(SDL_GL_GetProcAddress))) {
 			Helpers::panic("OpenGL init failed: %s", SDL_GetError());
 		}
 	}

third_party/duckstation/duckstation_compat.h

@@ -0,0 +1,16 @@
+#ifndef DUCKSTATION_COMPAT_H
+#define DUCKSTATION_COMPAT_H
+
+#include <assert.h>
+
+#include "compiler_builtins.hpp"
+#include "helpers.hpp"
+
+#define AssertMsg(cond, msg) assert(cond&& msg)
+#define Assert(cond) assert(cond)
+
+#define Panic(msg) assert(false && msg)
+
+#define UnreachableCode() __builtin_unreachable()
+
+#endif

third_party/duckstation/duckstation_log.h

@@ -0,0 +1,46 @@
+#ifndef LOG_H
+#define LOG_H
+
+#include <stdio.h>
+
+#define Log_SetChannel(ChannelName)
+#define Log_ErrorPrint(msg) puts(msg "\n");
+#define Log_ErrorPrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+#define Log_WarningPrint(msg) puts(msg)
+#define Log_WarningPrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+#define Log_PerfPrint(msg) puts(msg)
+#define Log_PerfPrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+#define Log_InfoPrint(msg) puts(msg)
+#define Log_InfoPrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+#define Log_VerbosePrint(msg) puts(msg)
+#define Log_VerbosePrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+#define Log_DevPrint(msg) puts(msg)
+#define Log_DevPrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+#define Log_ProfilePrint(msg) puts(msg)
+#define Log_ProfilePrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+
+#ifdef _DEBUG
+#define Log_DebugPrint(msg) puts(msg)
+#define Log_DebugPrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+#define Log_TracePrint(msg) puts(msg)
+#define Log_TracePrintf(...) do { printf(__VA_ARGS__); putchar('\n'); } while (0)
+#else
+#define Log_DebugPrint(msg)                                                                                            \
+  do                                                                                                                   \
+  {                                                                                                                    \
+  } while (0)
+#define Log_DebugPrintf(...)                                                                                           \
+  do                                                                                                                   \
+  {                                                                                                                    \
+  } while (0)
+#define Log_TracePrint(msg)                                                                                            \
+  do                                                                                                                   \
+  {                                                                                                                    \
+  } while (0)
+#define Log_TracePrintf(...)                                                                                           \
+  do                                                                                                                   \
+  {                                                                                                                    \
+  } while (0)
+#endif
+
+#endif

third_party/duckstation/duckstation_scoped_guard.h

@@ -0,0 +1,34 @@
+#pragma once
+#include <optional>
+#include <utility>
+
+/// ScopedGuard provides an object which runs a function (usually a lambda) when
+/// it goes out of scope. This can be useful for releasing resources or handles
+/// which do not normally have C++ types to automatically release.
+template<typename T>
+class ScopedGuard final
+{
+public:
+  ALWAYS_INLINE ScopedGuard(T&& func) : m_func(std::forward<T>(func)) {}
+  ALWAYS_INLINE ScopedGuard(ScopedGuard&& other) : m_func(std::move(other.m_func)) { other.m_func = nullptr; }
+  ALWAYS_INLINE ~ScopedGuard() { Invoke(); }
+
+  ScopedGuard(const ScopedGuard&) = delete;
+  void operator=(const ScopedGuard&) = delete;
+
+  /// Prevents the function from being invoked when we go out of scope.
+  ALWAYS_INLINE void Cancel() { m_func.reset(); }
+
+  /// Explicitly fires the function.
+  ALWAYS_INLINE void Invoke()
+  {
+    if (!m_func.has_value())
+      return;
+
+    m_func.value()();
+    m_func.reset();
+  }
+
+private:
+  std::optional<T> m_func;
+};

third_party/duckstation/gl/context.cpp

@@ -0,0 +1,179 @@
+#include "context.h"
+#include "duckstation_log.h"
+#include "loader.h"
+#include <cstdlib>
+#include <cstring>
+#ifdef __APPLE__
+#include <stdlib.h>
+#else
+#include <malloc.h>
+#endif
+Log_SetChannel(GL::Context);
+
+#if defined(_WIN32)
+#include "context_wgl.h"
+#elif defined(__APPLE__)
+#include "context_agl.h"
+#else
+#ifdef WAYLAND_ENABLED
+#include "context_egl_wayland.h"
+#endif
+#include "context_egl_x11.h"
+#include "context_glx.h"
+#endif
+
+namespace GL {
+
+static bool ShouldPreferESContext()
+{
+#ifndef _MSC_VER
+  const char* value = std::getenv("PREFER_GLES_CONTEXT");
+  return (value && strcmp(value, "1") == 0);
+#else
+  char buffer[2] = {};
+  size_t buffer_size = sizeof(buffer);
+  getenv_s(&buffer_size, buffer, "PREFER_GLES_CONTEXT");
+  return (std::strcmp(buffer, "1") == 0);
+#endif
+}
+
+Context::Context(const WindowInfo& wi) : m_wi(wi) {}
+
+Context::~Context() = default;
+
+std::vector<Context::FullscreenModeInfo> Context::EnumerateFullscreenModes()
+{
+  return {};
+}
+
+std::unique_ptr<GL::Context> Context::Create(const WindowInfo& wi, const Version* versions_to_try,
+                                             size_t num_versions_to_try)
+{
+  if (ShouldPreferESContext())
+  {
+    // move ES versions to the front
+    Version* new_versions_to_try = static_cast<Version*>(alloca(sizeof(Version) * num_versions_to_try));
+    size_t count = 0;
+    for (size_t i = 0; i < num_versions_to_try; i++)
+    {
+      if (versions_to_try[i].profile == Profile::ES)
+        new_versions_to_try[count++] = versions_to_try[i];
+    }
+    for (size_t i = 0; i < num_versions_to_try; i++)
+    {
+      if (versions_to_try[i].profile != Profile::ES)
+        new_versions_to_try[count++] = versions_to_try[i];
+    }
+    versions_to_try = new_versions_to_try;
+  }
+
+  std::unique_ptr<Context> context;
+#if defined(_WIN32)
+  context = ContextWGL::Create(wi, versions_to_try, num_versions_to_try);
+#elif defined(__APPLE__)
+  context = ContextAGL::Create(wi, versions_to_try, num_versions_to_try);
+#else
+  if (wi.type == WindowInfo::Type::X11)
+  {
+    const char* use_egl_x11 = std::getenv("USE_EGL_X11");
+    if (use_egl_x11 && std::strcmp(use_egl_x11, "1") == 0)
+      context = ContextEGLX11::Create(wi, versions_to_try, num_versions_to_try);
+    else
+      context = ContextGLX::Create(wi, versions_to_try, num_versions_to_try);
+  }
+
+#ifdef WAYLAND_ENABLED
+  if (wi.type == WindowInfo::Type::Wayland)
+    context = ContextEGLWayland::Create(wi, versions_to_try, num_versions_to_try);
+#endif
+#endif
+
+  if (!context)
+    return nullptr;
+
+  Log_InfoPrintf("Created a %s context", context->IsGLES() ? "OpenGL ES" : "OpenGL");
+
+  // TODO: Not thread-safe.
+  static Context* context_being_created;
+  context_being_created = context.get();
+
+  if (!gladLoadGLLoader([](const char* name) { return context_being_created->GetProcAddress(name); }))
+  {
+    Log_ErrorPrintf("Failed to load GL functions for GLAD");
+    return nullptr;
+  }
+
+  const char* gl_vendor = reinterpret_cast<const char*>(glGetString(GL_VENDOR));
+  const char* gl_renderer = reinterpret_cast<const char*>(glGetString(GL_RENDERER));
+  const char* gl_version = reinterpret_cast<const char*>(glGetString(GL_VERSION));
+  const char* gl_shading_language_version = reinterpret_cast<const char*>(glGetString(GL_SHADING_LANGUAGE_VERSION));
+  Log_InfoPrintf("GL_VENDOR: %s", gl_vendor);
+  Log_InfoPrintf("GL_RENDERER: %s", gl_renderer);
+  Log_InfoPrintf("GL_VERSION: %s", gl_version);
+  Log_InfoPrintf("GL_SHADING_LANGUAGE_VERSION: %s", gl_shading_language_version);
+
+  return context;
+}
+
+const std::array<Context::Version, 11>& Context::GetAllDesktopVersionsList()
+{
+  static constexpr std::array<Version, 11> vlist = {{{Profile::Core, 4, 6},
+                                                     {Profile::Core, 4, 5},
+                                                     {Profile::Core, 4, 4},
+                                                     {Profile::Core, 4, 3},
+                                                     {Profile::Core, 4, 2},
+                                                     {Profile::Core, 4, 1},
+                                                     {Profile::Core, 4, 0},
+                                                     {Profile::Core, 3, 3},
+                                                     {Profile::Core, 3, 2},
+                                                     {Profile::Core, 3, 1},
+                                                     {Profile::Core, 3, 0}}};
+  return vlist;
+}
+
+const std::array<Context::Version, 12>& Context::GetAllDesktopVersionsListWithFallback()
+{
+  static constexpr std::array<Version, 12> vlist = {{{Profile::Core, 4, 6},
+                                                     {Profile::Core, 4, 5},
+                                                     {Profile::Core, 4, 4},
+                                                     {Profile::Core, 4, 3},
+                                                     {Profile::Core, 4, 2},
+                                                     {Profile::Core, 4, 1},
+                                                     {Profile::Core, 4, 0},
+                                                     {Profile::Core, 3, 3},
+                                                     {Profile::Core, 3, 2},
+                                                     {Profile::Core, 3, 1},
+                                                     {Profile::Core, 3, 0},
+                                                     {Profile::NoProfile, 0, 0}}};
+  return vlist;
+}
+
+const std::array<Context::Version, 4>& Context::GetAllESVersionsList()
+{
+  static constexpr std::array<Version, 4> vlist = {
+    {{Profile::ES, 3, 2}, {Profile::ES, 3, 1}, {Profile::ES, 3, 0}, {Profile::ES, 2, 0}}};
+  return vlist;
+}
+
+const std::array<Context::Version, 16>& Context::GetAllVersionsList()
+{
+  static constexpr std::array<Version, 16> vlist = {{{Profile::Core, 4, 6},
+                                                     {Profile::Core, 4, 5},
+                                                     {Profile::Core, 4, 4},
+                                                     {Profile::Core, 4, 3},
+                                                     {Profile::Core, 4, 2},
+                                                     {Profile::Core, 4, 1},
+                                                     {Profile::Core, 4, 0},
+                                                     {Profile::Core, 3, 3},
+                                                     {Profile::Core, 3, 2},
+                                                     {Profile::Core, 3, 1},
+                                                     {Profile::Core, 3, 0},
+                                                     {Profile::ES, 3, 2},
+                                                     {Profile::ES, 3, 1},
+                                                     {Profile::ES, 3, 0},
+                                                     {Profile::ES, 2, 0},
+                                                     {Profile::NoProfile, 0, 0}}};
+  return vlist;
+}
+
+} // namespace GL