remove shutdown, locking fixes

Author: mbaetgen-wup

src/libprojectM/Renderer/PlatformGLResolver.cpp

@@ -13,6 +13,7 @@
 #include <Logging.hpp>
 
 #include <array>
+#include <cstdint>
 #include <cstdio>
 
 #ifdef _WIN32
@@ -30,12 +31,13 @@ namespace Platform {
 
 GLResolver::~GLResolver()
 {
-    SOIL_GL_Destroy();
-
-    // make sure handles are released
-    m_eglLib.Close();
-    m_glLib.Close();
-    m_glxLib.Close();
+    /*
+     * Process-lifetime singleton: destructor runs during process teardown.
+     * Do not call into GL or unload GL driver libraries here:
+     *  - GL context may already be destroyed on this thread.
+     *  - Other threads may still be running.
+     * OS will reclaim mappings on exit.
+     */
 }
 
 auto GLResolver::Instance() -> GLResolver&
@@ -50,6 +52,8 @@ void GLResolver::SetBackendDefault()
     {
 #ifdef __EMSCRIPTEN__
         m_backend = Backend::WebGl;
+#elif defined(__APPLE__)
+        m_backend = Backend::Cgl;
 #elif defined(USE_GLES)
         m_backend = Backend::Egl;
 #elif defined(_WIN32)
@@ -63,7 +67,7 @@ void GLResolver::SetBackendDefault()
 auto GLResolver::Initialize(UserResolver resolver, void* userData) -> bool
 {
     // Avoids holding m_mutex while calling into GLAD (prevents deadlocks),
-    // Prevent concurrent Initialize()/Shutdown(),
+    // Prevent concurrent Initialize()
     std::unique_lock<std::mutex> lock(m_mutex);
 
     if (m_loaded)
@@ -101,17 +105,17 @@ auto GLResolver::Initialize(UserResolver resolver, void* userData) -> bool
 
     lock.lock();
 
-    if (loaded)
+    if (!loaded)
+    {
+        m_loaded = false;
+    }
+    else
     {
         // set default in case detection failed, but loading succeeded
         SetBackendDefault();
 
         lock.unlock();
 
-        // init SOIL2 gl functions
-        SOIL_GL_SetResolver(&GLResolver::GladResolverThunk);
-        SOIL_GL_Init();
-
         GLContextCheck::Builder glCheck;
 #ifdef USE_GLES
         glCheck
@@ -125,16 +129,29 @@ auto GLResolver::Initialize(UserResolver resolver, void* userData) -> bool
             .WithRequireCoreProfile(true);
 #endif
 
+        const auto glDetails = glCheck.Check();
+
         lock.lock();
 
-        auto glDetails = glCheck.Check();
-        LOG_INFO(std::string("[GLResolver] GL Info: ") + GLContextCheck::FormatCompactLine(glDetails.info) + " backend=" + BackendToString(m_backend));
+        LOG_INFO(std::string("[GLResolver] GL Info: ") +
+                 GLContextCheck::FormatCompactLine(glDetails.info) +
+                 " backend=" + BackendToString(m_backend));
         if (!glDetails.success)
         {
             LOG_FATAL(std::string("[GLResolver] GL Check failed: ") + glDetails.reason);
         }
 
-        m_loaded = glDetails.success;
+        lock.unlock();
+
+        const bool ready = glDetails.success;
+        if (ready)
+        {
+            SOIL_GL_SetResolver(&GLResolver::GladResolverThunk);
+            SOIL_GL_Init();
+        }
+
+        lock.lock();
+        m_loaded = ready;
     }
 
     m_initializing = false;
@@ -144,35 +161,6 @@ auto GLResolver::Initialize(UserResolver resolver, void* userData) -> bool
     return m_loaded;
 }
 
-void GLResolver::Shutdown()
-{
-    std::unique_lock<std::mutex> lock(m_mutex);
-
-    while (m_initializing)
-    {
-        m_initCv.wait(lock);
-    }
-
-    SOIL_GL_Destroy();
-
-    m_loaded = false;
-    m_backend = Backend::None;
-
-    m_userResolver = nullptr;
-    m_userData = nullptr;
-
-    m_eglGetProcAddress = nullptr;
-#ifndef _WIN32
-    m_glxGetProcAddress = nullptr;
-#else
-    m_wglGetProcAddress = nullptr;
-#endif
-
-    m_eglLib.Close();
-    m_glLib.Close();
-    m_glxLib.Close();
-}
-
 auto GLResolver::IsLoaded() const -> bool
 {
     const std::lock_guard<std::mutex> lock(m_mutex);
@@ -370,14 +358,17 @@ void GLResolver::ResolveProviderFunctions()
     }
 #endif
 
-    {
-        std::array<char, 256> buf{};
-        std::snprintf(buf.data(), buf.size(), "[GLResolver] Library handles: egl=%p gl=%p glx=%p",
-            reinterpret_cast<void*>(m_eglLib.Handle()),
-            reinterpret_cast<void*>(m_glLib.Handle()),
-            reinterpret_cast<void*>(m_glxLib.Handle()));
-        LOG_DEBUG(std::string(buf.data()));
-    }
+    LOG_DEBUG(std::string("[GLResolver] EGL  handle=") +
+              std::to_string(reinterpret_cast<std::uintptr_t>(m_eglLib.Handle())) +
+              " lib=\"" + m_eglLib.LoadedName() + "\"");
+
+    LOG_DEBUG(std::string("[GLResolver] GL   handle=") +
+              std::to_string(reinterpret_cast<std::uintptr_t>(m_glLib.Handle())) +
+              " lib=\"" + m_glLib.LoadedName() + "\"");
+
+    LOG_DEBUG(std::string("[GLResolver] GLX  handle=") +
+              std::to_string(reinterpret_cast<std::uintptr_t>(m_glxLib.Handle())) +
+              " lib=\"" + m_glxLib.LoadedName() + "\"");
 
 }
 
@@ -514,10 +505,11 @@ auto GLResolver::ResolveUnlocked(const char* name,
     // 2) Platform provider getProcAddress (prefer for correctness, extensions, GLVND dispatch)
     if ((backend == Backend::Egl || backend == Backend::None) && eglGetProcAddressFn != nullptr)
     {
-        void* ptr = eglGetProcAddressFn(name);
-        if (ptr != nullptr)
+        // eglGetProcAddress returns a function pointer type; convert only at the boundary.
+        EglProc proc = eglGetProcAddressFn(name);
+        if (proc != nullptr)
         {
-            return ptr;
+            return reinterpret_cast<void*>(proc);
         }
     }
 

src/libprojectM/Renderer/PlatformGLResolver.hpp

@@ -42,7 +42,13 @@ enum class Backend : std::uint8_t
     /**
      * WegGl proc resolver (Emscripten only).
      */
-    WebGl = 4
+    WebGl = 4,
+
+    /**
+     * MacOS native CGL.
+     * Note: CGL will be reported as None until it is assigned in the default fallback.
+     */
+    Cgl = 5
 };
 
 /**
@@ -57,19 +63,30 @@ using UserResolver = void* (*)(const char* name, void* userData);
  * @brief Cross-platform runtime GL/GLES resolver.
  *
  * This resolver:
- *  - Supports: EGL, GLES, GLX, WGL, WebGL or a user supplied resolver.
- *  - Platforms: Android, Emscripten, Linux, Mac, Windows.
- *  - Must be initialized after a GL/GLES context has been created and made current.
- *  - Probes for EGL/GLX/WGL by checking for a current context.
- *  - Uses GLAD2 non-MX entrypoints (gladLoadGL / gladLoadGLES2) via a universal resolver.
- *  - Resolves symbols using the following order (GL/GLES):
- *      1) User resolver callback (if any)
- *      2) Platform provider eglGetProcAddress / glXGetProcAddress* / wglGetProcAddress (when available)
+ *  - Supports backends: CGL (macOS native), EGL (incl. GLES), GLX, WGL, WebGL, libGLVND, ANGLE, or a user supplied resolver.
+ *  - Supports platforms: Android, Emscripten, Linux, macOS, Windows.
+ *  - Must be initialized after a GL/GLES context has been created and made current on the calling thread.
+ *  - Detects the active backend by probing for a current context:
+ *      - EGL via eglGetCurrentContext
+ *      - GLX via glXGetCurrentContext*
+ *      - WGL via wglGetCurrentContext
+ *      - macOS native falls back to CGL/NSOpenGL (no provider GetProcAddress)
+ *  - Uses GLAD2 non-MX entrypoints (gladLoadGL / gladLoadGLES2) with a single universal resolver.
+ *  - Supports libGLVND dispatch on Linux (libOpenGL.so + libGLX.so).
+ *  - Supports ANGLE when libEGL/libGLESv2 are present.
+ *
+ *  - Resolves symbols in the following order (native GL / GLES):
+ *      1) User resolver callback (if provided)
+ *      2) Platform provider:
+ *           - eglGetProcAddress (EGL / ANGLE)
+ *           - glXGetProcAddress / glXGetProcAddressARB (GLX / GLVND)
+ *           - wglGetProcAddress (WGL)
  *      3) Global symbol table (RTLD_DEFAULT / main module)
- *      4) Symbols from opened libEGL / libGL / opengl32
- *  - Resolves symbols using the following order (Emscripten):
- *      1) User resolver callback (if any)
- *      2) emscripten_webgl_get_proc_address()
+ *      4) Symbols from explicitly opened libraries (libEGL, libGL, OpenGL.framework, opengl32)
+ *
+ *  - Resolves symbols in the following order (Emscripten):
+ *      1) User resolver callback (if provided)
+ *      2) emscripten_webgl_get_proc_address / emscripten_webgl2_get_proc_address
  */
 class GLResolver
 {
@@ -103,11 +120,6 @@ class GLResolver
      */
     auto Initialize(UserResolver resolver = nullptr, void* userData = nullptr) -> bool;
 
-    /**
-     * @brief Shuts down the resolver and releases library handles.
-     */
-    void Shutdown();
-
     /**
      * @brief Returns true if the resolver was successfully initialized.
      */
@@ -141,12 +153,12 @@ class GLResolver
     void SetBackendDefault();
     auto LoadGlad() -> bool;
 
-    /* Provider function types (kept private to avoid header pollution elsewhere). */
-    using EglGetProcAddressFn = void* (*)(const char*);
+    using EglProc = void (*)();
+    using EglGetProcAddressFn = EglProc (*)(const char* name);
 
 #ifndef _WIN32
     /* glXGetProcAddress/glXGetProcAddressARB return a function pointer. */
-    using GlxGetProcAddressFn = void (*(*)(const unsigned char*))(void);
+    using GlxGetProcAddressFn = void (*(*)(const unsigned char*))();
 #else
     using WglGetProcAddressFn = PROC (WINAPI*)(LPCSTR);
 #endif
@@ -214,6 +226,10 @@ inline auto BackendToString(Backend backend) -> const char*
         {
             return "WebGL";
         }
+        case Backend::Cgl:
+        {
+            return "CGL";
+        }
         default:
         {
             return "Unknown";