ShaderDescription.h

#pragma once
 
// Standard.
#include <filesystem>
 
// Custom.
#include "io/ConfigManager.h"
#include "shader/general/formats/VertexFormat.h"
 
namespace ne {
    enum class ShaderType : int {
        VERTEX_SHADER = 0,   //< vertex shader
        FRAGMENT_SHADER = 1, //< pixel/fragment shader
        COMPUTE_SHADER = 2,  //< compute shader
        // new types go here...
        // add a test for new type...
    };
 
    enum class ShaderCacheInvalidationReason {
        ENTRY_FUNCTION_NAME_CHANGED,
        SHADER_TYPE_CHANGED,
        DEFINED_SHADER_MACROS_CHANGED,
        SHADER_SOURCE_FILE_CHANGED,
        SHADER_INCLUDE_TREE_CONTENT_CHANGED,
        COMPILED_BINARY_CHANGED, //< some binary file was changed or missing
        // add new entry to ShaderCacheInvalidationReasonDescription...
        // add test for new reason...
    };
 
    struct ShaderCacheInvalidationReasonDescription {
        inline static const std::unordered_map<ShaderCacheInvalidationReason, const char*>
            cacheInvalidationReasons = {
                {ShaderCacheInvalidationReason::ENTRY_FUNCTION_NAME_CHANGED,
                 "shader entry function name changed"},
                {ShaderCacheInvalidationReason::SHADER_TYPE_CHANGED, "shader type changed"},
                {ShaderCacheInvalidationReason::DEFINED_SHADER_MACROS_CHANGED,
                 "defined shader macros changed"},
                {ShaderCacheInvalidationReason::SHADER_SOURCE_FILE_CHANGED, "shader source file changed"},
                {ShaderCacheInvalidationReason::SHADER_INCLUDE_TREE_CONTENT_CHANGED,
                 "shader include tree content changed"},
                {ShaderCacheInvalidationReason::COMPILED_BINARY_CHANGED,
                 "previously compiled binary file(s) changed"}};
 
        static const char* getDescription(ShaderCacheInvalidationReason reason) {
            const auto it = cacheInvalidationReasons.find(reason);
            if (it == cacheInvalidationReasons.end()) [[unlikely]] {
                throw std::runtime_error("no description is provided for this reason");
            }
            return it->second;
        }
    };
 
    struct ShaderDescription {
        static const char* getConfigurationFileSectionName() { return sConfigurationFileSectionName; }
 
        ShaderDescription() = default;
 
        ShaderDescription(
            const std::string& sShaderName,
            const std::filesystem::path& pathToShaderFile,
            ShaderType shaderType,
            std::optional<VertexFormat> vertexFormat,
            const std::string& sShaderEntryFunctionName,
            const std::unordered_map<std::string, std::string>& definedShaderMacros);
 
        ShaderDescription(const ShaderDescription& other) noexcept = default;
 
        ShaderDescription& operator=(const ShaderDescription& other) noexcept = default;
 
        ShaderDescription(ShaderDescription&& other) noexcept = default;
 
        ShaderDescription& operator=(ShaderDescription&& other) noexcept = default;
 
        static std::string
        getFileHash(const std::filesystem::path& pathToFile, const std::string& sShaderName);
 
        std::optional<ShaderCacheInvalidationReason> isSerializableDataEqual(ShaderDescription& other);
 
        void from_toml(const toml::value& data); // NOLINT
 
        toml::value into_toml() const; // NOLINT
 
        // ----------------------------------------------------------------------------------------
 
        // ------------------------------- ! if adding new fields ! ------------------------------------
        // if adding new fields:
        // - add to constructor,
        // - if fields should be considered when validating cache,
        // add fields to @ref from_toml, @ref into_toml and @ref isSerializableDataEqual.
        // ----------------------------------------
 
        std::unordered_map<std::string, std::string> definedShaderMacros;
 
        std::string sShaderName;
 
        std::filesystem::path pathToShaderFile;
 
        ShaderType shaderType = ShaderType::VERTEX_SHADER;
 
        std::optional<VertexFormat> vertexFormat;
 
        std::string sShaderEntryFunctionName;
 
        // ------------------------------- ! if adding new fields ! ------------------------------------
        // if adding new fields:
        // - add to constructor,
        // - if fields should be considered when validating cache,
        // add fields to @ref from_toml, @ref into_toml and @ref isSerializableDataEqual.
        // ----------------------------------------
 
    private:
        void calculateShaderIncludeTreeHashes();
 
        static std::unordered_map<
            std::string ,
            std::
                unordered_map<std::string , std::string >>
        deserializeShaderIncludeTreeHashes(const toml::value& data);
 
        static void serializeShaderIncludeTree(
            const std::filesystem::path& pathToShaderFile,
            std::string& sCurrentIncludeChain,
            toml::value& data);
 
        // ----------------------------------------------------------------------------------------
 
        std::string sSourceFileHash;
 
        std::unordered_map<
            std::string ,
            std::
                unordered_map<std::string , std::string >>
            shaderIncludeTreeHashes;
 
        // ------------------------------- ! if adding new fields ! ------------------------------------
        // if adding new fields:
        // - if fields should be considered when validating cache,
        // add fields to @ref from_toml, @ref into_toml and @ref isSerializableDataEqual.
        // ----------------------------------------
 
        static inline std::string_view sInitialIncludeChainText = "includes";
 
        inline static auto sConfigurationFileSectionName = "shader_description";
    };
} // namespace ne