ShuriZma
/
duckstation
mirror of https://github.com/stenzek/duckstation
1
0
Fork 0
Code Issues Packages Projects Releases Wiki Activity

GLContext: Rename to OpenGLContext

This commit is contained in:
Stenzek 2024-02-25 19:22:25 +10:00
parent bd34e62440
commit 3813985112
No known key found for this signature in database
20 changed files with 310 additions and 309 deletions
Show Stats Download Patch File Download Diff File Expand all files Collapse all files

3
src/core/settings.cpp
View File

@ -1755,7 +1755,7 @@ static const char* s_log_filters[] = {
#endif
#ifdef ENABLE_OPENGL
"GL::Context",
"OpenGLContext",
"OpenGLDevice",
#endif
@ -1778,7 +1778,6 @@ static const char* s_log_filters[] = {
"CocoaProgressCallback",
"MetalDevice",
#else
"ContextEGLWayland",
"X11NoGUIPlatform",
"WaylandNoGUIPlatform",
#endif

26
src/util/CMakeLists.txt
View File

@ -95,8 +95,8 @@ endif()
if(ENABLE_OPENGL)
target_sources(util PRIVATE
gl/context.cpp
gl/context.h
opengl_context.cpp
opengl_context.h
opengl_device.cpp
opengl_device.h
opengl_loader.h
@ -112,29 +112,29 @@ if(ENABLE_OPENGL)
if(WIN32)
target_sources(util PRIVATE
gl/context_wgl.cpp
gl/context_wgl.h
opengl_context_wgl.cpp
opengl_context_wgl.h
)
target_link_libraries(util PRIVATE "opengl32.lib")
endif()
if(LINUX OR FREEBSD OR ANDROID)
target_sources(util PRIVATE
gl/context_egl.cpp
gl/context_egl.h
opengl_context_egl.cpp
opengl_context_egl.h
)
target_compile_definitions(util PRIVATE "-DENABLE_EGL=1")
if(ENABLE_X11)
target_sources(util PRIVATE
gl/context_egl_x11.cpp
gl/context_egl_x11.h
opengl_context_egl_x11.cpp
opengl_context_egl_x11.h
)
endif()
if(ENABLE_WAYLAND)
target_sources(util PRIVATE
gl/context_egl_wayland.cpp
gl/context_egl_wayland.h
opengl_context_egl_wayland.cpp
opengl_context_egl_wayland.h
)
endif()
if(ANDROID)
@ -144,10 +144,10 @@ if(ENABLE_OPENGL)
if(APPLE)
target_sources(util PRIVATE
gl/context_agl.mm
gl/context_agl.h
opengl_context_agl.mm
opengl_context_agl.h
)
set_source_files_properties(gl/context_agl.mm PROPERTIES SKIP_PRECOMPILE_HEADERS TRUE)
set_source_files_properties(opengl_context_agl.mm PROPERTIES SKIP_PRECOMPILE_HEADERS TRUE)
endif()
endif()

44
src/util/gl/context_egl_x11.cpp
View File

@ -1,44 +0,0 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#include "context_egl_x11.h"
#include "common/error.h"
namespace GL {
ContextEGLX11::ContextEGLX11(const WindowInfo& wi) : ContextEGL(wi)
{
}
ContextEGLX11::~ContextEGLX11() = default;
std::unique_ptr<Context> ContextEGLX11::Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error)
{
std::unique_ptr<ContextEGLX11> context = std::make_unique<ContextEGLX11>(wi);
if (!context->Initialize(versions_to_try, error))
return nullptr;
return context;
}
std::unique_ptr<Context> ContextEGLX11::CreateSharedContext(const WindowInfo& wi, Error* error)
{
std::unique_ptr<ContextEGLX11> context = std::make_unique<ContextEGLX11>(wi);
context->m_display = m_display;
if (!context->CreateContextAndSurface(m_version, m_context, false))
return nullptr;
return context;
}
EGLDisplay ContextEGLX11::GetPlatformDisplay(const EGLAttrib* attribs, Error* error)
{
EGLDisplay dpy = TryGetPlatformDisplay(EGL_PLATFORM_X11_KHR, attribs);
if (dpy == EGL_NO_DISPLAY)
dpy = GetFallbackDisplay(error);
return dpy;
}
} // namespace GL

23
src/util/gl/context_egl_x11.h
View File

@ -1,23 +0,0 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#pragma once
#include "context_egl.h"
namespace GL {
class ContextEGLX11 final : public ContextEGL
{
public:
ContextEGLX11(const WindowInfo& wi);
~ContextEGLX11() override;
static std::unique_ptr<Context> Create(const WindowInfo& wi, std::span<const Version> versions_to_try, Error* error);
std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
protected:
EGLDisplay GetPlatformDisplay(const EGLAttrib* attribs, Error* error) override;
};
} // namespace GL

47
src/util/gl/context.cpp → src/util/opengl_context.cpp
View File

@ -1,8 +1,8 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#include "context.h"
#include "../opengl_loader.h"
#include "opengl_context.h"
#include "opengl_loader.h"
#include "common/error.h"
#include "common/log.h"
@ -16,25 +16,23 @@
#endif
#if defined(_WIN32) && !defined(_M_ARM64)
#include "context_wgl.h"
#include "opengl_context_wgl.h"
#elif defined(__APPLE__)
#include "context_agl.h"
#include "opengl_context_agl.h"
#elif defined(__ANDROID__)
#include "context_egl_android.h"
#include "opengl_context_egl_android.h"
#else
#ifdef ENABLE_EGL
#ifdef ENABLE_WAYLAND
#include "context_egl_wayland.h"
#include "opengl_context_egl_wayland.h"
#endif
#ifdef ENABLE_X11
#include "context_egl_x11.h"
#include "opengl_context_egl_x11.h"
#endif
#endif
#endif
Log_SetChannel(GL::Context);
namespace GL {
Log_SetChannel(OpenGLContext);
static bool ShouldPreferESContext()
{
@ -107,18 +105,18 @@ static void DisableBrokenExtensions(const char* gl_vendor, const char* gl_render
}
}
Context::Context(const WindowInfo& wi) : m_wi(wi)
OpenGLContext::OpenGLContext(const WindowInfo& wi) : m_wi(wi)
{
}
Context::~Context() = default;
OpenGLContext::~OpenGLContext() = default;
std::vector<Context::FullscreenModeInfo> Context::EnumerateFullscreenModes()
std::vector<OpenGLContext::FullscreenModeInfo> OpenGLContext::EnumerateFullscreenModes()
{
return {};
}
std::unique_ptr<GL::Context> Context::Create(const WindowInfo& wi, Error* error)
std::unique_ptr<OpenGLContext> OpenGLContext::Create(const WindowInfo& wi, Error* error)
{
static constexpr std::array<Version, 14> vlist = {{{Profile::Core, 4, 6},
{Profile::Core, 4, 5},
@ -154,37 +152,34 @@ std::unique_ptr<GL::Context> Context::Create(const WindowInfo& wi, Error* error)
versions_to_try = std::span<const Version>(new_versions_to_try, versions_to_try.size());
}
std::unique_ptr<Context> context;
std::unique_ptr<OpenGLContext> context;
Error local_error;
#if defined(_WIN32) && !defined(_M_ARM64)
context = ContextWGL::Create(wi, versions_to_try, error ? error : &local_error);
context = OpenGLContextWGL::Create(wi, versions_to_try, error);
#elif defined(__APPLE__)
context = ContextAGL::Create(wi, versions_to_try);
context = OpenGLContextAGL::Create(wi, versions_to_try, error);
#elif defined(__ANDROID__)
context = ContextEGLAndroid::Create(wi, versions_to_try, error ? error : &local_error);
context = ContextEGLAndroid::Create(wi, versions_to_try, error);
#else
#if defined(ENABLE_X11)
if (wi.type == WindowInfo::Type::X11)
context = ContextEGLX11::Create(wi, versions_to_try, error ? error : &local_error);
context = OpenGLContextEGLX11::Create(wi, versions_to_try, error);
#endif
#if defined(ENABLE_WAYLAND)
if (wi.type == WindowInfo::Type::Wayland)
context = ContextEGLWayland::Create(wi, versions_to_try, error ? error : &local_error);
context = OpenGLContextEGLWayland::Create(wi, versions_to_try, error);
#endif
if (wi.type == WindowInfo::Type::Surfaceless)
context = ContextEGL::Create(wi, versions_to_try, error ? error : &local_error);
context = OpenGLContextEGL::Create(wi, versions_to_try, error);
#endif
if (!context)
{
Log_ErrorFmt("Failed to create GL context: {}", (error ? error : &local_error)->GetDescription());
return nullptr;
}
Log_InfoPrint(context->IsGLES() ? "Created an OpenGL ES context" : "Created an OpenGL context");
// TODO: Not thread-safe.
static Context* context_being_created;
static OpenGLContext* context_being_created;
context_being_created = context.get();
// load up glad
@ -218,5 +213,3 @@ std::unique_ptr<GL::Context> Context::Create(const WindowInfo& wi, Error* error)
return context;
}
} // namespace GL

14
src/util/gl/context.h → src/util/opengl_context.h
View File

@ -3,7 +3,7 @@
#pragma once
#include "../window_info.h"
#include "window_info.h"
#include "common/types.h"
@ -13,12 +13,11 @@
class Error;
namespace GL {
class Context
class OpenGLContext
{
public:
Context(const WindowInfo& wi);
virtual ~Context();
OpenGLContext(const WindowInfo& wi);
virtual ~OpenGLContext();
enum class Profile
{
@ -55,14 +54,13 @@ public:
virtual bool MakeCurrent() = 0;
virtual bool DoneCurrent() = 0;
virtual bool SetSwapInterval(s32 interval) = 0;
virtual std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) = 0;
virtual std::unique_ptr<OpenGLContext> CreateSharedContext(const WindowInfo& wi, Error* error) = 0;
virtual std::vector<FullscreenModeInfo> EnumerateFullscreenModes();
static std::unique_ptr<Context> Create(const WindowInfo& wi, Error* error);
static std::unique_ptr<OpenGLContext> Create(const WindowInfo& wi, Error* error);
protected:
WindowInfo m_wi;
Version m_version = {};
};
} // namespace GL

26
src/util/gl/context_agl.h → src/util/opengl_context_agl.h
View File

@ -1,9 +1,10 @@
// SPDX-FileCopyrightText: 2019-2022 Connor McLaughlin <stenzek@gmail.com>
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#pragma once
#include "../opengl_loader.h"
#include "context.h"
#include "opengl_context.h"
#include "opengl_loader.h"
#if defined(__APPLE__) && defined(__OBJC__)
#import <AppKit/AppKit.h>
@ -14,15 +15,14 @@ struct NSView;
#define __bridge
#endif
namespace GL {
class ContextAGL final : public Context
class OpenGLContextAGL final : public OpenGLContext
{
public:
ContextAGL(const WindowInfo& wi);
~ContextAGL() override;
OpenGLContextAGL(const WindowInfo& wi);
~OpenGLContextAGL() override;
static std::unique_ptr<Context> Create(const WindowInfo& wi, std::span<const Version> versions_to_try);
static std::unique_ptr<OpenGLContext> Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error);
void* GetProcAddress(const char* name) override;
bool ChangeSurface(const WindowInfo& new_wi) override;
@ -32,13 +32,13 @@ public:
bool MakeCurrent() override;
bool DoneCurrent() override;
bool SetSwapInterval(s32 interval) override;
std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
std::unique_ptr<OpenGLContext> CreateSharedContext(const WindowInfo& wi, Error* error) override;
private:
ALWAYS_INLINE NSView* GetView() const { return static_cast<NSView*>((__bridge NSView*)m_wi.window_handle); }
bool Initialize(std::span<const Version> versions_to_try);
bool CreateContext(NSOpenGLContext* share_context, int profile, bool make_current);
bool Initialize(std::span<const Version> versions_to_try, Error* error);
bool CreateContext(NSOpenGLContext* share_context, int profile, bool make_current, Error* error);
void BindContextToView();
// returns true if dimensions have changed
@ -48,5 +48,3 @@ private:
NSOpenGLPixelFormat* m_pixel_format = nullptr;
void* m_opengl_module_handle = nullptr;
};
} // namespace GL

61
src/util/gl/context_agl.mm → src/util/opengl_context_agl.mm
View File

@ -1,22 +1,24 @@
// SPDX-FileCopyrightText: 2019-2022 Connor McLaughlin <stenzek@gmail.com>
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#include "context_agl.h"
#include "opengl_context_agl.h"
#include "common/assert.h"
#include "common/error.h"
#include "common/log.h"
#include <dlfcn.h>
Log_SetChannel(GL::Context);
namespace GL {
ContextAGL::ContextAGL(const WindowInfo& wi) : Context(wi)
#include <dlfcn.h>
Log_SetChannel(OpenGLContext);
OpenGLContextAGL::OpenGLContextAGL(const WindowInfo& wi) : OpenGLContext(wi)
{
m_opengl_module_handle = 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()
OpenGLContextAGL::~OpenGLContextAGL()
{
if ([NSOpenGLContext currentContext] == m_context)
[NSOpenGLContext clearCurrentContext];
@ -31,20 +33,20 @@ ContextAGL::~ContextAGL()
dlclose(m_opengl_module_handle);
}
std::unique_ptr<Context> ContextAGL::Create(const WindowInfo& wi, std::span<const Version> versions_to_try)
std::unique_ptr<OpenGLContext> OpenGLContextAGL::Create(const WindowInfo& wi, std::span<const Version> versions_to_try, Error* error)
{
std::unique_ptr<ContextAGL> context = std::make_unique<ContextAGL>(wi);
if (!context->Initialize(versions_to_try))
std::unique_ptr<OpenGLContextAGL> context = std::make_unique<OpenGLContextAGL>(wi);
if (!context->Initialize(versions_to_try, error))
return nullptr;
return context;
}
bool ContextAGL::Initialize(const std::span<const Version> versions_to_try)
bool OpenGLContextAGL::Initialize(const std::span<const Version> versions_to_try, Error* error)
{
for (const Version& cv : versions_to_try)
{
if (cv.profile == Profile::NoProfile && CreateContext(nullptr, NSOpenGLProfileVersionLegacy, true))
if (cv.profile == Profile::NoProfile && CreateContext(nullptr, NSOpenGLProfileVersionLegacy, true, error))
{
// we already have the dummy context, so just use that
m_version = cv;
@ -57,7 +59,7 @@ bool ContextAGL::Initialize(const std::span<const Version> versions_to_try)
const NSOpenGLPixelFormatAttribute profile =
(cv.major_version > 3 || cv.minor_version > 2) ? NSOpenGLProfileVersion4_1Core : NSOpenGLProfileVersion3_2Core;
if (CreateContext(nullptr, static_cast<int>(profile), true))
if (CreateContext(nullptr, static_cast<int>(profile), true, error))
{
m_version = cv;
return true;
@ -65,10 +67,11 @@ bool ContextAGL::Initialize(const std::span<const Version> versions_to_try)
}
}
Error::SetStringView(error, "Failed to create any context versions.");
return false;
}
void* ContextAGL::GetProcAddress(const char* name)
void* OpenGLContextAGL::GetProcAddress(const char* name)
{
void* addr = m_opengl_module_handle ? dlsym(m_opengl_module_handle, name) : nullptr;
if (addr)
@ -77,19 +80,19 @@ void* ContextAGL::GetProcAddress(const char* name)
return dlsym(RTLD_NEXT, name);
}
bool ContextAGL::ChangeSurface(const WindowInfo& new_wi)
bool OpenGLContextAGL::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 OpenGLContextAGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
{
UpdateDimensions();
}
bool ContextAGL::UpdateDimensions()
bool OpenGLContextAGL::UpdateDimensions()
{
const NSSize window_size = [GetView() frame].size;
const CGFloat window_scale = [[GetView() window] backingScaleFactor];
@ -114,39 +117,39 @@ bool ContextAGL::UpdateDimensions()
return true;
}
bool ContextAGL::SwapBuffers()
bool OpenGLContextAGL::SwapBuffers()
{
[m_context flushBuffer];
return true;
}
bool ContextAGL::IsCurrent()
bool OpenGLContextAGL::IsCurrent()
{
return (m_context != nil && [NSOpenGLContext currentContext] == m_context);
}
bool ContextAGL::MakeCurrent()
bool OpenGLContextAGL::MakeCurrent()
{
[m_context makeCurrentContext];
return true;
}
bool ContextAGL::DoneCurrent()
bool OpenGLContextAGL::DoneCurrent()
{
[NSOpenGLContext clearCurrentContext];
return true;
}
bool ContextAGL::SetSwapInterval(s32 interval)
bool OpenGLContextAGL::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, Error* error)
std::unique_ptr<OpenGLContext> OpenGLContextAGL::CreateSharedContext(const WindowInfo& wi, Error* error)
{
std::unique_ptr<ContextAGL> context = std::make_unique<ContextAGL>(wi);
std::unique_ptr<OpenGLContextAGL> context = std::make_unique<OpenGLContextAGL>(wi);
context->m_context = [[NSOpenGLContext alloc] initWithFormat:m_pixel_format shareContext:m_context];
if (context->m_context == nil)
@ -165,7 +168,7 @@ std::unique_ptr<Context> ContextAGL::CreateSharedContext(const WindowInfo& wi, E
return context;
}
bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool make_current)
bool OpenGLContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool make_current, Error* error)
{
if (m_context)
{
@ -182,13 +185,16 @@ bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool
m_pixel_format = [[NSOpenGLPixelFormat alloc] initWithAttributes:attribs.data()];
if (m_pixel_format == nil)
{
Log_ErrorPrintf("Failed to initialize pixel format");
Error::SetStringView(error, "Failed to initialize pixel format");
return false;
}
m_context = [[NSOpenGLContext alloc] initWithFormat:m_pixel_format shareContext:nil];
if (m_context == nil)
{
Error::SetStringView(error, "NSOpenGLContext initWithFormat failed");
return false;
}
if (m_wi.type == WindowInfo::Type::MacOS)
BindContextToView();
@ -199,7 +205,7 @@ bool ContextAGL::CreateContext(NSOpenGLContext* share_context, int profile, bool
return true;
}
void ContextAGL::BindContextToView()
void OpenGLContextAGL::BindContextToView()
{
NSView* const view = GetView();
NSWindow* const window = [view window];
@ -218,4 +224,3 @@ void ContextAGL::BindContextToView()
else
dispatch_sync(dispatch_get_main_queue(), block);
}
} // namespace GL

78
src/util/gl/context_egl.cpp → src/util/opengl_context_egl.cpp
View File

@ -1,7 +1,7 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#include "context_egl.h"
#include "opengl_context_egl.h"
#include "common/assert.h"
#include "common/dynamic_library.h"
@ -13,7 +13,7 @@
#include <optional>
#include <vector>
Log_SetChannel(GL::Context);
Log_SetChannel(OpenGLContext);
static DynamicLibrary s_egl_library;
static std::atomic_uint32_t s_egl_refcount = 0;
@ -77,30 +77,29 @@ static std::vector<EGLint> EGLAttribToInt(const EGLAttrib* attribs)
return int_attribs;
}
namespace GL {
ContextEGL::ContextEGL(const WindowInfo& wi) : Context(wi)
OpenGLContextEGL::OpenGLContextEGL(const WindowInfo& wi) : OpenGLContext(wi)
{
LoadEGL();
}
ContextEGL::~ContextEGL()
OpenGLContextEGL::~OpenGLContextEGL()
{
DestroySurface();
DestroyContext();
UnloadEGL();
}
std::unique_ptr<Context> ContextEGL::Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error)
std::unique_ptr<OpenGLContext> OpenGLContextEGL::Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error)
{
std::unique_ptr<ContextEGL> context = std::make_unique<ContextEGL>(wi);
std::unique_ptr<OpenGLContextEGL> context = std::make_unique<OpenGLContextEGL>(wi);
if (!context->Initialize(versions_to_try, error))
return nullptr;
return context;
}
bool ContextEGL::Initialize(std::span<const Version> versions_to_try, Error* error)
bool OpenGLContextEGL::Initialize(std::span<const Version> versions_to_try, Error* error)
{
if (!LoadGLADEGL(EGL_NO_DISPLAY, error))
return false;
@ -136,7 +135,7 @@ bool ContextEGL::Initialize(std::span<const Version> versions_to_try, Error* err
return false;
}
EGLDisplay ContextEGL::GetPlatformDisplay(const EGLAttrib* attribs, Error* error)
EGLDisplay OpenGLContextEGL::GetPlatformDisplay(const EGLAttrib* attribs, Error* error)
{
EGLDisplay dpy = TryGetPlatformDisplay(EGL_PLATFORM_SURFACELESS_MESA, attribs);
if (dpy == EGL_NO_DISPLAY)
@ -145,7 +144,7 @@ EGLDisplay ContextEGL::GetPlatformDisplay(const EGLAttrib* attribs, Error* error
return dpy;
}
EGLDisplay ContextEGL::TryGetPlatformDisplay(EGLenum platform, const EGLAttrib* attribs)
EGLDisplay OpenGLContextEGL::TryGetPlatformDisplay(EGLenum platform, const EGLAttrib* attribs)
{
const char* extensions_str = eglQueryString(EGL_NO_DISPLAY, EGL_EXTENSIONS);
if (!extensions_str)
@ -203,7 +202,7 @@ EGLDisplay ContextEGL::TryGetPlatformDisplay(EGLenum platform, const EGLAttrib*
return dpy;
}
EGLDisplay ContextEGL::GetFallbackDisplay(Error* error)
EGLDisplay OpenGLContextEGL::GetFallbackDisplay(Error* error)
{
Log_WarningPrint("Using fallback eglGetDisplay() path.");
EGLDisplay dpy = eglGetDisplay(m_wi.display_connection);
@ -216,7 +215,7 @@ EGLDisplay ContextEGL::GetFallbackDisplay(Error* error)
return dpy;
}
EGLSurface ContextEGL::CreatePlatformSurface(EGLConfig config, const EGLAttrib* attribs, Error* error)
EGLSurface OpenGLContextEGL::CreatePlatformSurface(EGLConfig config, const EGLAttrib* attribs, Error* error)
{
EGLSurface surface = EGL_NO_SURFACE;
if (GLAD_EGL_VERSION_1_5)
@ -234,7 +233,7 @@ EGLSurface ContextEGL::CreatePlatformSurface(EGLConfig config, const EGLAttrib*
return surface;
}
EGLSurface ContextEGL::CreateFallbackSurface(EGLConfig config, const EGLAttrib* attribs, void* win, Error* error)
EGLSurface OpenGLContextEGL::CreateFallbackSurface(EGLConfig config, const EGLAttrib* attribs, void* win, Error* error)
{
Log_WarningPrint("Using fallback eglCreateWindowSurface() path.");
@ -251,12 +250,12 @@ EGLSurface ContextEGL::CreateFallbackSurface(EGLConfig config, const EGLAttrib*
return surface;
}
void* ContextEGL::GetProcAddress(const char* name)
void* OpenGLContextEGL::GetProcAddress(const char* name)
{
return reinterpret_cast<void*>(eglGetProcAddress(name));
}
bool ContextEGL::ChangeSurface(const WindowInfo& new_wi)
bool OpenGLContextEGL::ChangeSurface(const WindowInfo& new_wi)
{
const bool was_current = (eglGetCurrentContext() == m_context);
if (was_current)
@ -281,7 +280,7 @@ bool ContextEGL::ChangeSurface(const WindowInfo& new_wi)
return true;
}
void ContextEGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
void OpenGLContextEGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
{
if (new_surface_width == 0 && new_surface_height == 0)
{
@ -303,17 +302,17 @@ void ContextEGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_he
m_wi.surface_height = new_surface_height;
}
bool ContextEGL::SwapBuffers()
bool OpenGLContextEGL::SwapBuffers()
{
return eglSwapBuffers(m_display, m_surface);
}
bool ContextEGL::IsCurrent()
bool OpenGLContextEGL::IsCurrent()
{
return m_context && eglGetCurrentContext() == m_context;
}
bool ContextEGL::MakeCurrent()
bool OpenGLContextEGL::MakeCurrent()
{
if (!eglMakeCurrent(m_display, m_surface, m_surface, m_context))
{
@ -324,19 +323,19 @@ bool ContextEGL::MakeCurrent()
return true;
}
bool ContextEGL::DoneCurrent()
bool OpenGLContextEGL::DoneCurrent()
{
return eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
}
bool ContextEGL::SetSwapInterval(s32 interval)
bool OpenGLContextEGL::SetSwapInterval(s32 interval)
{
return eglSwapInterval(m_display, interval);
}
std::unique_ptr<Context> ContextEGL::CreateSharedContext(const WindowInfo& wi, Error* error)
std::unique_ptr<OpenGLContext> OpenGLContextEGL::CreateSharedContext(const WindowInfo& wi, Error* error)
{
std::unique_ptr<ContextEGL> context = std::make_unique<ContextEGL>(wi);
std::unique_ptr<OpenGLContextEGL> context = std::make_unique<OpenGLContextEGL>(wi);
context->m_display = m_display;
if (!context->CreateContextAndSurface(m_version, m_context, false))
@ -348,7 +347,7 @@ std::unique_ptr<Context> ContextEGL::CreateSharedContext(const WindowInfo& wi, E
return context;
}
bool ContextEGL::CreateSurface()
bool OpenGLContextEGL::CreateSurface()
{
if (m_wi.type == WindowInfo::Type::Surfaceless)
{
@ -384,7 +383,7 @@ bool ContextEGL::CreateSurface()
return true;
}
bool ContextEGL::CreatePBufferSurface()
bool OpenGLContextEGL::CreatePBufferSurface()
{
const u32 width = std::max<u32>(m_wi.surface_width, 1);
const u32 height = std::max<u32>(m_wi.surface_height, 1);
@ -407,7 +406,7 @@ bool ContextEGL::CreatePBufferSurface()
return true;
}
bool ContextEGL::CheckConfigSurfaceFormat(EGLConfig config, GPUTexture::Format format)
bool OpenGLContextEGL::CheckConfigSurfaceFormat(EGLConfig config, GPUTexture::Format format)
{
int red_size, green_size, blue_size, alpha_size;
if (!eglGetConfigAttrib(m_display, config, EGL_RED_SIZE, &red_size) ||
@ -437,7 +436,7 @@ bool ContextEGL::CheckConfigSurfaceFormat(EGLConfig config, GPUTexture::Format f
}
}
GPUTexture::Format ContextEGL::GetSurfaceTextureFormat() const
GPUTexture::Format OpenGLContextEGL::GetSurfaceTextureFormat() const
{
int red_size = 0, green_size = 0, blue_size = 0, alpha_size = 0;
eglGetConfigAttrib(m_display, m_config, EGL_RED_SIZE, &red_size);
@ -464,7 +463,7 @@ GPUTexture::Format ContextEGL::GetSurfaceTextureFormat() const
}
}
void ContextEGL::DestroyContext()
void OpenGLContextEGL::DestroyContext()
{
if (eglGetCurrentContext() == m_context)
eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
@ -476,7 +475,7 @@ void ContextEGL::DestroyContext()
}
}
void ContextEGL::DestroySurface()
void OpenGLContextEGL::DestroySurface()
{
if (eglGetCurrentSurface(EGL_DRAW) == m_surface)
eglMakeCurrent(m_display, EGL_NO_SURFACE, EGL_NO_SURFACE, EGL_NO_CONTEXT);
@ -488,11 +487,12 @@ void ContextEGL::DestroySurface()
}
}
bool ContextEGL::CreateContext(const Version& version, EGLContext share_context)
bool OpenGLContextEGL::CreateContext(const Version& version, EGLContext share_context)
{
Log_DevPrintf(
"Trying version %u.%u (%s)", version.major_version, version.minor_version,
version.profile == Context::Profile::ES ? "ES" : (version.profile == Context::Profile::Core ? "Core" : "None"));
Log_DevPrintf("Trying version %u.%u (%s)", version.major_version, version.minor_version,
version.profile == OpenGLContext::Profile::ES ?
"ES" :
(version.profile == OpenGLContext::Profile::Core ? "Core" : "None"));
int surface_attribs[16] = {
EGL_RENDERABLE_TYPE,
(version.profile == Profile::ES) ?
@ -600,16 +600,17 @@ bool ContextEGL::CreateContext(const Version& version, EGLContext share_context)
return false;
}
Log_InfoPrintf(
"Got version %u.%u (%s)", version.major_version, version.minor_version,
version.profile == Context::Profile::ES ? "ES" : (version.profile == Context::Profile::Core ? "Core" : "None"));
Log_InfoPrintf("Got version %u.%u (%s)", version.major_version, version.minor_version,
version.profile == OpenGLContext::Profile::ES ?
"ES" :
(version.profile == OpenGLContext::Profile::Core ? "Core" : "None"));
m_config = config.value();
m_version = version;
return true;
}
bool ContextEGL::CreateContextAndSurface(const Version& version, EGLContext share_context, bool make_current)
bool OpenGLContextEGL::CreateContextAndSurface(const Version& version, EGLContext share_context, bool make_current)
{
if (!CreateContext(version, share_context))
return false;
@ -637,4 +638,3 @@ bool ContextEGL::CreateContextAndSurface(const Version& version, EGLContext shar
return true;
}
} // namespace GL

18
src/util/gl/context_egl.h → src/util/opengl_context_egl.h
View File

@ -3,19 +3,18 @@
#pragma once
#include "context.h"
#include "opengl_context.h"
#include "glad/egl.h"
namespace GL {
class ContextEGL : public Context
class OpenGLContextEGL : public OpenGLContext
{
public:
ContextEGL(const WindowInfo& wi);
~ContextEGL() override;
OpenGLContextEGL(const WindowInfo& wi);
~OpenGLContextEGL() override;
static std::unique_ptr<Context> Create(const WindowInfo& wi, std::span<const Version> versions_to_try, Error* error);
static std::unique_ptr<OpenGLContext> Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error);
void* GetProcAddress(const char* name) override;
virtual bool ChangeSurface(const WindowInfo& new_wi) override;
@ -25,7 +24,7 @@ public:
bool MakeCurrent() override;
bool DoneCurrent() override;
bool SetSwapInterval(s32 interval) override;
virtual std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
virtual std::unique_ptr<OpenGLContext> CreateSharedContext(const WindowInfo& wi, Error* error) override;
protected:
virtual EGLDisplay GetPlatformDisplay(const EGLAttrib* attribs, Error* error);
@ -36,7 +35,6 @@ protected:
EGLSurface CreateFallbackSurface(EGLConfig config, const EGLAttrib* attribs, void* window, Error* error);
bool Initialize(std::span<const Version> versions_to_try, Error* error);
bool CreateDisplay();
bool CreateContext(const Version& version, EGLContext share_context);
bool CreateContextAndSurface(const Version& version, EGLContext share_context, bool make_current);
bool CreateSurface();
@ -52,5 +50,3 @@ protected:
EGLConfig m_config = {};
};
} // namespace GL

41
src/util/gl/context_egl_wayland.cpp → src/util/opengl_context_egl_wayland.cpp
View File

@ -1,22 +1,19 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#include "context_egl_wayland.h"
#include "opengl_context_egl_wayland.h"
#include "common/error.h"
#include "common/log.h"
#include <dlfcn.h>
Log_SetChannel(ContextEGL);
namespace GL {
static const char* WAYLAND_EGL_MODNAME = "libwayland-egl.so.1";
ContextEGLWayland::ContextEGLWayland(const WindowInfo& wi) : ContextEGL(wi)
OpenGLContextEGLWayland::OpenGLContextEGLWayland(const WindowInfo& wi) : OpenGLContextEGL(wi)
{
}
ContextEGLWayland::~ContextEGLWayland()
OpenGLContextEGLWayland::~OpenGLContextEGLWayland()
{
if (m_wl_window)
m_wl_egl_window_destroy(m_wl_window);
@ -24,36 +21,36 @@ ContextEGLWayland::~ContextEGLWayland()
dlclose(m_wl_module);
}
std::unique_ptr<Context> ContextEGLWayland::Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error)
std::unique_ptr<OpenGLContext> OpenGLContextEGLWayland::Create(const WindowInfo& wi,
std::span<const Version> versions_to_try, Error* error)
{
std::unique_ptr<ContextEGLWayland> context = std::make_unique<ContextEGLWayland>(wi);
if (!context->LoadModule() || !context->Initialize(versions_to_try, error))
std::unique_ptr<OpenGLContextEGLWayland> context = std::make_unique<OpenGLContextEGLWayland>(wi);
if (!context->LoadModule(error) || !context->Initialize(versions_to_try, error))
return nullptr;
return context;
}
std::unique_ptr<Context> ContextEGLWayland::CreateSharedContext(const WindowInfo& wi, Error* error)
std::unique_ptr<OpenGLContext> OpenGLContextEGLWayland::CreateSharedContext(const WindowInfo& wi, Error* error)
{
std::unique_ptr<ContextEGLWayland> context = std::make_unique<ContextEGLWayland>(wi);
std::unique_ptr<OpenGLContextEGLWayland> context = std::make_unique<OpenGLContextEGLWayland>(wi);
context->m_display = m_display;
if (!context->LoadModule() || !context->CreateContextAndSurface(m_version, m_context, false))
if (!context->LoadModule(error) || !context->CreateContextAndSurface(m_version, m_context, false))
return nullptr;
return context;
}
void ContextEGLWayland::ResizeSurface(u32 new_surface_width, u32 new_surface_height)
void OpenGLContextEGLWayland::ResizeSurface(u32 new_surface_width, u32 new_surface_height)
{
if (m_wl_window)
m_wl_egl_window_resize(m_wl_window, new_surface_width, new_surface_height, 0, 0);
ContextEGL::ResizeSurface(new_surface_width, new_surface_height);
OpenGLContextEGL::ResizeSurface(new_surface_width, new_surface_height);
}
EGLDisplay ContextEGLWayland::GetPlatformDisplay(const EGLAttrib* attribs, Error* error)
EGLDisplay OpenGLContextEGLWayland::GetPlatformDisplay(const EGLAttrib* attribs, Error* error)
{
EGLDisplay dpy = TryGetPlatformDisplay(EGL_PLATFORM_WAYLAND_KHR, attribs);
if (dpy == EGL_NO_DISPLAY)
@ -62,7 +59,7 @@ EGLDisplay ContextEGLWayland::GetPlatformDisplay(const EGLAttrib* attribs, Error
return dpy;
}
EGLSurface ContextEGLWayland::CreatePlatformSurface(EGLConfig config, const EGLAttrib* attribs, Error* error)
EGLSurface OpenGLContextEGLWayland::CreatePlatformSurface(EGLConfig config, const EGLAttrib* attribs, Error* error)
{
if (m_wl_window)
{
@ -100,12 +97,13 @@ EGLSurface ContextEGLWayland::CreatePlatformSurface(EGLConfig config, const EGLA
return surface;
}
bool ContextEGLWayland::LoadModule()
bool OpenGLContextEGLWayland::LoadModule(Error* error)
{
m_wl_module = dlopen(WAYLAND_EGL_MODNAME, RTLD_NOW | RTLD_GLOBAL);
if (!m_wl_module)
{
Log_ErrorPrintf("Failed to load %s.", WAYLAND_EGL_MODNAME);
const char* err = dlerror();
Error::SetStringFmt(error, "Loading {} failed: {}", WAYLAND_EGL_MODNAME, err ? err : "<UNKNOWN>");
return false;
}
@ -117,10 +115,9 @@ bool ContextEGLWayland::LoadModule()
reinterpret_cast<decltype(m_wl_egl_window_resize)>(dlsym(m_wl_module, "wl_egl_window_resize"));
if (!m_wl_egl_window_create || !m_wl_egl_window_destroy || !m_wl_egl_window_resize)
{
Log_ErrorPrintf("Failed to load one or more functions from %s.", WAYLAND_EGL_MODNAME);
Error::SetStringFmt(error, "Failed to load one or more functions from {}.", WAYLAND_EGL_MODNAME);
return false;
}
return true;
}
} // namespace GL

21
src/util/gl/context_egl_wayland.h → src/util/opengl_context_egl_wayland.h
View File

@ -2,20 +2,21 @@
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#pragma once
#include "context_egl.h"
#include "opengl_context_egl.h"
#include <wayland-egl.h>
namespace GL {
class ContextEGLWayland final : public ContextEGL
class OpenGLContextEGLWayland final : public OpenGLContextEGL
{
public:
ContextEGLWayland(const WindowInfo& wi);
~ContextEGLWayland() override;
OpenGLContextEGLWayland(const WindowInfo& wi);
~OpenGLContextEGLWayland() override;
static std::unique_ptr<Context> Create(const WindowInfo& wi, std::span<const Version> versions_to_try, Error* error);
static std::unique_ptr<OpenGLContext> Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error);
std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
std::unique_ptr<OpenGLContext> CreateSharedContext(const WindowInfo& wi, Error* error) override;
void ResizeSurface(u32 new_surface_width = 0, u32 new_surface_height = 0) override;
protected:
@ -23,7 +24,7 @@ protected:
EGLSurface CreatePlatformSurface(EGLConfig config, const EGLAttrib* attribs, Error* error) override;
private:
bool LoadModule();
bool LoadModule(Error* error);
wl_egl_window* m_wl_window = nullptr;
@ -32,5 +33,3 @@ private:
void (*m_wl_egl_window_destroy)(struct wl_egl_window* egl_window);
void (*m_wl_egl_window_resize)(struct wl_egl_window* egl_window, int width, int height, int dx, int dy);
};
} // namespace GL

42
src/util/opengl_context_egl_x11.cpp Normal file
View File

@ -0,0 +1,42 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#include "opengl_context_egl_x11.h"
#include "common/error.h"
OpenGLContextEGLX11::OpenGLContextEGLX11(const WindowInfo& wi) : OpenGLContextEGL(wi)
{
}
OpenGLContextEGLX11::~OpenGLContextEGLX11() = default;
std::unique_ptr<OpenGLContext> OpenGLContextEGLX11::Create(const WindowInfo& wi,
std::span<const Version> versions_to_try, Error* error)
{
std::unique_ptr<OpenGLContextEGLX11> context = std::make_unique<OpenGLContextEGLX11>(wi);
if (!context->Initialize(versions_to_try, error))
return nullptr;
return context;
}
std::unique_ptr<OpenGLContext> OpenGLContextEGLX11::CreateSharedContext(const WindowInfo& wi, Error* error)
{
std::unique_ptr<OpenGLContextEGLX11> context = std::make_unique<OpenGLContextEGLX11>(wi);
context->m_display = m_display;
if (!context->CreateContextAndSurface(m_version, m_context, false))
return nullptr;
return context;
}
EGLDisplay OpenGLContextEGLX11::GetPlatformDisplay(const EGLAttrib* attribs, Error* error)
{
EGLDisplay dpy = TryGetPlatformDisplay(EGL_PLATFORM_X11_KHR, attribs);
if (dpy == EGL_NO_DISPLAY)
dpy = GetFallbackDisplay(error);
return dpy;
}

21
src/util/opengl_context_egl_x11.h Normal file
View File

@ -0,0 +1,21 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#pragma once
#include "opengl_context_egl.h"
class OpenGLContextEGLX11 final : public OpenGLContextEGL
{
public:
OpenGLContextEGLX11(const WindowInfo& wi);
~OpenGLContextEGLX11() override;
static std::unique_ptr<OpenGLContext> Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error);
std::unique_ptr<OpenGLContext> CreateSharedContext(const WindowInfo& wi, Error* error) override;
protected:
EGLDisplay GetPlatformDisplay(const EGLAttrib* attribs, Error* error) override;
};

53
src/util/gl/context_wgl.cpp → src/util/opengl_context_wgl.cpp
View File

@ -1,15 +1,15 @@
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#include "context_wgl.h"
#include "../opengl_loader.h"
#include "opengl_context_wgl.h"
#include "opengl_loader.h"
#include "common/assert.h"
#include "common/error.h"
#include "common/log.h"
#include "common/scoped_guard.h"
Log_SetChannel(GL::Context);
Log_SetChannel(GL::OpenGLContext);
#ifdef __clang__
#pragma clang diagnostic ignored "-Wmicrosoft-cast"
@ -36,12 +36,11 @@ static bool ReloadWGL(HDC dc)
return true;
}
namespace GL {
ContextWGL::ContextWGL(const WindowInfo& wi) : Context(wi)
OpenGLContextWGL::OpenGLContextWGL(const WindowInfo& wi) : OpenGLContext(wi)
{
}
ContextWGL::~ContextWGL()
OpenGLContextWGL::~OpenGLContextWGL()
{
if (wglGetCurrentContext() == m_rc)
wglMakeCurrent(m_dc, nullptr);
@ -52,17 +51,17 @@ ContextWGL::~ContextWGL()
ReleaseDC();
}
std::unique_ptr<Context> ContextWGL::Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error)
std::unique_ptr<OpenGLContext> OpenGLContextWGL::Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error)
{
std::unique_ptr<ContextWGL> context = std::make_unique<ContextWGL>(wi);
std::unique_ptr<OpenGLContextWGL> context = std::make_unique<OpenGLContextWGL>(wi);
if (!context->Initialize(versions_to_try, error))
return nullptr;
return context;
}
bool ContextWGL::Initialize(std::span<const Version> versions_to_try, Error* error)
bool OpenGLContextWGL::Initialize(std::span<const Version> versions_to_try, Error* error)
{
if (m_wi.type == WindowInfo::Type::Win32)
{
@ -98,12 +97,12 @@ bool ContextWGL::Initialize(std::span<const Version> versions_to_try, Error* err
return false;
}
void* ContextWGL::GetProcAddress(const char* name)
void* OpenGLContextWGL::GetProcAddress(const char* name)
{
return GetProcAddressCallback(name);
}
bool ContextWGL::ChangeSurface(const WindowInfo& new_wi)
bool OpenGLContextWGL::ChangeSurface(const WindowInfo& new_wi)
{
const bool was_current = (wglGetCurrentContext() == m_rc);
Error error;
@ -127,7 +126,7 @@ bool ContextWGL::ChangeSurface(const WindowInfo& new_wi)
return true;
}
void ContextWGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
void OpenGLContextWGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_height /*= 0*/)
{
RECT client_rc = {};
GetClientRect(GetHWND(), &client_rc);
@ -135,17 +134,17 @@ void ContextWGL::ResizeSurface(u32 new_surface_width /*= 0*/, u32 new_surface_he
m_wi.surface_height = static_cast<u32>(client_rc.bottom - client_rc.top);
}
bool ContextWGL::SwapBuffers()
bool OpenGLContextWGL::SwapBuffers()
{
return ::SwapBuffers(m_dc);
}
bool ContextWGL::IsCurrent()
bool OpenGLContextWGL::IsCurrent()
{
return (m_rc && wglGetCurrentContext() == m_rc);
}
bool ContextWGL::MakeCurrent()
bool OpenGLContextWGL::MakeCurrent()
{
if (!wglMakeCurrent(m_dc, m_rc))
{
@ -156,12 +155,12 @@ bool ContextWGL::MakeCurrent()
return true;
}
bool ContextWGL::DoneCurrent()
bool OpenGLContextWGL::DoneCurrent()
{
return wglMakeCurrent(m_dc, nullptr);
}
bool ContextWGL::SetSwapInterval(s32 interval)
bool OpenGLContextWGL::SetSwapInterval(s32 interval)
{
if (!GLAD_WGL_EXT_swap_control)
return false;
@ -169,9 +168,9 @@ bool ContextWGL::SetSwapInterval(s32 interval)
return wglSwapIntervalEXT(interval);
}
std::unique_ptr<Context> ContextWGL::CreateSharedContext(const WindowInfo& wi, Error* error)
std::unique_ptr<OpenGLContext> OpenGLContextWGL::CreateSharedContext(const WindowInfo& wi, Error* error)
{
std::unique_ptr<ContextWGL> context = std::make_unique<ContextWGL>(wi);
std::unique_ptr<OpenGLContextWGL> context = std::make_unique<OpenGLContextWGL>(wi);
if (wi.type == WindowInfo::Type::Win32)
{
if (!context->InitializeDC(error))
@ -198,7 +197,7 @@ std::unique_ptr<Context> ContextWGL::CreateSharedContext(const WindowInfo& wi, E
return context;
}
HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd, Error* error)
HDC OpenGLContextWGL::GetDCAndSetPixelFormat(HWND hwnd, Error* error)
{
PIXELFORMATDESCRIPTOR pfd = {};
pfd.nSize = sizeof(pfd);
@ -242,7 +241,7 @@ HDC ContextWGL::GetDCAndSetPixelFormat(HWND hwnd, Error* error)
return hDC;
}
bool ContextWGL::InitializeDC(Error* error)
bool OpenGLContextWGL::InitializeDC(Error* error)
{
if (m_wi.type == WindowInfo::Type::Win32)
{
@ -263,7 +262,7 @@ bool ContextWGL::InitializeDC(Error* error)
}
}
void ContextWGL::ReleaseDC()
void OpenGLContextWGL::ReleaseDC()
{
if (m_pbuffer)
{
@ -286,7 +285,7 @@ void ContextWGL::ReleaseDC()
}
}
bool ContextWGL::CreatePBuffer(Error* error)
bool OpenGLContextWGL::CreatePBuffer(Error* error)
{
static bool window_class_registered = false;
static const wchar_t* window_class_name = L"ContextWGLPBuffer";
@ -387,7 +386,7 @@ bool ContextWGL::CreatePBuffer(Error* error)
return true;
}
bool ContextWGL::CreateAnyContext(HGLRC share_context, bool make_current, Error* error)
bool OpenGLContextWGL::CreateAnyContext(HGLRC share_context, bool make_current, Error* error)
{
m_rc = wglCreateContext(m_dc);
if (!m_rc)
@ -421,7 +420,8 @@ bool ContextWGL::CreateAnyContext(HGLRC share_context, bool make_current, Error*
return true;
}
bool ContextWGL::CreateVersionContext(const Version& version, HGLRC share_context, bool make_current, Error* error)
bool OpenGLContextWGL::CreateVersionContext(const Version& version, HGLRC share_context, bool make_current,
Error* error)
{
// we need create context attribs
if (!GLAD_WGL_ARB_create_context)
@ -501,4 +501,3 @@ bool ContextWGL::CreateVersionContext(const Version& version, HGLRC share_contex
m_rc = new_rc;
return true;
}
} // namespace GL

19
src/util/gl/context_wgl.h → src/util/opengl_context_wgl.h
View File

@ -2,9 +2,9 @@
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#pragma once
#include "context.h"
#include "../opengl_loader.h"
#include "opengl_context.h"
#include "opengl_loader.h"
#include "common/windows_headers.h"
@ -12,15 +12,14 @@
#include <optional>
namespace GL {
class ContextWGL final : public Context
class OpenGLContextWGL final : public OpenGLContext
{
public:
ContextWGL(const WindowInfo& wi);
~ContextWGL() override;
OpenGLContextWGL(const WindowInfo& wi);
~OpenGLContextWGL() override;
static std::unique_ptr<Context> Create(const WindowInfo& wi, std::span<const Version> versions_to_try, Error* error);
static std::unique_ptr<OpenGLContext> Create(const WindowInfo& wi, std::span<const Version> versions_to_try,
Error* error);
void* GetProcAddress(const char* name) override;
bool ChangeSurface(const WindowInfo& new_wi) override;
@ -30,7 +29,7 @@ public:
bool MakeCurrent() override;
bool DoneCurrent() override;
bool SetSwapInterval(s32 interval) override;
std::unique_ptr<Context> CreateSharedContext(const WindowInfo& wi, Error* error) override;
std::unique_ptr<OpenGLContext> CreateSharedContext(const WindowInfo& wi, Error* error) override;
private:
ALWAYS_INLINE HWND GetHWND() const { return static_cast<HWND>(m_wi.window_handle); }
@ -55,5 +54,3 @@ private:
HDC m_dummy_dc = {};
HPBUFFERARB m_pbuffer = {};
};
} // namespace GL

4
src/util/opengl_device.cpp
View File

@ -316,7 +316,7 @@ bool OpenGLDevice::CreateDevice(const std::string_view& adapter, bool threaded_p
std::optional<bool> exclusive_fullscreen_control, FeatureMask disabled_features,
Error* error)
{
m_gl_context = GL::Context::Create(m_window_info, error);
m_gl_context = OpenGLContext::Create(m_window_info, error);
if (!m_gl_context)
{
Log_ErrorPrintf("Failed to create any GL context");
@ -692,7 +692,7 @@ GPUDevice::AdapterAndModeList OpenGLDevice::GetAdapterAndModeList()
if (m_gl_context)
{
for (const GL::Context::FullscreenModeInfo& fmi : m_gl_context->EnumerateFullscreenModes())
for (const OpenGLContext::FullscreenModeInfo& fmi : m_gl_context->EnumerateFullscreenModes())
{
aml.fullscreen_modes.push_back(GetFullscreenModeString(fmi.width, fmi.height, fmi.refresh_rate));
}

6
src/util/opengl_device.h
View File

@ -1,12 +1,12 @@
// SPDX-FileCopyrightText: 2019-2023 Connor McLaughlin <stenzek@gmail.com>
// SPDX-FileCopyrightText: 2019-2024 Connor McLaughlin <stenzek@gmail.com>
// SPDX-License-Identifier: (GPL-3.0 OR CC-BY-NC-ND-4.0)
#pragma once
#include "gl/context.h"
#include "gpu_device.h"
#include "gpu_framebuffer_manager.h"
#include "gpu_shader_cache.h"
#include "opengl_context.h"
#include "opengl_loader.h"
#include "opengl_pipeline.h"
#include "opengl_texture.h"
@ -168,7 +168,7 @@ private:
void SetVertexBufferOffsets(u32 base_vertex);
std::unique_ptr<GL::Context> m_gl_context;
std::unique_ptr<OpenGLContext> m_gl_context;
std::unique_ptr<OpenGLStreamBuffer> m_vertex_buffer;
std::unique_ptr<OpenGLStreamBuffer> m_index_buffer;

48
src/util/util.vcxproj
View File

@ -19,12 +19,6 @@
<ClInclude Include="d3d12_texture.h" />
<ClInclude Include="d3d_common.h" />
<ClInclude Include="dinput_source.h" />
<ClInclude Include="gl\context.h">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="gl\context_wgl.h">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="gpu_device.h" />
<ClInclude Include="gpu_framebuffer_manager.h" />
<ClInclude Include="gpu_shader_cache.h" />
@ -48,6 +42,24 @@
<ClInclude Include="metal_stream_buffer.h">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="opengl_context.h">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="opengl_context_agl.h">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="opengl_context_egl.h">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="opengl_context_egl_wayland.h">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="opengl_context_egl_x11.h">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="opengl_context_wgl.h">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClInclude>
<ClInclude Include="opengl_device.h">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClInclude>
@ -136,12 +148,6 @@
<ClCompile Include="d3d12_texture.cpp" />
<ClCompile Include="d3d_common.cpp" />
<ClCompile Include="dinput_source.cpp" />
<ClCompile Include="gl\context.cpp">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="gl\context_wgl.cpp">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="gpu_device.cpp" />
<ClCompile Include="gpu_shader_cache.cpp" />
<ClCompile Include="gpu_texture.cpp" />
@ -159,6 +165,21 @@
<ClCompile Include="iso_reader.cpp" />
<ClCompile Include="jit_code_buffer.cpp" />
<ClCompile Include="cd_subchannel_replacement.cpp" />
<ClCompile Include="opengl_context.cpp">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="opengl_context_egl.cpp">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="opengl_context_egl_wayland.cpp">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="opengl_context_egl_x11.cpp">
<ExcludedFromBuild>true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="opengl_context_wgl.cpp">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClCompile>
<ClCompile Include="opengl_device.cpp">
<ExcludedFromBuild Condition="'$(Platform)'=='ARM64'">true</ExcludedFromBuild>
</ClCompile>
@ -260,6 +281,9 @@
<ExcludedFromBuild>true</ExcludedFromBuild>
<FileType>Document</FileType>
</ClCompile>
<None Include="opengl_context_agl.mm">
<ExcludedFromBuild>true</ExcludedFromBuild>
</None>
</ItemGroup>
<PropertyGroup Label="Globals">
<ProjectGuid>{57F6206D-F264-4B07-BAF8-11B9BBE1F455}</ProjectGuid>

24
src/util/util.vcxproj.filters
View File

@ -54,12 +54,6 @@
<ClInclude Include="gpu_shader_cache.h" />
<ClInclude Include="gpu_texture.h" />
<ClInclude Include="metal_device.h" />
<ClInclude Include="gl\context_wgl.h">
<Filter>gl</Filter>
</ClInclude>
<ClInclude Include="gl\context.h">
<Filter>gl</Filter>
</ClInclude>
<ClInclude Include="postprocessing_shader_glsl.h" />
<ClInclude Include="d3d11_pipeline.h" />
<ClInclude Include="d3d11_stream_buffer.h" />
@ -72,6 +66,12 @@
<ClInclude Include="http_downloader.h" />
<ClInclude Include="gpu_framebuffer_manager.h" />
<ClInclude Include="imgui_animated.h" />
<ClInclude Include="opengl_context.h" />
<ClInclude Include="opengl_context_agl.h" />
<ClInclude Include="opengl_context_egl.h" />
<ClInclude Include="opengl_context_egl_wayland.h" />
<ClInclude Include="opengl_context_egl_x11.h" />
<ClInclude Include="opengl_context_wgl.h" />
</ItemGroup>
<ItemGroup>
<ClCompile Include="jit_code_buffer.cpp" />
@ -135,12 +135,6 @@
<ClCompile Include="gpu_device.cpp" />
<ClCompile Include="gpu_shader_cache.cpp" />
<ClCompile Include="gpu_texture.cpp" />
<ClCompile Include="gl\context_wgl.cpp">
<Filter>gl</Filter>
</ClCompile>
<ClCompile Include="gl\context.cpp">
<Filter>gl</Filter>
</ClCompile>
<ClCompile Include="postprocessing_shader_glsl.cpp" />
<ClCompile Include="d3d11_pipeline.cpp" />
<ClCompile Include="d3d11_stream_buffer.cpp" />
@ -154,6 +148,11 @@
<ClCompile Include="metal_device.mm" />
<ClCompile Include="metal_stream_buffer.mm" />
<ClCompile Include="zstd_byte_stream.cpp" />
<ClCompile Include="opengl_context.cpp" />
<ClCompile Include="opengl_context_egl.cpp" />
<ClCompile Include="opengl_context_egl_wayland.cpp" />
<ClCompile Include="opengl_context_egl_x11.cpp" />
<ClCompile Include="opengl_context_wgl.cpp" />
</ItemGroup>
<ItemGroup>
<Filter Include="gl">
@ -162,5 +161,6 @@
</ItemGroup>
<ItemGroup>
<None Include="metal_shaders.metal" />
<None Include="opengl_context_agl.mm" />
</ItemGroup>
</Project>