preserve-emulation/dolphin
1
0
Fork 0
mirror of https://github.com/dolphin-emu/dolphin.git synced 2026-07-11 01:24:22 +02:00
Code Issues Packages Projects Releases Wiki Activity

Remove GLX support

Browse Source 
EGL is the de-facto GL context initialization API, including on X11
where it provides many additional features over GLX.

I’m planning on adding support for selecting the GPU (adapter in
Dolphin-speak) also to OpenGL, similarly to the Vulkan backend, and that
will require EGL, so let’s remove the legacy API first.
This commit is contained in:
Link Mauve
2026-04-20 16:06:14 +02:00
parent 914f5c5621
commit fc47091592
6 changed files with 6 additions and 396 deletions
Download Patch File Download Diff File Expand all files Collapse all files
Source/Core/Common/CMakeLists.txt
-6
View File
@@ -331,13 +331,7 @@ elseif(ENABLE_X11 AND X11_FOUND)
target_sources(common PRIVATE
GL/GLX11Window.cpp
GL/GLX11Window.h
GL/GLInterface/GLX.cpp
GL/GLInterface/GLX.h
)
# GLX has a hard dependency on libGL.
# Make sure to link to it if using GLX.
target_link_libraries(common PUBLIC ${OPENGL_LIBRARIES})
endif()
if(CMAKE_SYSTEM_NAME STREQUAL "Linux")
Source/Core/Common/GL/GLContext.cpp
+3 -17
View File
@@ -14,9 +14,6 @@
#if defined(__HAIKU__)
#include "Common/GL/GLInterface/BGL.h"
#endif
#if HAVE_X11
#include "Common/GL/GLInterface/GLX.h"
#endif
#if HAVE_EGL
#include "Common/GL/GLInterface/EGL.h"
#if HAVE_X11
@@ -79,7 +76,7 @@ void* GLContext::GetFuncAddress(const std::string& name)
}
std::unique_ptr<GLContext> GLContext::Create(const WindowSystemInfo& wsi, bool stereo, bool core,
bool prefer_egl, bool prefer_gles)
bool prefer_gles)
{
std::unique_ptr<GLContext> context;
#if defined(__APPLE__)
@@ -98,22 +95,11 @@ std::unique_ptr<GLContext> GLContext::Create(const WindowSystemInfo& wsi, bool s
if (wsi.type == WindowSystemType::Haiku)
context = std::make_unique<GLContextBGL>();
#endif
#if HAVE_EGL
#if HAVE_X11
if (wsi.type == WindowSystemType::X11)
{
#if defined(HAVE_EGL)
// GLES 3 is not supported via GLX.
const bool use_egl = prefer_egl || prefer_gles;
if (use_egl)
context = std::make_unique<GLContextEGLX11>();
else
context = std::make_unique<GLContextGLX>();
#else
context = std::make_unique<GLContextGLX>();
context = std::make_unique<GLContextEGLX11>();
#endif
}
#endif
#if HAVE_EGL
if (wsi.type == WindowSystemType::Headless || wsi.type == WindowSystemType::FBDev)
context = std::make_unique<GLContextEGL>();
#endif
Source/Core/Common/GL/GLContext.h
+1 -2
View File
@@ -47,8 +47,7 @@ public:
// Creates an instance of GLContext specific to the platform we are running on.
// If successful, the context is made current on the calling thread.
static std::unique_ptr<GLContext> Create(const WindowSystemInfo& wsi, bool stereo = false,
bool core = true, bool prefer_egl = false,
bool prefer_gles = false);
bool core = true, bool prefer_gles = false);
protected:
virtual bool Initialize(const WindowSystemInfo& wsi, bool stereo, bool core);
Source/Core/Common/GL/GLInterface/GLX.cpp
-320
View File
@@ -1,320 +0,0 @@
// Copyright 2012 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#include "Common/GL/GLInterface/GLX.h"
#include <array>
#include <sstream>
#include "Common/Logging/Log.h"
#define GLX_CONTEXT_MAJOR_VERSION_ARB 0x2091
#define GLX_CONTEXT_MINOR_VERSION_ARB 0x2092
typedef GLXContext (*PFNGLXCREATECONTEXTATTRIBSPROC)(Display*, GLXFBConfig, GLXContext, Bool,
const int*);
#ifndef GLX_EXT_swap_control
typedef void (*PFNGLXSWAPINTERVALEXTPROC)(Display*, GLXDrawable, int);
#endif
typedef int (*PFNGLXSWAPINTERVALMESAPROC)(unsigned int);
static PFNGLXCREATECONTEXTATTRIBSPROC glXCreateContextAttribs = nullptr;
static PFNGLXSWAPINTERVALEXTPROC glXSwapIntervalEXTPtr = nullptr;
static PFNGLXSWAPINTERVALMESAPROC glXSwapIntervalMESAPtr = nullptr;
static PFNGLXCREATEGLXPBUFFERSGIXPROC glXCreateGLXPbufferSGIX = nullptr;
static PFNGLXDESTROYGLXPBUFFERSGIXPROC glXDestroyGLXPbufferSGIX = nullptr;
static bool s_glxError;
static int ctxErrorHandler(Display* dpy, XErrorEvent* ev)
{
s_glxError = true;
return 0;
}
GLContextGLX::~GLContextGLX()
{
DestroyWindowSurface();
if (m_context)
{
if (glXGetCurrentContext() == m_context)
glXMakeCurrent(m_display, None, nullptr);
glXDestroyContext(m_display, m_context);
}
}
bool GLContextGLX::IsHeadless() const
{
return !m_render_window;
}
void GLContextGLX::SwapInterval(int Interval)
{
if (!m_drawable)
return;
// Try EXT_swap_control, then MESA_swap_control.
if (glXSwapIntervalEXTPtr)
{
glXSwapIntervalEXTPtr(m_display, m_drawable, Interval);
}
else if (glXSwapIntervalMESAPtr)
{
glXSwapIntervalMESAPtr(static_cast<unsigned int>(Interval));
}
else
{
ERROR_LOG_FMT(VIDEO,
"No support for SwapInterval (framerate clamped to monitor refresh rate).");
}
}
void* GLContextGLX::GetFuncAddress(const std::string& name)
{
return reinterpret_cast<void*>(glXGetProcAddress(reinterpret_cast<const GLubyte*>(name.c_str())));
}
void GLContextGLX::Swap()
{
glXSwapBuffers(m_display, m_drawable);
}
// Create rendering window.
// Call browser: Core.cpp:EmuThread() > main.cpp:Video_Initialize()
bool GLContextGLX::Initialize(const WindowSystemInfo& wsi, bool stereo, bool core)
{
m_display = static_cast<Display*>(wsi.display_connection);
int screen = DefaultScreen(m_display);
// checking glx version
int glxMajorVersion, glxMinorVersion;
glXQueryVersion(m_display, &glxMajorVersion, &glxMinorVersion);
if (glxMajorVersion < 1 || (glxMajorVersion == 1 && glxMinorVersion < 4))
{
ERROR_LOG_FMT(VIDEO, "glX-Version {}.{} detected, but need at least 1.4", glxMajorVersion,
glxMinorVersion);
return false;
}
// loading core context creation function
glXCreateContextAttribs =
(PFNGLXCREATECONTEXTATTRIBSPROC)GetFuncAddress("glXCreateContextAttribsARB");
if (!glXCreateContextAttribs)
{
ERROR_LOG_FMT(VIDEO,
"glXCreateContextAttribsARB not found, do you support GLX_ARB_create_context?");
return false;
}
// choosing framebuffer
int visual_attribs[] = {GLX_X_RENDERABLE,
True,
GLX_DRAWABLE_TYPE,
GLX_WINDOW_BIT,
GLX_X_VISUAL_TYPE,
GLX_TRUE_COLOR,
GLX_RED_SIZE,
8,
GLX_GREEN_SIZE,
8,
GLX_BLUE_SIZE,
8,
GLX_DEPTH_SIZE,
0,
GLX_STENCIL_SIZE,
0,
GLX_DOUBLEBUFFER,
True,
GLX_STEREO,
stereo ? True : False,
None};
int fbcount = 0;
GLXFBConfig* fbc = glXChooseFBConfig(m_display, screen, visual_attribs, &fbcount);
if (!fbc || !fbcount)
{
ERROR_LOG_FMT(VIDEO, "Failed to retrieve a framebuffer config");
return false;
}
m_fbconfig = *fbc;
XFree(fbc);
s_glxError = false;
XErrorHandler oldHandler = XSetErrorHandler(&ctxErrorHandler);
// Create a GLX context.
if (core)
{
for (const auto& version : s_desktop_opengl_versions)
{
std::array<int, 9> context_attribs = {
{GLX_CONTEXT_MAJOR_VERSION_ARB, version.first, GLX_CONTEXT_MINOR_VERSION_ARB,
version.second, GLX_CONTEXT_PROFILE_MASK_ARB, GLX_CONTEXT_CORE_PROFILE_BIT_ARB,
GLX_CONTEXT_FLAGS_ARB, GLX_CONTEXT_FORWARD_COMPATIBLE_BIT_ARB, None}};
s_glxError = false;
m_context =
glXCreateContextAttribs(m_display, m_fbconfig, nullptr, True, &context_attribs[0]);
XSync(m_display, False);
if (!m_context || s_glxError)
continue;
// Got a context.
INFO_LOG_FMT(VIDEO, "Created a GLX context with version {}.{}", version.first,
version.second);
m_attribs.insert(m_attribs.end(), context_attribs.begin(), context_attribs.end());
break;
}
}
// Failed to create any core contexts, try for anything.
if (!m_context || s_glxError)
{
std::array<int, 5> context_attribs_legacy = {
{GLX_CONTEXT_MAJOR_VERSION_ARB, 1, GLX_CONTEXT_MINOR_VERSION_ARB, 0, None}};
s_glxError = false;
m_context =
glXCreateContextAttribs(m_display, m_fbconfig, nullptr, True, &context_attribs_legacy[0]);
XSync(m_display, False);
m_attribs.clear();
m_attribs.insert(m_attribs.end(), context_attribs_legacy.begin(), context_attribs_legacy.end());
}
if (!m_context || s_glxError)
{
ERROR_LOG_FMT(VIDEO, "Unable to create GL context.");
XSetErrorHandler(oldHandler);
return false;
}
glXSwapIntervalEXTPtr = nullptr;
glXSwapIntervalMESAPtr = nullptr;
glXCreateGLXPbufferSGIX = nullptr;
glXDestroyGLXPbufferSGIX = nullptr;
m_supports_pbuffer = false;
std::string tmp;
std::istringstream buffer(glXQueryExtensionsString(m_display, screen));
while (buffer >> tmp)
{
if (tmp == "GLX_SGIX_pbuffer")
{
glXCreateGLXPbufferSGIX = reinterpret_cast<PFNGLXCREATEGLXPBUFFERSGIXPROC>(
GetFuncAddress("glXCreateGLXPbufferSGIX"));
glXDestroyGLXPbufferSGIX = reinterpret_cast<PFNGLXDESTROYGLXPBUFFERSGIXPROC>(
GetFuncAddress("glXDestroyGLXPbufferSGIX"));
m_supports_pbuffer = glXCreateGLXPbufferSGIX && glXDestroyGLXPbufferSGIX;
}
else if (tmp == "GLX_EXT_swap_control")
{
glXSwapIntervalEXTPtr =
reinterpret_cast<PFNGLXSWAPINTERVALEXTPROC>(GetFuncAddress("glXSwapIntervalEXT"));
}
else if (tmp == "GLX_MESA_swap_control")
{
glXSwapIntervalMESAPtr =
reinterpret_cast<PFNGLXSWAPINTERVALMESAPROC>(GetFuncAddress("glXSwapIntervalMESA"));
}
}
if (!CreateWindowSurface(reinterpret_cast<Window>(wsi.render_surface)))
{
ERROR_LOG_FMT(VIDEO, "Error: CreateWindowSurface failed\n");
XSetErrorHandler(oldHandler);
return false;
}
XSetErrorHandler(oldHandler);
m_opengl_mode = Mode::OpenGL;
return MakeCurrent();
}
std::unique_ptr<GLContext> GLContextGLX::CreateSharedContext()
{
s_glxError = false;
XErrorHandler oldHandler = XSetErrorHandler(&ctxErrorHandler);
GLXContext new_glx_context =
glXCreateContextAttribs(m_display, m_fbconfig, m_context, True, &m_attribs[0]);
XSync(m_display, False);
if (!new_glx_context || s_glxError)
{
ERROR_LOG_FMT(VIDEO, "Unable to create GL context.");
XSetErrorHandler(oldHandler);
return nullptr;
}
std::unique_ptr<GLContextGLX> new_context = std::make_unique<GLContextGLX>();
new_context->m_context = new_glx_context;
new_context->m_opengl_mode = m_opengl_mode;
new_context->m_supports_pbuffer = m_supports_pbuffer;
new_context->m_display = m_display;
new_context->m_fbconfig = m_fbconfig;
new_context->m_is_shared = true;
if (m_supports_pbuffer && !new_context->CreateWindowSurface(None))
{
ERROR_LOG_FMT(VIDEO, "Error: CreateWindowSurface failed");
XSetErrorHandler(oldHandler);
return nullptr;
}
XSetErrorHandler(oldHandler);
return new_context;
}
bool GLContextGLX::CreateWindowSurface(Window window_handle)
{
if (window_handle)
{
// Get an appropriate visual
XVisualInfo* vi = glXGetVisualFromFBConfig(m_display, m_fbconfig);
m_render_window = GLX11Window::Create(m_display, window_handle, vi);
if (!m_render_window)
return false;
m_backbuffer_width = m_render_window->GetWidth();
m_backbuffer_height = m_render_window->GetHeight();
m_drawable = static_cast<GLXDrawable>(m_render_window->GetWindow());
XFree(vi);
}
else if (m_supports_pbuffer)
{
m_pbuffer = glXCreateGLXPbufferSGIX(m_display, m_fbconfig, 1, 1, nullptr);
if (!m_pbuffer)
return false;
m_drawable = static_cast<GLXDrawable>(m_pbuffer);
}
return true;
}
void GLContextGLX::DestroyWindowSurface()
{
m_render_window.reset();
if (m_supports_pbuffer && m_pbuffer)
{
glXDestroyGLXPbufferSGIX(m_display, m_pbuffer);
m_pbuffer = 0;
}
}
bool GLContextGLX::MakeCurrent()
{
return glXMakeCurrent(m_display, m_drawable, m_context);
}
bool GLContextGLX::ClearCurrent()
{
return glXMakeCurrent(m_display, None, nullptr);
}
void GLContextGLX::Update()
{
m_render_window->UpdateDimensions();
m_backbuffer_width = m_render_window->GetWidth();
m_backbuffer_height = m_render_window->GetHeight();
}
Source/Core/Common/GL/GLInterface/GLX.h
-49
View File
@@ -1,49 +0,0 @@
// Copyright 2008 Dolphin Emulator Project
// SPDX-License-Identifier: GPL-2.0-or-later
#pragma once
#include <GL/glx.h>
#include <GL/glxext.h>
#include <memory>
#include <string>
#include <vector>
#include "Common/GL/GLContext.h"
#include "Common/GL/GLX11Window.h"
class GLContextGLX final : public GLContext
{
public:
~GLContextGLX() override;
bool IsHeadless() const override;
std::unique_ptr<GLContext> CreateSharedContext() override;
bool MakeCurrent() override;
bool ClearCurrent() override;
void Update() override;
void SwapInterval(int Interval) override;
void Swap() override;
void* GetFuncAddress(const std::string& name) override;
protected:
bool Initialize(const WindowSystemInfo& wsi, bool stereo, bool core) override;
Display* m_display = nullptr;
std::unique_ptr<GLX11Window> m_render_window;
GLXDrawable m_drawable = {};
GLXContext m_context = nullptr;
GLXFBConfig m_fbconfig = {};
bool m_supports_pbuffer = false;
GLXPbufferSGIX m_pbuffer = 0;
std::vector<int> m_attribs;
bool CreateWindowSurface(Window window_handle);
void DestroyWindowSurface();
};
Source/Core/VideoBackends/OGL/OGLMain.cpp
+2 -2
View File
@@ -76,7 +76,7 @@ std::string VideoBackend::GetDisplayName() const
void VideoBackend::InitBackendInfo(const WindowSystemInfo& wsi)
{
std::unique_ptr<GLContext> temp_gl_context =
GLContext::Create(wsi, g_Config.stereo_mode == StereoMode::QuadBuffer, true, false,
GLContext::Create(wsi, g_Config.stereo_mode == StereoMode::QuadBuffer, true,
Config::Get(Config::GFX_PREFER_GLES));
if (!temp_gl_context)
@@ -195,7 +195,7 @@ bool VideoBackend::FillBackendInfo(GLContext* context)
bool VideoBackend::Initialize(const WindowSystemInfo& wsi)
{
std::unique_ptr<GLContext> main_gl_context =
GLContext::Create(wsi, g_Config.stereo_mode == StereoMode::QuadBuffer, true, false,
GLContext::Create(wsi, g_Config.stereo_mode == StereoMode::QuadBuffer, true,
Config::Get(Config::GFX_PREFER_GLES));
if (!main_gl_context)
return false;