test: add spatial query (hyperion-mc#754)

Author: andrewgazelka

Cargo.lock

@@ -10,7 +10,7 @@ impl<T: Debug> Bvh<T> {
     ///
     /// If no element is hit, returns `None`.
     #[allow(clippy::excessive_nesting)]
-    pub fn get_closest_ray(
+    pub fn first_ray_collision(
         &self,
         ray: Ray,
         get_aabb: impl Fn(&T) -> Aabb,

crates/bvh-region/src/query/ray.rs

@@ -37,7 +37,7 @@ fn test_bvh_vs_brute_known_case() {
 
     // BVH:
     let bvh = Bvh::build(elements.clone(), |x| *x);
-    let bvh_closest = bvh.get_closest_ray(ray, |x| *x);
+    let bvh_closest = bvh.first_ray_collision(ray, |x| *x);
 
     assert_eq!(brute_closest.map(|x| x.1), bvh_closest.map(|x| x.1));
 }
@@ -53,7 +53,7 @@ fn test_multiple_aabbs_along_ray() {
     let ray = Ray::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 0.0, 0.0));
     let bvh = Bvh::build(elements.clone(), |x| *x);
     let (closest, dist) = bvh
-        .get_closest_ray(ray, |x| *x)
+        .first_ray_collision(ray, |x| *x)
         .expect("Should find intersection");
     assert_eq!(
         closest, &elements[0],
@@ -82,7 +82,7 @@ proptest! {
         let ray = Ray::new(Vec3::new(origin.0, origin.1, origin.2), Vec3::new(direction.0, direction.1, direction.2));
 
         let bvh = Bvh::build(elements.clone(), |x| *x);
-        let bvh_closest = bvh.get_closest_ray(ray, |x| *x);
+        let bvh_closest = bvh.first_ray_collision(ray, |x| *x);
         let brute_closest = brute_force_closest_ray(&elements, ray);
 
         match (bvh_closest, brute_closest) {
@@ -287,7 +287,7 @@ proptest! {
         );
 
         let bvh = Bvh::build(elements.clone(), copied);
-        let bvh_closest = bvh.get_closest_ray(ray, copied);
+        let bvh_closest = bvh.first_ray_collision(ray, copied);
         let brute_closest = brute_force_closest_ray(&elements, ray);
 
         match (bvh_closest, brute_closest) {

crates/bvh-region/tests/simple.rs

@@ -44,6 +44,12 @@ impl Ray {
         }
     }
 
+    #[must_use]
+    pub fn from_points(origin: Vec3, end: Vec3) -> Self {
+        let direction = end - origin;
+        Self::new(origin, direction)
+    }
+
     /// Get the point along the ray at distance t
     #[must_use]
     pub fn at(&self, t: f32) -> Vec3 {

crates/geometry/src/ray.rs

@@ -73,8 +73,10 @@ valence_server = { workspace = true }
 valence_text = { workspace = true }
 
 [dev-dependencies]
+approx = { workspace = true }
 divan = { workspace = true }
 fastrand = { workspace = true }
+spatial = { workspace = true }
 
 [lints]
 workspace = true

crates/hyperion/Cargo.toml

@@ -440,7 +440,7 @@ pub struct Pitch {
 const PLAYER_WIDTH: f32 = 0.6;
 const PLAYER_HEIGHT: f32 = 1.8;
 
-#[derive(Component, Copy, Clone, Debug)]
+#[derive(Component, Copy, Clone, Debug, Constructor, PartialEq)]
 #[meta]
 pub struct EntitySize {
     pub half_width: f32,

crates/hyperion/src/simulation/mod.rs

@@ -40,7 +40,7 @@ fn arrow() {
         .set(Velocity::new(0.0, 1.0, 0.0))
         .set(Position::new(0.0, 20.0, 0.0));
 
-    println!("arrow = {arrow:?}\n");
+    println!("arrow = {arrow:?}");
 
     world.progress();
 

crates/hyperion/tests/entity.rs

@@ -0,0 +1,80 @@
+#![feature(assert_matches)]
+#![allow(
+    clippy::print_stdout,
+    reason = "the purpose of not having printing to stdout is so that tracing is used properly \
+              for the core libraries. These are tests, so it doesn't matter"
+)]
+
+use std::{assert_matches::assert_matches, collections::HashSet};
+
+use approx::assert_relative_eq;
+use flecs_ecs::core::{QueryBuilderImpl, SystemAPI, World, WorldGet, flecs};
+use geometry::{aabb::Aabb, ray::Ray};
+use glam::Vec3;
+use hyperion::{
+    HyperionCore,
+    simulation::{EntitySize, Position, entity_kind::EntityKind},
+};
+use spatial::{Spatial, SpatialIndex, SpatialModule};
+
+#[test]
+fn spatial() {
+    let world = World::new();
+    world.import::<HyperionCore>();
+    world.import::<SpatialModule>();
+
+    // Make all entities have Spatial component so they are spatially indexed
+    world
+        .observer::<flecs::OnAdd, ()>()
+        .with_enum_wildcard::<EntityKind>()
+        .each_entity(|entity, ()| {
+            entity.add::<Spatial>();
+        });
+
+    let zombie = world
+        .entity_named("test_zombie")
+        .add_enum(EntityKind::Zombie)
+        .set(EntitySize::default())
+        .set(Position::new(0.0, 0.0, 0.0));
+
+    let player = world
+        .entity_named("test_player")
+        .add_enum(EntityKind::Player)
+        .set(EntitySize::default())
+        .set(Position::new(10.0, 0.0, 0.0));
+
+    // progress one tick to ensure that the index is updated
+    world.progress();
+
+    world.get::<&SpatialIndex>(|spatial| {
+        let closest = spatial
+            .closest_to(Vec3::new(1.0, 2.0, 0.0), &world)
+            .expect("there to be a closest entity");
+        assert_eq!(closest, zombie);
+
+        let closest = spatial
+            .closest_to(Vec3::new(11.0, 2.0, 0.0), &world)
+            .expect("there to be a closest entity");
+        assert_eq!(closest, player);
+
+        let big_aabb = Aabb::new(Vec3::new(0.0, 0.0, 0.0), Vec3::new(100.0, 100.0, 100.0));
+
+        let collisions: HashSet<_> = spatial.get_collisions(big_aabb, &world).collect();
+        assert!(
+            collisions.contains(&zombie),
+            "zombie should be in collisions"
+        );
+        assert!(
+            collisions.contains(&player),
+            "player should be in collisions"
+        );
+
+        let ray = Ray::from_points(Vec3::new(0.0, 0.0, 0.0), Vec3::new(1.0, 1.0, 1.0));
+        let (first, distance) = spatial.first_ray_collision(ray, &world).unwrap();
+        assert_eq!(first, zombie);
+        assert_relative_eq!(distance.into_inner(), 0.0);
+
+        let ray = Ray::from_points(Vec3::new(12.0, 0.0, 0.0), Vec3::new(13.0, 1.0, 1.0));
+        assert_matches!(spatial.first_ray_collision(ray, &world), None);
+    });
+}

crates/hyperion/tests/spatial.rs

@@ -33,7 +33,7 @@ pub fn get_first_collision(
     world: &World,
 ) -> Option<Either<EntityView<'_>, RayCollision>> {
     // Check for collisions with entities
-    let entity = world.get::<&SpatialIndex>(|index| index.closest_to_ray(ray, world));
+    let entity = world.get::<&SpatialIndex>(|index| index.first_ray_collision(ray, world));
     let block = world.get::<&Blocks>(|blocks| blocks.first_collision(ray));
 
     // check which one is closest to the Ray don't forget to account for entity size
@@ -101,13 +101,13 @@ impl SpatialIndex {
     }
 
     #[must_use]
-    pub fn closest_to_ray<'a>(
+    pub fn first_ray_collision<'a>(
         &self,
         ray: Ray,
         world: &'a World,
     ) -> Option<(EntityView<'a>, NotNan<f32>)> {
         let get_aabb = get_aabb_func(world);
-        let (entity, distance) = self.query.get_closest_ray(ray, get_aabb)?;
+        let (entity, distance) = self.query.first_ray_collision(ray, get_aabb)?;
         let entity = world.entity_from_id(*entity);
         Some((entity, distance))
     }