ShaderManager.h

#pragma once
 
// Standard.
#include <string>
#include <unordered_map>
#include <memory>
#include <functional>
#include <mutex>
#include <optional>
#include <atomic>
#include <variant>
#include <array>
 
// Custom.
#include "misc/Error.h"
#include "shader/ShaderDescription.h"
#include "shader/general/cache/ShaderCacheManager.h"
#include "shader/general/ShaderPack.h"
 
namespace ne {
    class Shader;
    class Renderer;
 
    class ShaderManager {
        // Only ShaderUser should be able to work with shaders.
        friend class ShaderUser;
 
        // Renderer sets shaders' configuration.
        friend class Renderer;
 
    public:
        ShaderManager(Renderer* pRenderer);
 
        ShaderManager() = delete;
        ShaderManager(const ShaderManager&) = delete;
        ShaderManager& operator=(const ShaderManager&) = delete;
 
        virtual ~ShaderManager() = default;
 
        [[nodiscard]] std::optional<Error> compileShaders(
            std::vector<ShaderDescription> vShadersToCompile,
            const std::function<void(size_t iCompiledShaderCount, size_t iTotalShadersToCompile)>& onProgress,
            const std::function<
                void(ShaderDescription shaderDescription, std::variant<std::string, Error> error)>& onError,
            const std::function<void()>& onCompleted);
 
        bool isShaderNameCanBeUsed(const std::string& sShaderName);
 
        bool markShaderToBeRemoved(const std::string& sShaderName);
 
        void performSelfValidation();
 
    protected:
        void compileShaderTask(
            size_t iQueryId,
            const std::shared_ptr<std::atomic<size_t>>& pCompiledShaderCount,
            size_t iTotalShaderCount,
            ShaderDescription shaderDescription,
            const std::function<void(size_t iCompiledShaderCount, size_t iTotalShadersToCompile)>& onProgress,
            const std::function<
                void(ShaderDescription shaderDescription, std::variant<std::string, Error> error)>& onError,
            const std::function<void()>& onCompleted);
 
        std::shared_ptr<ShaderPack> findShader(const std::string& sShaderName);
 
        void releaseShaderBytecodeIfNotUsed(const std::string& sShaderName);
 
        void removeShaderIfMarkedToBeRemoved(const std::string& sShaderName);
 
        [[nodiscard]] std::optional<Error> refreshShaderCache();
 
    private:
        struct ShaderData {
            std::unordered_map<std::string, std::shared_ptr<ShaderPack>> compiledShaders;
 
            std::vector<std::string> vShadersToBeRemoved;
        };
 
        std::unique_ptr<ShaderCacheManager> pShaderCacheManager;
 
        std::pair<std::recursive_mutex, ShaderData> mtxShaderData;
 
        std::atomic<size_t> iTotalCompileShadersQueries = 0;
 
        Renderer* const pRenderer = nullptr;
 
        static inline const std::array<char, 65> vValidCharactersForShaderName = {
            'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q',
            'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h',
            'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y',
            'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '.', '_', '-'};
 
        static inline const size_t iMaximumShaderNameLength = 40;
    };
} // namespace ne