coord.hpp

 
#ifndef UFO_CONTAINER_TREE_PREDICATE_COORD_HPP
#define UFO_CONTAINER_TREE_PREDICATE_COORD_HPP
 
// UFO
#include <ufo/container/tree/predicate/filter.hpp>
#include <ufo/container/tree/predicate/predicate_interval.hpp>
 
namespace ufo::pred
{
namespace detail
{
template <std::size_t Axis>
struct Coord {
    using value_type = float;
};
}  // namespace detail
 
template <std::size_t Axis, bool Negated = false>
using Coord = PredicateInterval<detail::Coord<Axis>, Negated>;
 
template <bool Negated = false>
using X = Coord<0, Negated>;
 
template <bool Negated = false>
using Y = Coord<1, Negated>;
 
template <bool Negated = false>
using Z = Coord<2, Negated>;
 
template <bool Negated = false>
using W = Coord<3, Negated>;
 
static constexpr inline X<false> const x;
static constexpr inline Y<false> const y;
static constexpr inline Z<false> const z;
static constexpr inline W<false> const w;
 
template <std::size_t Axis, bool Negated>
struct Filter<Coord<Axis, Negated>> {
    using Pred = Coord<Axis, Negated>;
 
    template <class Tree>
    static constexpr void init(Pred&, Tree const&) noexcept
    {
    }
 
    template <class Value>
    [[nodiscard]] static constexpr bool returnableValue(Pred const&, Value const&) noexcept
    {
        return true;
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool returnable(Pred const& p, Tree const& t,
                                                   typename Tree::Node const& n) noexcept
    {
        auto c  = t.centerAxis(n, Axis);
        auto hl = t.halfLength(n)[Axis];
 
        if constexpr (Negated) {
            // Check if the interval is outside the node
            return p.min > c + hl || p.max < c - hl;
        } else {
            // Check if the node overlaps with the interval
            return p.min <= c + hl && p.max >= c - hl;
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversable(Pred const& p, Tree const& t,
                                                    typename Tree::Node const& n) noexcept
    {
        auto c  = t.centerAxis(n, Axis);
        auto hl = t.halfLength(n)[Axis];
 
        if constexpr (Negated) {
            // Check if the whole node is contained in the negated interval
            return !(p.min <= c - hl && p.max >= c + hl);
        } else {
            // Check if the node overlaps with the interval
            return p.min <= c + hl && p.max >= c - hl;
        }
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool returnableRay(Pred const& p, Tree const& t,
                                                      typename Tree::Node const& n,
                                                      typename Tree::Ray const&) noexcept
    {
        return returnable(p, t, n);
    }
 
    template <class Tree>
    [[nodiscard]] static constexpr bool traversableRay(Pred const& p, Tree const& t,
                                                       typename Tree::Node const& n,
                                                       typename Tree::Ray const&) noexcept
    {
        return traversable(p, t, n);
    }
};
}  // namespace ufo::pred
 
#endif  // UFO_CONTAINER_TREE_PREDICATE_COORD_HPP