Shader.h

#pragma once
 
// Standard.
#include <filesystem>
#include <memory>
#include <unordered_map>
#include <variant>
 
// Custom.
#include "misc/Error.h"
#include "shader/ShaderDescription.h"
#include "shader/general/format/VertexFormat.h"
 
namespace ne {
    class Renderer;
    class ConfigManager;
 
    class Shader {
    public:
        Shader() = delete;
        Shader(const Shader&) = delete;
        Shader& operator=(const Shader&) = delete;
 
        virtual ~Shader() = default;
 
        static constexpr const char* getFrameConstantsShaderResourceName() {
            return pFrameConstantBufferName;
        }
 
        static size_t getCurrentAmountOfShadersInMemory();
 
        static std::variant<std::shared_ptr<Shader>, std::string, Error> compileShader(
            Renderer* pRenderer,
            const std::filesystem::path& shaderCacheDirectory,
            const std::string& sConfiguration,
            const ShaderDescription& shaderDescription);
 
        static std::variant<std::shared_ptr<Shader>, Error> createFromCache(
            Renderer* pRenderer,
            const std::filesystem::path& pathToCompiledShaderBytecode,
            ShaderDescription& shaderDescription,
            const std::string& sShaderNameWithoutConfiguration,
            std::optional<ShaderCacheInvalidationReason>& cacheInvalidationReason);
 
        std::string getShaderName() const;
 
        ShaderType getShaderType() const;
 
        std::optional<VertexFormat> getVertexFormat() const;
 
        virtual bool releaseShaderDataFromMemoryIfLoaded() = 0;
 
    protected:
        Shader(
            Renderer* pRenderer,
            std::filesystem::path pathToCompiledShader,
            const std::string& sShaderName,
            ShaderType shaderType,
            std::optional<VertexFormat> vertexFormat);
 
        static void notifyShaderBytecodeLoadedIntoMemory();
 
        static void notifyShaderBytecodeReleasedFromMemory();
 
        [[nodiscard]] virtual std::optional<Error>
        saveAdditionalCompilationResultsInfo(ConfigManager& cacheMetadataConfigManager) {
            return {};
        };
 
        [[nodiscard]] virtual std::optional<Error> checkCachedAdditionalCompilationResultsInfo(
            ConfigManager& cacheMetadataConfigManager,
            std::optional<ShaderCacheInvalidationReason>& cacheInvalidationReason) {
            return {};
        };
 
        std::variant<std::filesystem::path, Error> getPathToCompiledShader();
 
        Renderer* getRenderer() const;
 
    private:
        static std::variant<std::shared_ptr<Shader>, std::string, Error> compileRenderDependentShader(
            Renderer* pRenderer,
            const std::filesystem::path& shaderCacheDirectory,
            const std::string& sConfiguration,
            const ShaderDescription& shaderDescription);
 
        static std::variant<std::shared_ptr<Shader>, Error> createRenderDependentShaderFromCache(
            Renderer* pRenderer,
            const std::filesystem::path& pathToSourceShaderFile,
            const std::filesystem::path& pathToCompiledShaderBytecode,
            const std::string& sShaderName,
            ShaderType shaderType,
            std::optional<VertexFormat> vertexFormat);
 
        Renderer* const pRenderer = nullptr;
 
        const std::optional<VertexFormat> optionalVertexFormat;
 
        const std::string sShaderName;
 
        const ShaderType shaderType;
 
        const std::filesystem::path pathToCompiledShader;
 
        static inline const auto sCompiledBytecodeHashKeyName = "compiled_bytecode_hash";
 
        static constexpr auto pFrameConstantBufferName = "frameData";
    };
} // namespace ne