Implements first draft of quadtree lookup implemented via *BoundingBox*

arcs/Cargo.toml

@@ -26,6 +26,8 @@ kurbo = "0.5"
 shred = "0.9"
 cgmath = "0.17.0"
 lazy_static = "1"
+aabb-quadtree = "0.2.0"
+quadtree_euclid = { package = "euclid", version = "0.19.8" }
 euclid = "0.20.7"
 
 [dev-dependencies]

arcs/src/components/bounding_box.rs

@@ -2,6 +2,8 @@ use crate::{algorithms::Bounded, DrawingSpace, Length, Point, Vector};
 use euclid::{num::Zero, Size2D};
 use specs::prelude::*;
 use specs_derive::Component;
+use aabb_quadtree::{Spatial};
+use quadtree_euclid::{TypedRect, TypedPoint2D, TypedSize2D};
 
 /// An axis-aligned bounding box.
 #[derive(Debug, Copy, Clone, PartialEq, Component)]
@@ -11,6 +13,16 @@ pub struct BoundingBox {
     top_right: Point,
 }
 
+impl Spatial<f64> for BoundingBox {
+    fn aabb(&self) -> TypedRect<f32, f64> {
+        let bb = self;
+        TypedRect::<f32, f64>::new(
+            // TypedRects have their origin at the bottom left corner (this is undocumented!)
+            TypedPoint2D::new(bb.bottom_left().x as f32, bb.bottom_left().y as f32),
+            TypedSize2D::new(bb.width() as f32, bb.height() as f32))
+    }
+}
+
 impl BoundingBox {
     /// Create a new [`BoundingBox`] around two points.
     pub fn new(first: Point, second: Point) -> Self {
@@ -73,6 +85,8 @@ impl BoundingBox {
 
     pub fn diagonal(self) -> Vector { self.top_right - self.bottom_left }
 
+    pub fn center(self) -> Vector { self.bottom_left() + self.diagonal() * 0.5 }
+
     /// Merge two [`BoundingBox`]es.
     pub fn merge(left: BoundingBox, right: BoundingBox) -> BoundingBox {
         BoundingBox::new(left.bottom_left, right.top_right)

arcs/src/components/mod.rs

@@ -8,6 +8,7 @@ mod name;
 mod styles;
 mod viewport;
 mod vtable;
+mod spatial_entity;
 
 pub use bounding_box::BoundingBox;
 pub use dimension::Dimension;
@@ -17,6 +18,7 @@ pub use name::{Name, NameTable};
 pub use styles::{LineStyle, PointStyle, WindowStyle};
 pub use viewport::Viewport;
 pub(crate) use vtable::ComponentVtable;
+pub use spatial_entity::{SpatialEntity, Space};
 
 use specs::World;
 

arcs/src/components/spatial_entity.rs

@@ -0,0 +1,145 @@
+use crate::{
+    components::BoundingBox,
+    Vector,
+    primitives::{Arc},
+    algorithms::{Bounded},
+};
+use specs::{Entity, world::Index};
+use aabb_quadtree::{QuadTree, Spatial, ItemId};
+use quadtree_euclid::{TypedRect, TypedPoint2D, TypedSize2D};
+use std::collections::HashMap;
+
+pub(crate) type SpatialTree = QuadTree<SpatialEntity, f64, [(ItemId, TypedRect<f32, f64>); 0]>;
+
+/// A intermediate struct that maps an [`Entity`] to its [`BoundingBox`]
+/// 
+/// This is used to populate an efficient spatial lookup structure like a `QuadTree`
+#[derive(Debug)]
+pub struct SpatialEntity {
+    pub bounds: BoundingBox,
+    pub entity: Entity
+}
+
+impl Spatial<f64> for SpatialEntity {
+    fn aabb(&self) -> TypedRect<f32, f64> {
+        let bb = self.bounds;
+        TypedRect::<f32, f64>::new(
+            // TypedRects have their origin at the bottom left corner (this is undocumented!)
+            TypedPoint2D::new(bb.bottom_left().x as f32, bb.bottom_left().y as f32),
+            TypedSize2D::new(bb.width() as f32, bb.height() as f32))
+    }
+}
+
+impl SpatialEntity {
+    pub fn new(bounds: BoundingBox, entity: Entity) -> SpatialEntity {
+        SpatialEntity {
+            bounds,
+            entity
+        }
+    }
+}
+
+/// A global [`Resource`] for looking up which [`Entity`]s inhabit
+/// a given spatial point or region
+#[derive(Debug)]
+pub struct Space {
+    quadtree: SpatialTree,
+    ids: HashMap<Index, ItemId>
+}
+
+impl Default for Space {
+    fn default() -> Self {
+        Space {
+            quadtree: Self::default_tree(),
+            ids: HashMap::new()
+        }
+    }
+}
+
+impl Space {
+    // FIXME: Hard-code is bad-bad
+    const WORLD_RADIUS: f64 = 1_000_000.0;
+
+    // FIXME: We need to supply this in *DrawingUnits*
+    // as 1[meter] f.e. becomes meaningless when zoomed far in/out
+    const QUERY_POINT_RADIUS: f64 = 1.0;
+
+    fn default_tree() -> SpatialTree{
+        // Initialize quadtree
+        let size = BoundingBox::new(
+            Vector::new(-Self::WORLD_RADIUS, -Self::WORLD_RADIUS),
+            Vector::new(Self::WORLD_RADIUS, Self::WORLD_RADIUS)
+            ).aabb();
+        let quadtree: SpatialTree = QuadTree::new(
+            size,
+            true,
+            4,
+            16,
+            8,
+            4
+        );
+
+        quadtree
+    }
+
+    pub fn insert(&mut self, spatial: SpatialEntity) {
+        let entity_id = spatial.entity.id();
+        if let Some(id) = self.quadtree.insert(spatial) {
+            self.ids.insert(entity_id, id);
+        }
+    }
+
+    pub fn modify(&mut self, spatial: SpatialEntity) {
+        let entity_id = spatial.entity.id();
+        if self.ids.contains_key(&entity_id) {
+            let item_id = self.ids[&entity_id];
+
+            // remove old item
+            self.quadtree.remove(item_id);
+            self.ids.remove(&entity_id);
+
+            // Add modified
+            self.insert(spatial);
+        }
+    }
+
+    pub fn remove_by_id(&mut self, id: Index) {
+        if self.ids.contains_key(&id) {
+            let item_id = self.ids[&id];
+
+            // remove old item
+            self.quadtree.remove(item_id);
+            self.ids.remove(&id);
+        }
+    }
+
+    pub fn len(&self) -> usize {
+        self.ids.len()
+    }
+
+    pub fn is_empty(&self) -> bool {
+        self.ids.is_empty()
+    }
+
+    pub fn query_point(&self, point: Vector) -> Option<Vec<Entity>> {
+        let cursor_circle = Arc::from_centre_radius(point, Self::QUERY_POINT_RADIUS, 0.0, 2.0 * std::f64::consts::PI);
+        self.query_region(cursor_circle.bounding_box())
+    }
+
+    pub fn query_region(&self, region: BoundingBox) -> Option<Vec<Entity>> {
+        let query = self.quadtree.query(region.aabb());
+
+        if query.is_empty() {
+            None
+        }
+        else {
+            let query_result: Vec<_> = query.iter().map(|q| q.0.entity).collect();
+            Some(query_result)
+        }
+    }
+
+    pub fn clear(&mut self) {
+        self.quadtree = Self::default_tree();
+        self.ids.clear();
+    }
+}

arcs/src/systems/mod.rs

@@ -2,9 +2,11 @@
 
 mod bounds;
 mod name_table_bookkeeping;
+mod spatial_relation;
 
 pub use bounds::SyncBounds;
 pub use name_table_bookkeeping::NameTableBookkeeping;
+pub use spatial_relation::SpatialRelation;
 
 use specs::{DispatcherBuilder, World};
 
@@ -20,4 +22,5 @@ pub fn register_background_tasks<'a, 'b>(
             &[],
         )
         .with(SyncBounds::new(world), SyncBounds::NAME, &[])
+        .with(SpatialRelation::new(world), SpatialRelation::NAME, &[])
 }