shader_registry.hpp

Go to the documentation of this file.

#pragma once
 
#include <mbgl/gfx/shader.hpp>
 
#include <memory>
#include <mutex>
#include <shared_mutex>
#include <unordered_map>
 
namespace mbgl {
namespace gfx {
 
class ShaderRegistry {
    public:
        explicit ShaderRegistry();
        ShaderRegistry(const ShaderRegistry&) = delete;
        ShaderRegistry(ShaderRegistry&&) noexcept = delete;
        ShaderRegistry& operator=(const ShaderRegistry&) = delete;
        ShaderRegistry& operator=(ShaderRegistry&&) noexcept = delete;
        virtual ~ShaderRegistry() = default;
 
        [[nodiscard]] virtual bool isShader(const std::string& shaderName)
            const noexcept;
        
        [[nodiscard]] virtual const std::shared_ptr<gfx::Shader> getShader(
            const std::string& shaderName) const noexcept;
 
        [[nodiscard]] virtual bool replaceShader(
            std::shared_ptr<Shader>&& shader) noexcept;
 
        [[nodiscard]] virtual bool replaceShader(
            std::shared_ptr<Shader>&& shader, const std::string& shaderName) noexcept;
            
        [[nodiscard]] virtual bool registerShader(
            std::shared_ptr<Shader>&& shader) noexcept;
        
        [[nodiscard]] virtual bool registerShader(
            std::shared_ptr<Shader>&& shader, const std::string& shaderName) noexcept;
 
        template<typename T,
            typename std::enable_if_t<is_shader_v<T>, bool>* = nullptr>
        std::shared_ptr<T> get(const std::string& shaderName) noexcept {
            auto shader = getShader(shaderName);
            if (!shader || shader->typeName() != T::Name) {
                return nullptr;
            }
            return std::static_pointer_cast<T>(shader);
        }
 
        template<typename T,
            typename std::enable_if_t<is_shader_v<T>, bool>* = nullptr>
        std::shared_ptr<T> get() noexcept {
            auto shader = getShader(std::string(T::Name));
            if (!shader || shader->typeName() != T::Name) {
                return nullptr;
            }
            return std::static_pointer_cast<T>(shader);
        }
 
        template<typename T,
            typename std::enable_if_t<is_shader_v<T>, bool>* = nullptr>
        bool populate(std::shared_ptr<T>& to, const std::string& shaderName) noexcept {
            if (to) {
                return true;
            }
 
            auto shader = getShader(shaderName);
            if (!shader || shader->typeName() != T::Name) {
                return false;
            }
            to = std::static_pointer_cast<T>(shader);
            return true;
        }
 
        template<typename T,
            typename std::enable_if_t<is_shader_v<T>, bool>* = nullptr>
        bool populate(std::shared_ptr<T>& to) noexcept {
            if (to) {
                return true;
            }
 
            auto shader = getShader(std::string(T::Name));
            if (!shader || shader->typeName() != T::Name) {
                return false;
            }
            to = std::static_pointer_cast<T>(shader);
            return true;
        }
 
    private:
        std::unordered_map<
            std::string,
            std::shared_ptr<gfx::Shader>
        > programs;
        mutable std::shared_mutex programLock;
};
 
} // namespace gfx
} // namespace mbgl