formatting

Author: mbaetgen-wup

src/libprojectM/Renderer/PlatformGLResolver.cpp

@@ -1,6 +1,3 @@
-// Cross-platform runtime GL/GLES loader using GLAD2 C API (non-MX).
-//
-// Provides a universal resolver to find GL function pointers.
 
 #include "PlatformGLResolver.hpp"
 
@@ -303,8 +300,17 @@ auto GLResolver::Initialize(UserResolver resolver, void* userData) -> bool
 #elif !defined(__APPLE__) && !defined(__ANDROID__)
 
         diag += std::string(" glx_get_proc=\"") + (m_state.m_glxGetProcAddress != nullptr ? "yes" : "no") + "\"";
+
+#if PLATFORM_GLX_ALLOW_CORE_GETPROCADDRESS_FALLBACK
+
+        diag += " glx_policy=\"ext+fallback\"";
+
+#else
+
         diag += " glx_policy=\"ext-only\"";
 
+#endif
+
 #endif
 
         diag += std::string(" user_resolver=\"") + (m_state.m_userResolver != nullptr ? "yes" : "no") + "\"";

src/libprojectM/Renderer/PlatformGLResolver.hpp

@@ -73,7 +73,7 @@ enum class Backend : std::uint8_t
 using UserResolver = void* (*)(const char* name, void* userData);
 
 /**
- * @brief Cross-platform runtime GL/GLES procedure resolver.
+ * @brief Universal cross-platform runtime GL/GLES procedure resolver for GLAD2 (non-MX).
  *
  * Compile-time API selection:
  *  - If USE_GLES is defined, loads OpenGL ES entry points via gladLoadGLES2() and
@@ -84,9 +84,14 @@ using UserResolver = void* (*)(const char* name, void* userData);
  * Supported backends/wrappers: EGL (including ANGLE), GLX (including libGLVND), WGL,
  * macOS CGL, WebGL (Emscripten), plus an optional user resolver.
  *
+ * Lifecycle:
+ *  - The resolver is a process-singleton.
+ *  - GL libraries that have been opened are not unloaded to avoid conflicts with the host app.
+ *    They will be released by OS during process tear-down.
+ *
  * Initialization:
  *  - Must be called after a context is created and made current on the calling thread.
- *  - Thread-safe; intended to be called once during startup before any resolution occurs.
+ *  - Thread-safe; intended to be called during startup before any resolution occurs.
  *  - If multiple backends appear to be current, EGL is preferred.
  *
  * Resolution order (non-Emscripten):
@@ -96,18 +101,13 @@ using UserResolver = void* (*)(const char* name, void* userData);
  *        - Queried for all symbols only when EGL_KHR_get_all_proc_addresses or
  *          EGL_KHR_client_get_all_proc_addresses is advertised.
  *        - Otherwise queried only for extension-style names during the provider step.
- *        - As a last resort (after exports/global lookups fail), a best-effort call
- *          to eglGetProcAddress may be attempted even for non-extension names to support
- *          stacks that expose core client API entry points only via eglGetProcAddress.
  *      - GLX: glXGetProcAddressARB / glXGetProcAddress
- *        - Queried only for glX* or extension-style names (default).
- *        - Optional: as a last resort, non-extension gl* names can be queried when
- *          PLATFORM_GLX_ALLOW_CORE_GETPROCADDRESS_FALLBACK is enabled.
+ *        - Queried only for glX* or extension-style names.
  *      - WGL: wglGetProcAddress
  *        - Filters sentinel values; prefers exported symbols for core OpenGL 1.1 entry points.
  *  3) Global symbol scope lookup (dlsym(RTLD_DEFAULT) / GetProcAddress on already-loaded modules)
  *  4) Direct exports from explicitly opened libraries (EGL/GL/GLX)
- *  5) Fallback
+ *  5) GetProcAddress fallback
  *     - EGL: Try to resolve function via eglGetProcAddress as fallback.
  *            Always enabled.
  *     - GLX: Try to resolve function via glXGetProcAddress as fallback.
@@ -270,6 +270,7 @@ class GLResolver
 private:
 
     // Basic EGL access signatures.
+
     using EglProc = void (PLATFORM_EGLAPIENTRY*)();
     using EglGetProcAddressFn = EglProc (PLATFORM_EGLAPIENTRY*)(const char* name);
     using EglGetCurrentContextFn = void* (PLATFORM_EGLAPIENTRY*)();

src/libprojectM/Renderer/PlatformLoader.hpp

@@ -1,15 +1,18 @@
 #pragma once
 
-#include <array>
-#include <cstddef>
 #include <cstdint>
 #include <cstdio>
 #include <cstring>
 #include <string>
 #include <type_traits>
 
 #ifndef __EMSCRIPTEN__
+
 #ifdef _WIN32
+
+#include <array>
+#include <cstddef>
+
 #include <windows.h>
 
 // -------------------------------------------------------------------------
@@ -48,12 +51,18 @@
 //
 // Define PLATFORM_ALLOW_UNSAFE_DLL_SEARCH=1 to re-enable the legacy fallback.
 #ifndef PLATFORM_ALLOW_UNSAFE_DLL_SEARCH
+
 #define PLATFORM_ALLOW_UNSAFE_DLL_SEARCH 0
+
 #endif
-#else
+
+#else // #ifdef _WIN32
+
 #include <dlfcn.h>
-#endif
-#endif
+
+#endif // #ifdef _WIN32
+
+#endif // #ifndef __EMSCRIPTEN__
 
 // -------------------------------------------------------------------------
 // Minimal EGL calling-convention support
@@ -66,9 +75,13 @@
 // This macro is used in our local EGL function pointer typedefs to ensure we
 // call into the provider (ANGLE / driver EGL) using the correct ABI.
 #if defined(_WIN32) && !defined(_WIN64)
+
 #define PLATFORM_EGLAPIENTRY __stdcall
+
 #else
+
 #define PLATFORM_EGLAPIENTRY
+
 #endif
 
 // -------------------------------------------------------------------------
@@ -123,13 +136,15 @@ inline auto TrimTrailingWhitespace(std::string& str) -> void
 }
 
 #if PLATFORM_LOADER_DIAGNOSTICS
+
 inline auto ReportFnPtrSizeMismatch(const char* where, std::size_t fnSize, std::size_t ptrSize) -> void
 {
     std::fprintf(stderr, "[PlatformLoader] %s: sizeof(Fn)=%zu sizeof(void*)=%zu; cannot convert symbol/function pointer\n",
                  (where != nullptr ? where : "(unknown)"),
                  static_cast<std::size_t>(fnSize),
                  static_cast<std::size_t>(ptrSize));
 }
+
 #endif
 
 /**
@@ -162,9 +177,13 @@ auto SymbolToFunction(void* symbol) -> Fn
 
     if (sizeof(Fn) != sizeof(void*))
     {
+
 #if PLATFORM_LOADER_DIAGNOSTICS
+
         ReportFnPtrSizeMismatch("SymbolToFunction", sizeof(Fn), sizeof(void*));
+
 #endif
+
         return nullptr;
     }
 
@@ -197,9 +216,13 @@ auto FunctionToSymbol(Fn func) -> void*
 
     if (sizeof(Fn) != sizeof(void*))
     {
+
 #if PLATFORM_LOADER_DIAGNOSTICS
+
         ReportFnPtrSizeMismatch("FunctionToSymbol", sizeof(Fn), sizeof(void*));
+
 #endif
+
         return nullptr;
     }
 
@@ -228,9 +251,13 @@ auto FunctionToInteger(Fn func) -> std::uintptr_t
 
     if (sizeof(Fn) != sizeof(void*))
     {
+
 #if PLATFORM_LOADER_DIAGNOSTICS
+
         ReportFnPtrSizeMismatch("FunctionToInteger", sizeof(Fn), sizeof(void*));
+
 #endif
+
         return 0;
     }
 
@@ -269,6 +296,7 @@ inline auto WinProcToSymbol(FARPROC proc) noexcept -> void*
     std::memcpy(&sym, &proc, sizeof(void*));
     return sym;
 }
+
 #endif
 
 #ifdef __EMSCRIPTEN__
@@ -319,12 +347,8 @@ class DynamicLibrary
     }
 };
 
-inline auto IsCurrentEgl(const DynamicLibrary&) -> bool
-{
-    return false;
-}
-
 #else // #ifdef __EMSCRIPTEN__
+
 // -------------------------------------------------------------------------
 // Native implementation (Windows / POSIX)
 // -------------------------------------------------------------------------