intensity_map.hpp

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