cleanup

Author: mbaetgen-wup

src/libprojectM/ProjectMCWrapper.cpp

@@ -5,10 +5,7 @@
 #include <Logging.hpp>
 
 #include <Audio/AudioConstants.hpp>
-
 #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>
@@ -88,7 +85,7 @@ projectm_handle projectm_create_with_opengl_load_proc(void* (*load_proc)(const c
         auto glResolver = libprojectM::Renderer::Platform::GLResolver::Instance();
 
         // init resolver to discover gl function pointers and init glad
-        // init is guarded internally, so it actually only happens once
+        // Initialize() is guarded internally, may be executed multiple times
         auto success = glResolver->Initialize(load_proc, user_data);
         if (!success)
         {

src/libprojectM/Renderer/PlatformGLResolver.cpp

@@ -21,7 +21,9 @@ namespace Platform {
 
 GLResolver::~GLResolver()
 {
-    Shutdown();
+    // make sure handles are released
+    m_eglLib.Close();
+    m_glLib.Close();
 }
 
 auto GLResolver::Instance() -> std::shared_ptr<GLResolver>
@@ -62,18 +64,23 @@ auto GLResolver::Initialize(UserResolver resolver, void* userData) -> bool
 
     if (m_userResolver == nullptr)
     {
+        // need to find source for gl functions
+        // open libs and detect backend
         OpenNativeLibraries();
         ResolveProviderFunctions();
         DetectBackend();
     }
     else
     {
+        // user resolver was provided
+        // we *should* be able to get all gl functions from the resolver
+        // using user resolver + global symbol fallback
         m_backend = Backend::UserResolver;
     }
 
     if (LoadGlad())
     {
-        // set default if detection failed, but loading succeeded
+        // set default in case detection failed, but loading succeeded
         SetBackendDefault();
 
         // init SOIL2 gl functions
@@ -181,7 +188,7 @@ void GLResolver::ResolveProviderFunctions()
 
     {
         char buf[256];
-        std::snprintf(buf, sizeof(buf), "[PlatformGLResolver] Library handles: egl=%p gl=%p",
+        std::snprintf(buf, sizeof(buf), "[GLResolver] Library handles: egl=%p gl=%p",
             reinterpret_cast<void*>(m_eglLib.Handle()),
             reinterpret_cast<void*>(m_glLib.Handle()));
         LOG_DEBUG(buf);
@@ -204,28 +211,28 @@ void GLResolver::DetectBackend()
 
     if (usingEgl)
     {
-        LOG_DEBUG("[PlatformGLResolver] current context: EGL");
+        LOG_DEBUG("[GLResolver] current context: EGL");
         m_backend = Backend::EglGles;
         return;
     }
 
 #ifndef _WIN32
     if (usingGlx)
     {
-        LOG_DEBUG("[PlatformGLResolver] current context: GLX");
+        LOG_DEBUG("[GLResolver] current context: GLX");
         m_backend = Backend::GlxGl;
         return;
     }
 #else
     if (usingWgl)
     {
-        LOG_DEBUG("[PlatformGLResolver] current context: WGL");
+        LOG_DEBUG("[GLResolver] current context: WGL");
         m_backend = Backend::WglGl;
         return;
     }
 #endif
 
-    LOG_DEBUG("[PlatformGLResolver] current context: (unknown, will try generic loader)");
+    LOG_DEBUG("[GLResolver] current context: (unknown, will try generic loader)");
     m_backend = Backend::None;
 }
 
@@ -235,11 +242,20 @@ auto GLResolver::GladResolverThunk(const char* name) -> GLapiproc
 }
 
 namespace {
-// adapt external void* handle to GLAD type
+
+/**
+ * Resolves a GL function by name using GladResolverThunk.
+ * Adapt external void* handle to GLAD type
+ *
+ * @param name GL function name.
+ *
+ * @return Function pointer as GLADapiproc.
+ */
 auto gladBridgeResolverThunk(const char* name) -> GLADapiproc
 {
     return reinterpret_cast<GLADapiproc>(GLResolver::GladResolverThunk(name));
 }
+
 }
 
 auto GLResolver::LoadGlad() -> bool
@@ -250,19 +266,19 @@ auto GLResolver::LoadGlad() -> bool
     result = gladLoadGL(&gladBridgeResolverThunk);
     if (result != 0)
     {
-        LOG_DEBUG("[PlatformGLResolver] gladLoadGL() succeeded");
+        LOG_DEBUG("[GLResolver] gladLoadGL() succeeded");
         return true;
     }
-    LOG_FATAL("[PlatformGLResolver] gladLoadGL() failed");
+    LOG_FATAL("[GLResolver] gladLoadGL() failed");
     return false;
 #else
     result = gladLoadGLES2(&gladBridgeResolverThunk);
     if (result != 0)
     {
-        LOG_DEBUG("[PlatformGLResolver] gladLoadGLES2() succeeded");
+        LOG_DEBUG("[GLResolver] gladLoadGLES2() succeeded");
         return true;
     }
-    LOG_FATAL("[PlatformGLResolver] gladLoadGLES2() failed");
+    LOG_FATAL("[GLResolver] gladLoadGLES2() failed");
     return false;
 #endif
 }

src/libprojectM/Renderer/PlatformGLResolver.hpp

@@ -138,20 +138,19 @@ class GLResolver
     auto LoadGlad() -> bool;
     auto Resolve(const char* name) const -> GLapiproc;
 
-    mutable std::mutex m_mutex;
+    mutable std::mutex m_mutex;                   //!< Mutex to synchronize initialization and access.
+    bool m_loaded{false};                         //!< True if the resolver is initialized.
+    Backend m_backend{ Backend::None };           //!< Detected GL backend.
 
-    bool m_loaded{};
-    Backend m_backend{ Backend::None };
+    UserResolver m_userResolver{nullptr};         //!< User provided function resolver.
+    void* m_userData{nullptr};                    //!< User data to pass to user provided function resolver.
 
-    UserResolver m_userResolver{};
-    void* m_userData{};
+    DynamicLibrary m_eglLib;                      //!< EGL library handle. Optional, may not be assigned.
+    DynamicLibrary m_glLib;                       //!< Detected GL backend. Optional, may not be assigned.
 
-    Platform::DynamicLibrary m_eglLib;
-    Platform::DynamicLibrary m_glLib;
-
-    GetProcFunc m_eglGetProcAddress{};
-    GetProcFunc m_glxGetProcAddress{};
-    GetProcFunc m_wglGetProcAddress{};
+    GetProcFunc m_eglGetProcAddress{nullptr};     //!< Function pointer to EGL proc resolver function.
+    GetProcFunc m_glxGetProcAddress{nullptr};     //!< Function pointer to GLX proc resolver function.
+    GetProcFunc m_wglGetProcAddress{nullptr};     //!< Function pointer to WGL proc resolver function.
 };
 
 } // namespace Platform

src/libprojectM/Renderer/PlatformLoader.h

@@ -197,7 +197,7 @@ class DynamicLibrary
     }
 
 private:
-    LibHandle m_handle{};
+    LibHandle m_handle{};          //!< Library handle used to access the system library.
 };
 
 /**

vendor/SOIL2/CMakeLists.txt

@@ -2,11 +2,30 @@ add_library(SOIL2 OBJECT
         ${CMAKE_CURRENT_SOURCE_DIR}/src/common/common.cpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/common/common.hpp
         ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/image_DXT.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/image_DXT.h
         ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/image_helper.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/image_helper.h
         ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/pkm_helper.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/pvr_helper.h
         ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/SOIL2.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/SOIL2.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stb_image.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stb_image_write.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_DDS.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_DDS_c.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_ext.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_ext_c.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_pkm.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_pkm_c.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_pvr.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_pvr_c.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_qoi.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_qoi_c.h
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/stbi_qoi_write.h
         ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/wfETC.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/wfETC.h
         ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/SOIL2_gl_bridge.c
+        ${CMAKE_CURRENT_SOURCE_DIR}/src/SOIL2/SOIL2_gl_bridge.h
         )
 
 target_include_directories(SOIL2
@@ -37,31 +56,18 @@ else()
             )
 endif()
 
-# GLES / EGL settings
 if (USE_GLES)
     target_compile_definitions(SOIL2
-            PRIVATE
+            PUBLIC
             SOIL_GLES2
             )
-
     target_link_libraries(SOIL2
             PUBLIC
             ${CMAKE_DL_LIBS}
             )
-else()
-    target_compile_definitions(SOIL2
-            PRIVATE
-            SOIL_NO_EGL
-            )
 endif()
 
-if (EMSCRIPTEN)
-    target_compile_definitions(SOIL2
-            PRIVATE
-            SOIL_GLES2
-            SOIL_NO_EGL
-            )
-elseif (NOT TARGET OpenGL::EGL)
+if(NOT TARGET OpenGL::EGL)
     target_compile_definitions(SOIL2
             PRIVATE
             SOIL_NO_EGL

vendor/SOIL2/src/SOIL2/SOIL2_gl_bridge.h

@@ -16,7 +16,7 @@ extern "C" {
      */
     typedef void* (*soil_gl_resolver_t)(const char* name);
 
-/**
+    /**
      * Sets the GL function resolver for SOIL2.
      *
      * @param resolver The resolver function to use.
@@ -29,7 +29,7 @@ extern "C" {
      * @param proc GL Function name.
      * @return Resolved function pointer for the given function name, or 0 if the function could not be resolved.
      */
-void* SOIL_GL_GetProcAddress(const char* proc);
+     void* SOIL_GL_GetProcAddress(const char* proc);
 
 #ifdef __cplusplus
 }