block.hpp

 
#ifndef UFO_MAP_DISTANCE_BLOCK_HPP
#define UFO_MAP_DISTANCE_BLOCK_HPP
 
// UFO
#include <ufo/geometry/aabb.hpp>
#include <ufo/map/distance/info.hpp>
#include <ufo/numeric/vec.hpp>
#include <ufo/utility/create_array.hpp>
 
// STL
#include <array>
#include <cassert>
#include <cstddef>
#include <limits>
 
namespace ufo
{
template <std::size_t Dim, std::size_t BF, bool WithBounds>
struct DistanceBlock {
    using Point  = typename DistanceInfo<Dim>::Point;
    using Bounds = AABB<Dim, float>;
 
    constexpr DistanceBlock() = default;
 
    constexpr DistanceBlock(DistanceBlock const& parent, std::size_t offset)
        : info_(createArray<BF>(parent.info_[offset]))
        , bounds_(createArray<BF>(parent.bounds_[offset]))
    {
    }
 
    constexpr void fill(DistanceBlock const& parent, std::size_t offset)
    {
        info_   = createArray<BF>(parent.info_[offset]);
        bounds_ = createArray<BF>(parent.bounds_[offset]);
    }
 
    [[nodiscard]] constexpr DistanceInfo<Dim>& operator[](std::size_t pos)
    {
        assert(BF > pos);
        return info_[pos];
    }
 
    [[nodiscard]] constexpr DistanceInfo<Dim> const& operator[](std::size_t pos) const
    {
        assert(BF > pos);
        return info_[pos];
    }
 
    [[nodiscard]] constexpr auto& info() { return info_; }
 
    [[nodiscard]] constexpr auto const& info() const { return info_; }
 
    [[nodiscard]] constexpr auto& bounds() { return bounds_; }
 
    [[nodiscard]] constexpr auto const& bounds() const { return bounds_; }
 
    [[nodiscard]] constexpr Bounds& bounds(std::size_t pos)
    {
        assert(BF > pos);
        return bounds_[pos];
    }
 
    [[nodiscard]] constexpr Bounds const& bounds(std::size_t pos) const
    {
        assert(BF > pos);
        return bounds_[pos];
    }
 
    [[nodiscard]] static constexpr DistanceInfo<Dim> resetInfo()
    {
        return DistanceInfo<Dim>{Point(std::numeric_limits<float>::max()), 0.0f};
    }
 
    [[nodiscard]] static constexpr Bounds resetBounds()
    {
        return Bounds(Point(std::numeric_limits<float>::max()),
                      Point(std::numeric_limits<float>::lowest()));
    }
    void reset() { fill(resetInfo(), resetBounds()); }
 
    void reset(std::size_t pos)
    {
        assert(BF > pos);
        info_[pos]   = resetInfo();
        bounds_[pos] = resetBounds();
    }
 
 private:
    // We have them in different arrays to simplify (de)serialization
    std::array<DistanceInfo<Dim>, BF> info_ = createArray<BF>(resetInfo());
    // TODO: Store single per block
    std::array<Bounds, BF> bounds_ = createArray<BF>(resetBounds());
};
}  // namespace ufo
 
#endif  // UFO_MAP_DISTANCE_BLOCK_HPP