color_map.hpp

 
#ifndef UFO_MAP_COLOR_PREDICATE_COLOR_MAP_HPP
#define UFO_MAP_COLOR_PREDICATE_COLOR_MAP_HPP
 
// UFO
#include <ufo/map/predicate/predicate.hpp>
 
namespace ufo::pred
{
template <bool Negated = false>
struct ColorMap {
 private:
    bool enabled;
 
    friend struct Init<ColorMap>;
    friend struct InnerCheck<ColorMap>;
    friend struct ValueCheck<ColorMap>;
    friend struct ShaderInnerCheck<ColorMap>;
    friend struct ShaderValueCheck<ColorMap>;
};
 
template <bool Negated>
ColorMap<!Negated> operator!(ColorMap<Negated>)
{
    return {};
}
 
template <bool Negated>
struct Init<ColorMap<Negated>> {
    using Pred = ColorMap<Negated>;
 
    template <class Map>
    static inline void apply(Pred& p, Map const& m)
    {
        p.enabled = m.isMapTypesEnabled(MapType::COLOR);
    }
};
 
template <bool Negated>
struct InnerCheck<ColorMap<Negated>> {
    using Pred = ColorMap<Negated>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred p, Map const&, Node)
    {
        if constexpr (!Map::enableDisableUtilityPresent()) {
            if constexpr (Negated) {
                return !is_color_map_v<Map>;
            } else {
                return is_color_map_v<Map>;
            }
        } else {
            if constexpr (Negated) {
                return !p.enabled;
            } else {
                return p.enabled;
            }
        }
    }
};
 
template <bool Negated, class PredPost>
struct InnerCheck<Then<ColorMap<Negated>, PredPost>> {
    using Pred = Then<ColorMap<Negated>, PredPost>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred const& p, Map const& m, Node const& n)
    {
        if constexpr (!Map::enableDisableUtilityPresent()) {
            if constexpr (InnerCheck<ColorMap<Negated>>::apply(p.pre, m, n)) {
                return InnerCheck<PredPost>::apply(p.post, m, n);
            } else {
                return true;
            }
        } else {
            return !InnerCheck<ColorMap<Negated>>::apply(p.pre, m, n) ||
                   InnerCheck<PredPost>::apply(p.post, m, n);
        }
    }
};
 
template <bool Negated>
struct ValueCheck<ColorMap<Negated>> {
    using Pred = ColorMap<Negated>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred p, Map const&, Node const& n)
    {
        if constexpr (!Map::enableDisableUtilityPresent()) {
            if constexpr (Negated) {
                return !is_color_map_v<Map>;
            } else {
                return is_color_map_v<Map>;
            }
        } else {
            if constexpr (Negated) {
                return !p.enabled;
            } else {
                return p.enabled;
            }
        }
    }
};
 
template <bool Negated, class PredPost>
struct ValueCheck<Then<ColorMap<Negated>, PredPost>> {
    using Pred = Then<ColorMap<Negated>, PredPost>;
 
    template <class Map, class Node>
    static constexpr bool apply(Pred const& p, Map const& m, Node const& n)
    {
        if constexpr (!Map::enableDisableUtilityPresent()) {
            if constexpr (ValueCheck<ColorMap<Negated>>::apply(p.pre, m, n)) {
                return ValueCheck<PredPost>::apply(p.post, m, n);
            } else {
                return true;
            }
        } else {
            return !ValueCheck<ColorMap<Negated>>::apply(p.pre, m, n) ||
                   ValueCheck<PredPost>::apply(p.post, m, n);
        }
    }
};
}  // namespace ufo::pred
 
#endif  // UFO_MAP_COLOR_PREDICATE_COLOR_MAP_HPP