src/chunk: stick bboxes into the pointer on 64-bit

1 files changed, 54 insertions, 38 deletions

diff --git a/src/collision.hpp b/src/collision.hpp
index adfec6b0..31be7c1f 100644
--- a/src/collision.hpp
+++ b/src/collision.hpp
@@ -5,59 +5,75 @@
 
 namespace floormat {
 
-struct collision_bbox final
-{
-    using BB = loose_quadtree::BoundingBox<std::int16_t>;
-
-    std::int16_t left, top;
-    std::uint16_t width, height;
-    enum pass_mode pass_mode;
-
-    constexpr collision_bbox();
-    constexpr collision_bbox(std::int16_t left, std::int16_t top, std::uint16_t width, std::uint16_t height, enum pass_mode p) noexcept;
-    operator BB() const noexcept;
-    bool intersects(BB bb) const noexcept;
-    bool intersects(collision_bbox bb) const noexcept;
-};
-
-constexpr collision_bbox::collision_bbox() :
-    left{0}, top{0}, width{0}, height{0}, pass_mode{pass_mode::pass}
-{}
-
-constexpr collision_bbox::collision_bbox(std::int16_t left, std::int16_t top, std::uint16_t width, std::uint16_t height, enum pass_mode p) noexcept :
-    left{left}, top{top}, width{width}, height{height}, pass_mode{p}
-{}
+struct compact_bb;
 
-struct collision_bb_extractor final
+struct compact_bb_extractor final
 {
     using BB = loose_quadtree::BoundingBox<std::int16_t>;
-    static void ExtractBoundingBox(const collision_bbox* object, BB* bbox);
+    [[maybe_unused]] static void ExtractBoundingBox(compact_bb* object, BB* bbox);
 };
 
+template<typename Num, typename BB, typename BBE>
 struct collision_iterator final
 {
-    using Query = typename loose_quadtree::LooseQuadtree<std::int16_t, collision_bbox, collision_bb_extractor>::Query;
+    using Query = typename loose_quadtree::LooseQuadtree<std::int16_t, BB, BBE>::Query;
 
-    explicit collision_iterator() noexcept;
-    explicit collision_iterator(Query* q) noexcept;
-    ~collision_iterator() noexcept;
-    collision_iterator& operator++() noexcept;
-    const collision_bbox* operator++(int) noexcept;
-    const collision_bbox& operator*() const noexcept;
-    const collision_bbox* operator->() const noexcept;
-    bool operator==(const collision_iterator& other) const noexcept;
-    operator bool() const noexcept;
+    explicit collision_iterator() noexcept : q{nullptr} {}
+    explicit collision_iterator(Query* q) noexcept : q{q} {}
+    ~collision_iterator() noexcept
+    {
+        if (q)
+            while (!q->EndOfQuery())
+                q->Next();
+    }
+    collision_iterator& operator++() noexcept
+    {
+        fm_debug_assert(q != nullptr && !q->EndOfQuery());
+        q->Next();
+        return *this;
+    }
+    const BB* operator++(int) noexcept
+    {
+        fm_debug_assert(q != nullptr && !q->EndOfQuery());
+        auto* bbox = q->GetCurrent();
+        fm_debug_assert(bbox != nullptr);
+        operator++();
+        return bbox;
+    }
+    const BB& operator*() const noexcept { return *operator->(); }
+    const BB* operator->() const noexcept
+    {
+        fm_debug_assert(q != nullptr && !q->EndOfQuery());
+        auto* ptr = q->GetCurrent();
+        fm_debug_assert(ptr != nullptr);
+        return ptr;
+    }
+    bool operator==(const collision_iterator& other) const noexcept
+    {
+        if (q && !other.q) [[likely]]
+            return q->EndOfQuery();
+        else if (!q && !other.q)
+            return true;
+        else if (!q)
+            return other.q->EndOfQuery();
+        else
+            return q == other.q;
+    }
+    operator bool() const noexcept { return q && !q->EndOfQuery(); }
 
 private:
     Query* q;
 };
 
+template<typename Num, typename BB, typename BBE>
 struct collision_query
 {
-    using Query = typename loose_quadtree::LooseQuadtree<std::int16_t, collision_bbox, collision_bb_extractor>::Query;
-    collision_query(Query&& q) noexcept;
-    collision_iterator begin() noexcept;
-    static collision_iterator end() noexcept;
+    using Query = typename loose_quadtree::LooseQuadtree<Num, BB, BBE>::Query;
+    collision_query(Query&& q) noexcept : q{std::move(q)} {}
+    ~collision_query() noexcept { while (!q.EndOfQuery()) q.Next(); }
+    collision_iterator<Num, BB, BBE> begin() noexcept { return collision_iterator<Num, BB, BBE>{&q}; }
+    static collision_iterator<Num, BB, BBE> end() noexcept { return collision_iterator<Num, BB, BBE>{nullptr}; }
+    operator bool() const noexcept { return !q.EndOfQuery(); }
 
 private:
     Query q;