naming fixes

Author: mbaetgen-wup

src/libprojectM/ProjectMCWrapper.cpp

@@ -6,9 +6,9 @@
 
 #include <Audio/AudioConstants.hpp>
 
-#include <Renderer/CrossGlLoader.hpp>
-#include <SOIL2/SOIL2_gl_bridge.h>
+#include <Renderer/PlatformGLResolver.hpp>
 #include <SOIL2/SOIL2.h>
+#include <SOIL2/SOIL2_gl_bridge.h>
 
 #include <projectM-4/parameters.h>
 #include <projectM-4/render_opengl.h>
@@ -79,15 +79,15 @@ projectm_handle projectm_create_with_opengl_load_proc(void* (*load_proc)(const c
 {
     try
     {
-        // invoke loader to discover gl function pointer and init glad
-        auto success = libprojectM::Renderer::CrossGlLoader::Instance().Initialize(load_proc, user_data);
+        // invoke loader to discover gl function pointers and init glad
+        auto success = libprojectM::Renderer::Platform::GLResolver::Instance().Initialize(load_proc, user_data);
         if (!success)
         {
             return nullptr;
         }
 
         // init SOIL2 gl functions
-        SOIL_GL_SetResolver(&libprojectM::Renderer::CrossGlLoader::GladResolverThunk);
+        SOIL_GL_SetResolver(&libprojectM::Renderer::Platform::GLResolver::GladResolverThunk);
         SOIL_GL_Init();
 
         // create projectM
@@ -104,7 +104,7 @@ void projectm_destroy(projectm_handle instance)
 {
     auto projectMInstance = handle_to_instance(instance);
     delete projectMInstance;
-    libprojectM::Renderer::CrossGlLoader::Instance().Shutdown();
+    libprojectM::Renderer::Platform::GLResolver::Instance().Shutdown();
 }
 
 void projectm_load_preset_file(projectm_handle instance, const char* filename,

src/libprojectM/Renderer/CMakeLists.txt

@@ -22,8 +22,6 @@ add_library(Renderer OBJECT
         Color.hpp
         CopyTexture.cpp
         CopyTexture.hpp
-        CrossGlLoader.cpp
-        CrossGlLoader.hpp
         FileScanner.cpp
         FileScanner.hpp
         Framebuffer.cpp
@@ -34,6 +32,8 @@ add_library(Renderer OBJECT
         MilkdropNoise.cpp
         MilkdropNoise.hpp
         OpenGL.h
+        PlatformGLResolver.cpp
+        PlatformGLResolver.hpp
         PlatformLoader.h
         Point.hpp
         PresetTransition.cpp

…c/libprojectM/Renderer/CrossGlLoader.cpp …projectM/Renderer/PlatformGLResolver.cppsrc/libprojectM/Renderer/CrossGlLoader.cpp renamed to src/libprojectM/Renderer/PlatformGLResolver.cpp src/libprojectM/Renderer/CrossGlLoader.cpp renamed to src/libprojectM/Renderer/PlatformGLResolver.cpp

@@ -2,24 +2,27 @@
 //
 // Provides a universal resolver to find GL function pointers.
 
-#include "CrossGlLoader.hpp"
+#include "PlatformGLResolver.hpp"
 
-#include <Logging.hpp>
 #include "OpenGL.h"
+#include <Logging.hpp>
 
 #include <array>
 #include <cstdio>
 
 namespace libprojectM {
+
 namespace Renderer {
 
-auto CrossGlLoader::Instance() -> CrossGlLoader&
+namespace Platform {
+
+auto GLResolver::Instance() -> GLResolver&
 {
-    static CrossGlLoader instance;
+    static GLResolver instance;
     return instance;
 }
 
-auto CrossGlLoader::Initialize(UserResolver resolver, void* userData) -> bool
+auto GLResolver::Initialize(UserResolver resolver, void* userData) -> bool
 {
     const std::lock_guard<std::mutex> lock(m_mutex);
 
@@ -35,7 +38,7 @@ auto CrossGlLoader::Initialize(UserResolver resolver, void* userData) -> bool
     ResolveProviderFunctions();
     DetectBackend();
 
-    if (LoadViaGlad())
+    if (LoadGlad())
     {
         // If detection failed, but loading succeeded
         // fall back to a sensible default
@@ -55,7 +58,7 @@ auto CrossGlLoader::Initialize(UserResolver resolver, void* userData) -> bool
     return false;
 }
 
-void CrossGlLoader::Shutdown()
+void GLResolver::Shutdown()
 {
     const std::lock_guard<std::mutex> lock(m_mutex);
 
@@ -73,26 +76,26 @@ void CrossGlLoader::Shutdown()
     m_glLib.Close();
 }
 
-auto CrossGlLoader::IsLoaded() const -> bool
+auto GLResolver::IsLoaded() const -> bool
 {
     const std::lock_guard<std::mutex> lock(m_mutex);
     return m_loaded;
 }
 
-auto CrossGlLoader::CurrentBackend() const -> Backend
+auto GLResolver::CurrentBackend() const -> Backend
 {
     const std::lock_guard<std::mutex> lock(m_mutex);
     return m_backend;
 }
 
-auto CrossGlLoader::GetProcAddress(const char* name) const -> GLapiproc
+auto GLResolver::GetProcAddress(const char* name) const -> GLapiproc
 {
     // NOTE: This method is used during GLAD loading. Avoid taking the mutex here to
     // prevent deadlocks if GLAD calls back into us while Initialize() is holding the lock
     return Resolve(name);
 }
 
-void CrossGlLoader::OpenNativeLibraries()
+void GLResolver::OpenNativeLibraries()
 {
     // Best-effort: macOS or minimal EGL setups may fail to open
 
@@ -111,15 +114,15 @@ void CrossGlLoader::OpenNativeLibraries()
     m_glLib.Open(kGlNames.data());
 }
 
-void CrossGlLoader::ResolveProviderFunctions()
+void GLResolver::ResolveProviderFunctions()
 {
     // EGL
     if (m_eglLib.IsOpen())
     {
         void* sym = m_eglLib.GetSymbol("eglGetProcAddress");
         if (sym == nullptr)
         {
-            sym = Platform::DynamicLibrary::FindGlobalSymbol("eglGetProcAddress");
+            sym = DynamicLibrary::FindGlobalSymbol("eglGetProcAddress");
         }
         m_eglGetProcAddress = reinterpret_cast<GetProcFunc>(sym);
     }
@@ -131,7 +134,7 @@ void CrossGlLoader::ResolveProviderFunctions()
         void* sym = m_glLib.GetSymbol("wglGetProcAddress");
         if (!sym)
         {
-            sym = Platform::DynamicLibrary::FindGlobalSymbol("wglGetProcAddress");
+            sym = DynamicLibrary::FindGlobalSymbol("wglGetProcAddress");
         }
         m_wglGetProcAddress = reinterpret_cast<GetProcFunc>(sym);
 #else
@@ -142,23 +145,23 @@ void CrossGlLoader::ResolveProviderFunctions()
         }
         if (sym == nullptr)
         {
-            sym = Platform::DynamicLibrary::FindGlobalSymbol("glXGetProcAddress");
+            sym = DynamicLibrary::FindGlobalSymbol("glXGetProcAddress");
         }
         m_glxGetProcAddress = reinterpret_cast<GetProcFunc>(sym);
 #endif
     }
 
-    [&] {
+     {
         char buf[256];
-        std::snprintf(buf, sizeof(buf), "CrossGlLoader: egl=%p gl=%p",
+        std::snprintf(buf, sizeof(buf), "[PlatformGLResolver] Library handles: egl=%p gl=%p",
             reinterpret_cast<void*>(m_eglLib.Handle()),
             reinterpret_cast<void*>(m_glLib.Handle()));
         LOG_DEBUG(buf);
-    }();
+    }
 
 }
 
-void CrossGlLoader::DetectBackend()
+void GLResolver::DetectBackend()
 {
     // Detect current context provider
     // This is best-effort: on some platforms (e.g. macOS/CGL) it may report "unknown"
@@ -168,37 +171,37 @@ void CrossGlLoader::DetectBackend()
 #ifndef _WIN32
     const bool usingGlx = m_glLib.IsOpen() && IsCurrentGlx(m_glLib);
 #else
-    const bool usingWgl = Platform::IsCurrentWgl();
+    const bool usingWgl = IsCurrentWgl();
 #endif
 
     if (usingEgl)
     {
-        LOG_DEBUG("CrossGlLoader: current context: EGL");
+        LOG_DEBUG("[PlatformGLResolver] current context: EGL");
         m_backend = Backend::EglGles;
         return;
     }
 
 #ifndef _WIN32
     if (usingGlx)
     {
-        LOG_DEBUG("CrossGlLoader: current context: GLX");
+        LOG_DEBUG("[PlatformGLResolver] current context: GLX");
         m_backend = Backend::GlxGl;
         return;
     }
 #else
     if (usingWgl)
     {
-        LOG_DEBUG("CrossGlLoader: current context: WGL");
+        LOG_DEBUG("[PlatformGLResolver] current context: WGL");
         m_backend = Backend::WglGl;
         return;
     }
 #endif
 
-    LOG_DEBUG("CrossGlLoader: current context: (unknown, will try generic loader)");
+    LOG_DEBUG("[PlatformGLResolver] current context: (unknown, will try generic loader)");
     m_backend = Backend::None;
 }
 
-auto CrossGlLoader::GladResolverThunk(const char* name) -> GLapiproc
+auto GLResolver::GladResolverThunk(const char* name) -> GLapiproc
 {
     return Instance().Resolve(name);
 }
@@ -207,36 +210,36 @@ namespace {
 // adapt external void* handle to GLAD type
 auto gladBridgeResolverThunk(const char* name) -> GLADapiproc
 {
-    return reinterpret_cast<GLADapiproc>(CrossGlLoader::GladResolverThunk(name));
+    return reinterpret_cast<GLADapiproc>(GLResolver::GladResolverThunk(name));
 }
 }
 
-auto CrossGlLoader::LoadViaGlad() -> bool
+auto GLResolver::LoadGlad() -> bool
 {
     int result = 0;
 
 #ifndef USE_GLES
     result = gladLoadGL(&gladBridgeResolverThunk);
     if (result != 0)
     {
-        LOG_DEBUG("CrossGlLoader: gladLoadGL() succeeded");
+        LOG_DEBUG("[PlatformGLResolver] gladLoadGL() succeeded");
         return true;
     }
-    LOG_DEBUG("CrossGlLoader: gladLoadGL() failed");
+    LOG_FATAL("[PlatformGLResolver] gladLoadGL() failed");
     return false;
 #else
     result = gladLoadGLES2(&gladBridgeResolverThunk);
     if (result != 0)
     {
-        LOG_DEBUG("CrossGlLoader: gladLoadGLES2() succeeded");
+        LOG_DEBUG("[PlatformGLResolver] gladLoadGLES2() succeeded");
         return true;
     }
-    LOG_DEBUG("CrossGlLoader: gladLoadGLES2() failed");
+    LOG_FATAL("[PlatformGLResolver] gladLoadGLES2() failed");
     return false;
 #endif
 }
 
-auto CrossGlLoader::Resolve(const char* name) const -> GLapiproc
+auto GLResolver::Resolve(const char* name) const -> GLapiproc
 {
     if (name == nullptr)
     {
@@ -253,7 +256,7 @@ auto CrossGlLoader::Resolve(const char* name) const -> GLapiproc
     }
 
     // 2) Global symbol table
-    if (void* ptr = Platform::DynamicLibrary::FindGlobalSymbol(name))
+    if (void* ptr = DynamicLibrary::FindGlobalSymbol(name))
     {
         return ptr;
     }
@@ -300,5 +303,6 @@ auto CrossGlLoader::Resolve(const char* name) const -> GLapiproc
     return nullptr;
 }
 
+} // namespace Platform
 } // namespace Renderer
 } // namespace libprojectM