wayland: Clean up library references

src/citra_qt/CMakeLists.txt

@@ -312,10 +312,8 @@ elseif(UNIX)
         externals/duckstation/gl/context_egl_x11.cpp
         externals/duckstation/gl/context_glx.cpp
         externals/duckstation/gl/x11_window.cpp
-
-        ../../externals/glad/src/glad_egl.c
-        ../../externals/glad/src/glad_glx.c
     )
+
     target_link_libraries(citra PRIVATE "${X11_LIBRARIES}" "${EGL_LIBRARIES}")
     target_include_directories(citra PRIVATE "${X11_INCLUDE_DIR}")
     add_compile_definitions(QAPPLICATION_CLASS=QApplication)

src/citra_qt/externals/duckstation/gl/context.cpp

@@ -1,7 +1,7 @@
 #include <cstdlib>
 #include <cstring>
 #include <stdlib.h>
-#include "../log.h"
+#include "citra_qt/wayland/log.h"
 #include "context.h"
 #include "loader.h"
 Log_SetChannel(GL::Context);

src/citra_qt/externals/duckstation/gl/context.h

@@ -2,8 +2,9 @@
 #include <array>
 #include <memory>
 #include <vector>
-#include "../duckstation_compat.h"
+
-#include "../window_info.h"
+#include "citra_qt/wayland/duckstation_compat.h"
+#include "citra_qt/wayland/window_info.h"
 
 namespace GL {
 using namespace citra;

src/citra_qt/externals/duckstation/gl/context_agl.mm

@@ -1,20 +1,19 @@
-#include "context_agl.h"
-#include "../duckstation_compat.h"
-#include "../log.h"
-#include "loader.h"
 #include <dlfcn.h>
+#include "citra_qt/wayland/duckstation_compat.h"
+#include "citra_qt/wayland/log.h"
+#include "context_agl.h"
+#include "loader.h"
 Log_SetChannel(GL::ContextAGL);
 
 namespace GL {
-ContextAGL::ContextAGL(const WindowInfo& wi) : Context(wi)
+ContextAGL::ContextAGL(const WindowInfo& wi) : Context(wi) {
-{
+    m_opengl_module_handle =
-  m_opengl_module_handle = dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_NOW);
+        dlopen("/System/Library/Frameworks/OpenGL.framework/Versions/Current/OpenGL", RTLD_NOW);
     if (!m_opengl_module_handle)
         Log_ErrorPrint("Could not open OpenGL.framework, function lookups will probably fail");
 }
 
-ContextAGL::~ContextAGL()
+ContextAGL::~ContextAGL() {
-{
     if ([NSOpenGLContext currentContext] == m_context)
         [NSOpenGLContext clearCurrentContext];
 
@@ -29,8 +28,7 @@ ContextAGL::~ContextAGL()
 }
 
 std::unique_ptr<Context> ContextAGL::Create(const WindowInfo& wi, const Version* versions_to_try,
-                                            size_t num_versions_to_try)
+                                            size_t num_versions_to_try) {
-{
     std::unique_ptr<ContextAGL> context = std::make_unique<ContextAGL>(wi);
     if (!context->Initialize(versions_to_try, num_versions_to_try))
         return nullptr;
@@ -38,25 +36,22 @@ std::unique_ptr<Context> ContextAGL::Create(const WindowInfo& wi, const Version*
     return context;
 }
 
-bool ContextAGL::Initialize(const Version* versions_to_try, size_t num_versions_to_try)
+bool ContextAGL::Initialize(const Version* versions_to_try, size_t num_versions_to_try) {
-{
+    for (size_t i = 0; i < num_versions_to_try; i++) {
-  for (size_t i = 0; i < num_versions_to_try; i++)
-  {
         const Version& cv = versions_to_try[i];
-    if (cv.profile == Profile::NoProfile && CreateContext(nullptr, NSOpenGLProfileVersionLegacy, true))
+        if (cv.profile == Profile::NoProfile &&
-    {
+            CreateContext(nullptr, NSOpenGLProfileVersionLegacy, true)) {
             // we already have the dummy context, so just use that
             m_version = cv;
             return true;
-    }
+        } else if (cv.profile == Profile::Core) {
-    else if (cv.profile == Profile::Core)
-    {
             if (cv.major_version > 4 && cv.minor_version > 1)
                 continue;
 
-      const NSOpenGLPixelFormatAttribute profile = (cv.major_version > 3 || cv.minor_version > 2) ? NSOpenGLProfileVersion4_1Core : NSOpenGLProfileVersion3_2Core;
+            const NSOpenGLPixelFormatAttribute profile =
-      if (CreateContext(nullptr, static_cast<int>(profile), true))
+                (cv.major_version > 3 || cv.minor_version > 2) ? NSOpenGLProfileVersion4_1Core
-      {        
+                                                               : NSOpenGLProfileVersion3_2Core;
+            if (CreateContext(nullptr, static_cast<int>(profile), true)) {
                 m_version = cv;
                 return true;
             }
@@ -66,8 +61,7 @@ bool ContextAGL::Initialize(const Version* versions_to_try, size_t num_versions_
     return false;
 }
 
-void* ContextAGL::GetProcAddress(const char* name)
+void* ContextAGL::GetProcAddress(const char* name) {
-{
     void* addr = m_opengl_module_handle ? dlsym(m_opengl_module_handle, name) : nullptr;
     if (addr)
         return addr;
@@ -75,24 +69,22 @@ void* ContextAGL::GetProcAddress(const char* name)
     return dlsym(RTLD_NEXT, name);
 }
 
-bool ContextAGL::ChangeSurface(const WindowInfo& new_wi)
+bool ContextAGL::ChangeSurface(const WindowInfo& new_wi) {
-{
     m_wi = new_wi;
     BindContextToView();
     return true;
 }
 
-void ContextAGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
+void ContextAGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/) {
-{
     UpdateDimensions();
 }
 
-bool ContextAGL::UpdateDimensions()
+bool ContextAGL::UpdateDimensions() {
-{
     const NSSize window_size = [GetView() frame].size;
     const CGFloat window_scale = [[GetView() window] backingScaleFactor];
     const u32 new_width = static_cast<u32>(static_cast<CGFloat>(window_size.width) * window_scale);
-  const u32 new_height = static_cast<u32>(static_cast<CGFloat>(window_size.height) * window_scale);
+    const u32 new_height =
+        static_cast<u32>(static_cast<CGFloat>(window_size.height) * window_scale);
 
     if (m_wi.surface_width == new_width && m_wi.surface_height == new_height)
         return false;
@@ -112,36 +104,32 @@ bool ContextAGL::UpdateDimensions()
     return true;
 }
 
-bool ContextAGL::SwapBuffers()
+bool ContextAGL::SwapBuffers() {
-{
     [m_context flushBuffer];
     return true;
 }
 
-bool ContextAGL::MakeCurrent()
+bool ContextAGL::MakeCurrent() {
-{
     [m_context makeCurrentContext];
     return true;
 }
 
-bool ContextAGL::DoneCurrent()
+bool ContextAGL::DoneCurrent() {
-{
     [NSOpenGLContext clearCurrentContext];
     return true;
 }
 
-bool ContextAGL::SetSwapInterval(s32 interval)
+bool ContextAGL::SetSwapInterval(s32 interval) {
-{
     GLint gl_interval = static_cast<GLint>(interval);
     [m_context setValues:&gl_interval forParameter:NSOpenGLCPSwapInterval];
     return true;
 }
 
-std::unique_ptr<Context> ContextAGL::CreateSharedContext(const WindowInfo& wi)
+std::unique_ptr<Context> ContextAGL::CreateSharedContext(const WindowInfo& wi) {
-{
     std::unique_ptr<ContextAGL> context = std::make_unique<ContextAGL>(wi);
 
-  context->m_context = [[NSOpenGLContext alloc] initWithFormat:m_pixel_format shareContext:m_context];
+    context->m_context = [[NSOpenGLContext alloc] initWithFormat:m_pixel_format
+                                                    shareContext:m_context];
     if (context->m_context == nil)
         return nullptr;
 
@@ -155,10 +143,8 @@ std::unique_ptr<Context> ContextAGL::CreateSharedContext(const WindowInfo& wi)
     return context;
 }
 
-bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool make_current)
+bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool make_current) {
-{
+    if (m_context) {
-  if (m_context)
-  {
         [m_context release];
         m_context = nullptr;
     }
@@ -166,15 +152,11 @@ bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool
     if (m_pixel_format)
         [m_pixel_format release];
 
-  const std::array<NSOpenGLPixelFormatAttribute, 5> attribs = {{
+    const std::array<NSOpenGLPixelFormatAttribute, 5> attribs = {
-      NSOpenGLPFADoubleBuffer,
+        {NSOpenGLPFADoubleBuffer, NSOpenGLPFAOpenGLProfile,
-      NSOpenGLPFAOpenGLProfile,
+         static_cast<NSOpenGLPixelFormatAttribute>(profile), NSOpenGLPFAAccelerated, 0}};
-      static_cast<NSOpenGLPixelFormatAttribute>(profile),
-      NSOpenGLPFAAccelerated,
-      0}};
     m_pixel_format = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs.data()];
-  if (m_pixel_format == nil)
+    if (m_pixel_format == nil) {
-  {
         Log_ErrorPrintf("Failed to initialize pixel format");
         return false;
     }
@@ -192,8 +174,7 @@ bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool
     return true;
 }
 
-void ContextAGL::BindContextToView()
+void ContextAGL::BindContextToView() {
-{
     NSView* const view = GetView();
     NSWindow* const window = [view window];
     [view setWantsBestResolutionOpenGLSurface:YES];

src/citra_qt/externals/duckstation/gl/context_egl.cpp

@@ -1,8 +1,8 @@
 #include <cstring>
 #include <optional>
 #include <vector>
-#include "../duckstation_compat.h"
+#include "citra_qt/wayland/duckstation_compat.h"
-#include "../log.h"
+#include "citra_qt/wayland/log.h"
 #include "context_egl.h"
 Log_SetChannel(GL::ContextEGL);
 

src/citra_qt/externals/duckstation/gl/context_egl.h

@@ -1,7 +1,9 @@
 #pragma once
-#include "../../../../../externals/glad/src/glad_egl.h"
+
 #include "context.h"
 
+#include <glad/glad_egl.h>
+
 namespace GL {
 
 class ContextEGL : public Context {

src/citra_qt/externals/duckstation/gl/context_egl_wayland.cpp

@@ -1,5 +1,5 @@
 #include <dlfcn.h>
-#include "../log.h"
+#include "citra_qt/wayland/log.h"
 #include "context_egl_wayland.h"
 Log_SetChannel(ContextEGLWayland);
 

src/citra_qt/externals/duckstation/gl/context_egl_x11.cpp

@@ -1,4 +1,4 @@
-#include "../log.h"
+#include "citra_qt/wayland/log.h"
 #include "context_egl_x11.h"
 Log_SetChannel(GL::ContextEGLX11);
 

src/citra_qt/externals/duckstation/gl/context_glx.cpp

@@ -1,6 +1,6 @@
 #include <dlfcn.h>
-#include "../duckstation_compat.h"
+#include "citra_qt/wayland/duckstation_compat.h"
-#include "../log.h"
+#include "citra_qt/wayland/log.h"
 #include "context_glx.h"
 Log_SetChannel(GL::ContextGLX);
 

src/citra_qt/externals/duckstation/gl/context_glx.h

@@ -1,8 +1,10 @@
 #pragma once
-#include "../../../../../externals/glad/src/glad_glx.h"
+
 #include "context.h"
 #include "x11_window.h"
 
+#include <glad/glad_glx.h>
+
 namespace GL {
 
 class ContextGLX final : public Context {

src/citra_qt/externals/duckstation/gl/context_wgl.cpp

@@ -1,6 +1,6 @@
-#include "../duckstation_compat.h"
+#include "citra_qt/wayland/duckstation_compat.h"
-#include "../log.h"
+#include "citra_qt/wayland/log.h"
-#include "../scoped_guard.h"
+#include "citra_qt/wayland/scoped_guard.h"
 #include "context_wgl.h"
 #include "loader.h"
 using namespace melonDS;

src/citra_qt/externals/duckstation/gl/context_wgl.h

@@ -1,8 +1,10 @@
 #pragma once
-#include "../windows_headers.h"
+
+#include "citra+qt/wayland/windows_headers.h"
 
 #include <optional>
-#include "../../../../../externals/glad/src/glad_wgl.h"
+#include <glad/glad_wgl.h>
+
 #include "context.h"
 #include "loader.h"
 

src/citra_qt/externals/duckstation/gl/loader.h

@@ -2,7 +2,7 @@
 
 // Fix glad.h including windows.h
 #ifdef _WIN32
-#include "../windows_headers.h"
+#include "citra_qt/wayland/windows_headers.h"
 #endif
 
-#include "../../../../../externals/glad/src/glad.h"
+#include <glad/glad.h>

src/citra_qt/externals/duckstation/gl/x11_window.cpp

@@ -1,6 +1,6 @@
 #include <cstdio>
-#include "../duckstation_compat.h"
+#include "citra_qt/wayland/duckstation_compat.h"
-#include "../log.h"
+#include "citra_qt/wayland/log.h"
 #include "x11_window.h"
 Log_SetChannel(X11Window);
 

src/citra_qt/externals/duckstation/gl/x11_window.h

@@ -1,7 +1,7 @@
 #pragma once
 #include <X11/Xlib.h>
 #include <X11/Xutil.h>
-#include "../duckstation_compat.h"
+#include "citra_qt/wayland/duckstation_compat.h"
 
 namespace GL {
 using namespace citra;

src/citra_qt/externals/types.h

@@ -1,38 +0,0 @@
-/*
-    Copyright 2016-2023 melonDS team
-
-    This file is part of melonDS.
-
-    melonDS is free software: you can redistribute it and/or modify it under
-    the terms of the GNU General Public License as published by the Free
-    Software Foundation, either version 3 of the License, or (at your option)
-    any later version.
-
-    melonDS is distributed in the hope that it will be useful, but WITHOUT ANY
-    WARRANTY; without even the implied warranty of MERCHANTABILITY or FITNESS
-    FOR A PARTICULAR PURPOSE. See the GNU General Public License for more details.
-
-    You should have received a copy of the GNU General Public License along
-    with melonDS. If not, see http://www.gnu.org/licenses/.
-*/
-
-#ifndef TYPES_H
-#define TYPES_H
-
-#include <array>
-#include <stdint.h>
-
-namespace citra {
-typedef uint8_t u8;
-typedef uint16_t u16;
-typedef uint32_t u32;
-typedef uint64_t u64;
-typedef int8_t s8;
-typedef int16_t s16;
-typedef int32_t s32;
-typedef int64_t s64;
-
-template <class T, std::size_t A, std::size_t B>
-using array2d = std::array<std::array<T, B>, A>;
-} // namespace citra
-#endif // TYPES_H

src/citra_qt/wayland/duckstation_compat.h

@@ -1,7 +1,7 @@
 #ifndef DUCKSTATION_COMPAT_H
 #define DUCKSTATION_COMPAT_H
 
-#include "../types.h"
+#include "common/common_types.h"
 
 #include <assert.h>
 

src/citra_qt/wayland/window_info.cpp

@@ -86,7 +86,7 @@ bool WindowInfo::QueryRefreshRateForWindow(const WindowInfo& wi, float* refresh_
 
 #include <X11/extensions/Xrandr.h>
 #include "common/scoped_guard.h"
-#include "gl/x11_window.h"
+#include "x11_window.h"
 
 static bool GetRefreshRateFromXRandR(const WindowInfo& wi, float* refresh_rate) {
     Display* display = static_cast<Display*>(wi.display_connection);

src/citra_qt/wayland/window_info.h

@@ -1,5 +1,5 @@
 #pragma once
-#include "../types.h"
+#include "common/common_types.h"
 
 // Contains the information required to create a graphics context in a window.
 struct WindowInfo {

src/common/common_types.h

@@ -54,6 +54,9 @@ typedef u32 PAddr; ///< Represents a pointer in the ARM11 physical address space
 using u128 = std::array<std::uint64_t, 2>;
 static_assert(sizeof(u128) == 16, "u128 must be 128 bits wide");
 
+template <class T, std::size_t A, std::size_t B>
+using array2d = std::array<std::array<T, B>, A>;
+
 // An inheritable class to disallow the copy constructor and operator= functions
 class NonCopyable {
 protected: