Add a global shader cache

Author: kblaschke

src/libprojectM/ProjectM.cpp

@@ -30,6 +30,7 @@
 #include <Renderer/CopyTexture.hpp>
 #include <Renderer/PresetTransition.hpp>
 #include <Renderer/TextureManager.hpp>
+#include <Renderer/ShaderCache.hpp>
 #include <Renderer/TransitionShaderManager.hpp>
 
 namespace libprojectM {
@@ -194,6 +195,7 @@ void ProjectM::Initialize()
     /** Initialise per-pixel matrix calculations */
     /** We need to initialise this before the builtin param db otherwise bass/mid etc won't bind correctly */
     m_textureManager = std::make_unique<Renderer::TextureManager>(m_textureSearchPaths);
+    m_shaderCache = std::make_unique<Renderer::ShaderCache>();
 
     m_transitionShaderManager = std::make_unique<Renderer::TransitionShaderManager>();
 
@@ -452,6 +454,7 @@ auto ProjectM::GetRenderContext() -> Renderer::RenderContext
     ctx.perPixelMeshX = static_cast<int>(m_meshX);
     ctx.perPixelMeshY = static_cast<int>(m_meshY);
     ctx.textureManager = m_textureManager.get();
+    ctx.shaderCache = m_shaderCache.get();
 
     return ctx;
 }

src/libprojectM/ProjectM.hpp

@@ -37,6 +37,7 @@ class CopyTexture;
 class PresetTransition;
 class Renderer;
 class TextureManager;
+class ShaderCache;
 class TransitionShaderManager;
 } // namespace Renderer
 
@@ -200,11 +201,11 @@ class PROJECTM_EXPORT ProjectM
 
     auto GetRenderContext() -> Renderer::RenderContext;
 
-    uint32_t m_meshX{32};              //!< Per-point mesh horizontal resolution.
-    uint32_t m_meshY{24};              //!< Per-point mesh vertical resolution.
-    uint32_t m_targetFps{35};          //!< Target frames per second.
-    uint32_t m_windowWidth{0};            //!< EvaluateFrameData window width. If 0, nothing is rendered.
-    uint32_t m_windowHeight{0};           //!< EvaluateFrameData window height. If 0, nothing is rendered.
+    uint32_t m_meshX{32};            //!< Per-point mesh horizontal resolution.
+    uint32_t m_meshY{24};            //!< Per-point mesh vertical resolution.
+    uint32_t m_targetFps{35};        //!< Target frames per second.
+    uint32_t m_windowWidth{0};       //!< EvaluateFrameData window width. If 0, nothing is rendered.
+    uint32_t m_windowHeight{0};      //!< EvaluateFrameData window height. If 0, nothing is rendered.
     double m_presetDuration{30.0};   //!< Preset duration in seconds.
     double m_softCutDuration{3.0};   //!< Soft cut transition time.
     double m_hardCutDuration{20.0};  //!< Time after which a hard cut can happen at the earliest.
@@ -227,6 +228,7 @@ class PROJECTM_EXPORT ProjectM
 
     Audio::PCM m_audioStorage;                                                    //!< Audio data buffer and analyzer instance.
     std::unique_ptr<Renderer::TextureManager> m_textureManager;                   //!< The texture manager.
+    std::unique_ptr<Renderer::ShaderCache> m_shaderCache;                         //!< The global shader cache.
     std::unique_ptr<Renderer::TransitionShaderManager> m_transitionShaderManager; //!< The transition shader manager.
     std::unique_ptr<Renderer::CopyTexture> m_textureCopier;                       //!< Class that copies textures 1:1 to another texture or framebuffer.
     std::unique_ptr<Preset> m_activePreset;                                       //!< Currently loaded preset.

src/libprojectM/Renderer/CMakeLists.txt

@@ -49,6 +49,8 @@ add_library(Renderer OBJECT
         Sampler.hpp
         Shader.cpp
         Shader.hpp
+        ShaderCache.cpp
+        ShaderCache.hpp
         Texture.cpp
         Texture.hpp
         TextureAttachment.cpp

src/libprojectM/Renderer/RenderContext.hpp

@@ -7,6 +7,7 @@
 namespace libprojectM {
 namespace Renderer {
 
+class ShaderCache;
 class TextureManager;
 
 /**
@@ -30,6 +31,7 @@ class RenderContext
     int perPixelMeshY{48}; //!< Per-pixel/per-vertex mesh Y resolution.
 
     TextureManager* textureManager{nullptr}; //!< Holds all loaded textures for shader access.
+    ShaderCache* shaderCache{nullptr}; //!< The shader chace of this projectM instance.
 };
 
 } // namespace Renderer

src/libprojectM/Renderer/ShaderCache.cpp

@@ -0,0 +1,34 @@
+#include "ShaderCache.hpp"
+
+#include <utility>
+
+namespace libprojectM {
+namespace Renderer {
+
+void ShaderCache::Insert(const std::string& key, const std::shared_ptr<Shader>& shader)
+{
+    m_cachedShaders.emplace(key, shader);
+}
+
+void ShaderCache::Insert(const std::string& key, std::shared_ptr<Shader>&& shader)
+{
+    m_cachedShaders.emplace(key, std::move(shader));
+}
+
+void ShaderCache::Remove(const std::string& key)
+{
+    m_cachedShaders.erase(key);
+}
+
+auto ShaderCache::Get(const std::string& key) const -> std::shared_ptr<Shader>
+{
+    if (m_cachedShaders.find(key) != m_cachedShaders.end())
+    {
+        return m_cachedShaders.at(key);
+    }
+
+    return {};
+}
+
+} // namespace Renderer
+} // namespace libprojectM

src/libprojectM/Renderer/ShaderCache.hpp

@@ -0,0 +1,62 @@
+#pragma once
+
+#include "Renderer/Shader.hpp"
+
+#include <map>
+#include <memory>
+#include <string>
+
+namespace libprojectM {
+namespace Renderer {
+
+/**
+ * @brief Instance shader cache.
+ *
+ * Used to store shaders which only need to be compiled once per projectM instance.
+ * Removes the need for the previously used static shader provider, and reduces
+ * shader recompilation times.
+ *
+ * Shaders are accessed by arbitrary strings as keys.
+ *
+ * All cached shader programs will be properly deleted when the projectM instance is destroyed.
+ * Classes storing a reference to a cached shader should ideally use an std::weak_ptr to do so.
+ */
+class ShaderCache
+{
+public:
+    /**
+     * @brief Adds a new shader to the cache.
+     * If the shader already exists, the existing cache entry it NOT replaced.
+     * @param key The key to store the shader with.
+     * @param shader A shared pointer to the shader program to be cached.
+     */
+    void Insert(const std::string& key, const std::shared_ptr<Shader>& shader);
+
+    /**
+     * @brief Adds a new shader to the cache.
+     * If the shader already exists, the existing cache entry it NOT replaced.
+     * @param key The key to store the shader with.
+     * @param shader A shared pointer to the shader program to be cached.
+     */
+    void Insert(const std::string& key, std::shared_ptr<Shader>&& shader);
+
+    /**
+     * @brief Removes a shader from the cache.
+     * If the key does not exist in the cache, this function will not do anything.
+     * @param key The key of the sahder to be removed.
+     */
+    void Remove(const std::string& key);
+
+    /**
+     * @brief Returns a cached shader.
+     * @param key the key of the cached shader to be returned.
+     * @return A shared pointer to the cached shader program, or nullptr if the key wasn't found.
+     */
+    auto Get(const std::string& key) const -> std::shared_ptr<Shader>;
+
+private:
+    std::map<std::string, std::shared_ptr<Shader>> m_cachedShaders;
+};
+
+} // namespace Renderer
+} // namespace libprojectM