ShaderMacro.h

#pragma once
 
// Standard.
#include <string>
#include <vector>
#include <set>
#include <unordered_map>
 
namespace ne {
    class Renderer;
 
    enum class ShaderMacro : int {
        PS_USE_DIFFUSE_TEXTURE,
        PS_USE_MATERIAL_TRANSPARENCY,
        VS_SHADOW_MAPPING_PASS,
 
        // ... add new entries here...
 
        // !! also add new entries to convertShaderMacrosToText !!
        // !! also add new entries to valid configuration combinations below !!
    };
 
    std::vector<std::string> convertShaderMacrosToText(const std::set<ShaderMacro>& macros);
 
    std::string formatShaderMacros(const std::vector<std::string>& macros);
 
    struct ShaderMacroConfigurations {
    private:
        static std::set<std::set<ShaderMacro>> combineConfigurations(
            const std::set<std::set<ShaderMacro>>& constantSets,
            const std::set<std::set<ShaderMacro>>& macroSets,
            const std::set<ShaderMacro>& appendToEachSet,
            bool bIncludeEmptyConfiguration);
 
        static std::set<std::set<ShaderMacro>> duplicateAndAppendConfiguration(
            const std::set<std::set<ShaderMacro>>& toDuplicateSets,
            const std::set<ShaderMacro>& toAppendToDuplicated);
 
        static inline const std::unordered_map<ShaderMacro, ShaderMacro> dependentMacros = {};
 
    public:
        static unsigned long long convertConfigurationToHash(const std::set<ShaderMacro>& configuration);
 
        static std::string convertConfigurationToText(const std::set<ShaderMacro>& configuration);
 
        static bool isMacroShouldBeConsideredInConfiguration(
            ShaderMacro macro, const std::set<ShaderMacro>& configuration);
 
        static inline const std::set<std::set<ShaderMacro>> validVertexShaderMacroConfigurations = {
            {}, {ShaderMacro::VS_SHADOW_MAPPING_PASS}};
 
        static inline const std::set<std::set<ShaderMacro>> validPixelShaderMacroConfigurations =
            combineConfigurations(
                {{ShaderMacro::PS_USE_DIFFUSE_TEXTURE},
                 {ShaderMacro::PS_USE_MATERIAL_TRANSPARENCY},
                 {ShaderMacro::PS_USE_DIFFUSE_TEXTURE, ShaderMacro::PS_USE_MATERIAL_TRANSPARENCY}},
                {},
                {},
                true);
 
        static inline const std::set<std::set<ShaderMacro>> validComputeShaderMacroConfigurations = {{}};
    };
 
    class ShaderConfiguration {
    public:
        ShaderConfiguration() = delete;
 
        ShaderConfiguration(Renderer* pRenderer) { this->pRenderer = pRenderer; }
 
        void updateShaderConfiguration();
 
        std::set<ShaderMacro> currentVertexShaderConfiguration;
 
        std::set<ShaderMacro> currentPixelShaderConfiguration;
 
    private:
        Renderer* pRenderer = nullptr;
    };
 
    struct ShaderMacroSetHash {
        size_t operator()(std::set<ShaderMacro> const& item) const {
            return ShaderMacroConfigurations::convertConfigurationToHash(item);
        }
    };
} // namespace ne