ShaderPack.h

#pragma once
 
// Standard.
#include <mutex>
#include <unordered_map>
#include <memory>
#include <optional>
#include <string>
 
// Custom.
#include "shader/ShaderDescription.h"
#include "shader/general/ShaderMacro.h"
 
namespace ne {
    class Renderer;
    class Shader;
 
    class ShaderPack {
        // Shader manager can change shader pack configuration (to tell what shader should be currently used).
        friend class ShaderManager;
 
    public:
        struct InternalResources {
            InternalResources() = default;
 
            bool bIsRenderConfigurationSet = false;
 
            std::set<ShaderMacro> renderConfiguration;
 
            std::unordered_map<std::set<ShaderMacro>, std::shared_ptr<Shader>, ShaderMacroSetHash>
                shadersInPack;
        };
 
        ShaderPack() = delete;
        ShaderPack(const ShaderPack&) = delete;
        ShaderPack& operator=(const ShaderPack&) = delete;
 
        virtual ~ShaderPack() = default;
 
        static std::variant<std::shared_ptr<ShaderPack>, std::string, Error>
        compileShaderPack(Renderer* pRenderer, const ShaderDescription& shaderDescription);
 
        static std::variant<std::shared_ptr<ShaderPack>, Error> createFromCache(
            Renderer* pRenderer,
            const ShaderDescription& shaderDescription,
            std::optional<ShaderCacheInvalidationReason>& cacheInvalidationReason);
 
        bool releaseShaderPackDataFromMemoryIfLoaded();
 
        std::shared_ptr<Shader> getShader(
            const std::set<ShaderMacro>& additionalConfiguration,
            std::set<ShaderMacro>& fullShaderConfiguration);
 
        std::string getShaderName() const;
 
        ShaderType getShaderType();
 
        std::pair<std::mutex, InternalResources>* getInternalResources();
 
    private:
        static void addEngineMacrosToShaderDescription(
            ShaderDescription& description,
            const std::set<ShaderMacro>& shaderConfigurationMacros,
            Renderer* pRenderer);
 
        ShaderPack(const std::string& sShaderName, ShaderType shaderType);
 
        void setRendererConfiguration(const std::set<ShaderMacro>& renderConfiguration);
 
        std::pair<std::mutex, InternalResources> mtxInternalResources;
 
        std::string sShaderName;
 
        ShaderType shaderType;
    };
} // namespace ne