feat(core): Entity To Entity Raycasting. (#720)

Co-authored-by: Andrew Gazelka <andrew.gazelka@gmail.com>

Author: Tebarem

Cargo.lock

@@ -1,3 +1,5 @@
+use std::ops::Mul;
+
 use glam::{IVec3, Vec3};
 
 #[derive(Debug, Clone, Copy)]
@@ -7,6 +9,14 @@ pub struct Ray {
     inv_direction: Vec3,
 }
 
+impl Mul<f32> for Ray {
+    type Output = Self;
+
+    fn mul(self, rhs: f32) -> Self::Output {
+        Self::new(self.origin, self.direction * rhs)
+    }
+}
+
 impl Ray {
     #[must_use]
     pub const fn origin(&self) -> Vec3 {

crates/geometry/src/ray.rs

@@ -428,9 +428,7 @@ impl Module for EntityStateSyncModule {
 
                 #[allow(clippy::excessive_nesting)]
                 world.get::<&mut Blocks>(|blocks| {
-                    // calculate distance limit based on velocity
-                    let distance_limit = velocity.0.length();
-                    let Some(collision) = blocks.first_collision(ray, distance_limit) else {
+                    let Some(collision) = blocks.first_collision(ray) else {
                         // Drag (0.99 / 20.0)
                         // 1.0 - (0.99 / 20.0) * 0.05
                         velocity.0 *= 0.997_525;
@@ -442,7 +440,6 @@ impl Module for EntityStateSyncModule {
                         velocity.0 = velocity.0.clamp_length(0.0, 100.0);
                         return;
                     };
-                    debug!("distance_limit = {}", distance_limit);
 
                     debug!("collision = {collision:?}");
 

crates/hyperion/src/egress/sync_entity_state.rs

@@ -54,7 +54,7 @@ pub enum TrySetBlockDeltaError {
     ChunkNotLoaded,
 }
 
-#[derive(Debug)]
+#[derive(Debug, Copy, Clone)]
 pub struct RayCollision {
     pub distance: f32,
     pub location: IVec3,
@@ -99,12 +99,12 @@ impl Blocks {
     }
 
     #[must_use]
-    pub fn first_collision(&self, ray: Ray, distance_limit: f32) -> Option<RayCollision> {
+    pub fn first_collision(&self, ray: Ray) -> Option<RayCollision> {
         // Calculate exact start position (the block we're in)
         let start_pos = ray.origin();
 
         // Calculate end position with a small offset to handle edge cases
-        let end_pos = ray.origin() + ray.direction() * (distance_limit + 0.0001);
+        let end_pos = ray.origin() + ray.direction();
 
         // Convert to block coordinates, expanding bounds to ensure we catch all blocks
         let min_block = start_pos.min(end_pos).floor().as_ivec3();

crates/hyperion/src/simulation/blocks/mod.rs

@@ -9,8 +9,9 @@ publish = false
 [dependencies]
 bvh-region.workspace = true
 flecs_ecs.workspace = true
-hyperion.workspace = true
 geometry.workspace = true
+hyperion.workspace = true
+ordered-float.workspace = true
 rayon.workspace = true
 
 [lints]

crates/spatial/Cargo.toml

@@ -6,12 +6,17 @@ use flecs_ecs::{
     macros::{Component, system},
     prelude::Module,
 };
-use geometry::aabb::Aabb;
+use geometry::{aabb::Aabb, ray::Ray};
 use hyperion::{
     egress::player_join::RayonWorldStages,
     glam::Vec3,
-    simulation::{EntitySize, Position, aabb},
+    simulation::{
+        EntitySize, Position, aabb,
+        blocks::{Blocks, RayCollision},
+    },
 };
+use ordered_float::NotNan;
+use rayon::iter::Either;
 
 #[derive(Component)]
 pub struct SpatialModule;
@@ -22,6 +27,39 @@ pub struct SpatialIndex {
     query: bvh_region::Bvh<Entity>,
 }
 
+#[must_use]
+pub fn get_first_collision(
+    ray: Ray,
+    world: &World,
+) -> Option<Either<EntityView<'_>, RayCollision>> {
+    // Check for collisions with entities
+    let entity = world.get::<&SpatialIndex>(|index| index.closest_to_ray(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
+    entity.map_or(block.map(Either::Right), |(entity, _)| {
+        let entity_data = entity.get::<(&Position, &EntitySize)>(|(position, size)| {
+            let entity_aabb = aabb(**position, *size);
+
+            #[allow(clippy::redundant_closure_for_method_calls)]
+            let distance_to_entity = entity_aabb
+                .intersect_ray(&ray)
+                .map_or(f32::MAX, |distance| distance.into_inner());
+
+            (entity, distance_to_entity)
+        });
+
+        let (entity, distance_to_entity) = entity_data;
+        block.map_or(Some(Either::Left(entity)), |block_collision| {
+            if distance_to_entity < block_collision.distance {
+                Some(Either::Left(entity))
+            } else {
+                Some(Either::Right(block_collision))
+            }
+        })
+    })
+}
+
 fn get_aabb_func<'a>(world: &'a World) -> impl Fn(&Entity) -> Aabb + Send + Sync {
     let stages: &'a RayonWorldStages = world.get::<&RayonWorldStages>(|stages| {
         // we can properly extend lifetimes here
@@ -61,6 +99,18 @@ impl SpatialIndex {
         let (target, _) = self.query.get_closest(point, &get_aabb)?;
         Some(world.entity_from_id(*target))
     }
+
+    #[must_use]
+    pub fn closest_to_ray<'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 = world.entity_from_id(*entity);
+        Some((entity, distance))
+    }
 }
 
 /// If we want the entity to be spatially indexed, we need to add this component.

crates/spatial/src/lib.rs

@@ -1,11 +1,12 @@
 use clap::Parser;
-use flecs_ecs::core::{Entity, EntityView, EntityViewGet, WorldGet, WorldProvider};
+use flecs_ecs::core::{Entity, EntityView, EntityViewGet, WorldProvider};
 use hyperion::{
-    BlockState,
     glam::Vec3,
-    simulation::{Pitch, Position, Yaw, blocks::Blocks},
+    simulation::{Pitch, Position, Yaw, entity_kind::EntityKind},
 };
 use hyperion_clap::{CommandPermission, MinecraftCommand};
+use rayon::iter::Either;
+use spatial::get_first_collision;
 use tracing::debug;
 
 #[derive(Parser, CommandPermission, Debug)]
@@ -43,6 +44,7 @@ pub fn get_direction_from_rotation(yaw: f32, pitch: f32) -> Vec3 {
 impl MinecraftCommand for RaycastCommand {
     fn execute(self, system: EntityView<'_>, caller: Entity) {
         const EYE_HEIGHT: f32 = 1.62;
+        const DISTANCE: f32 = 10.0;
 
         let world = system.world();
 
@@ -55,21 +57,25 @@ impl MinecraftCommand for RaycastCommand {
                     let eye = center + Vec3::new(0.0, EYE_HEIGHT, 0.0);
                     let direction = get_direction_from_rotation(**yaw, **pitch);
 
-                    geometry::ray::Ray::new(eye, direction)
+                    geometry::ray::Ray::new(eye, direction) * DISTANCE
                 });
 
         debug!("ray = {ray:?}");
 
-        world.get::<&mut Blocks>(|blocks| {
-            let Some(collision) = blocks.first_collision(ray, 10.0) else {
-                return;
-            };
+        let result = get_first_collision(ray, &world);
 
-            debug!("collision = {collision:?}");
-
-            blocks
-                .set_block(collision.location, BlockState::DIRT)
-                .unwrap();
-        });
+        match result {
+            Some(Either::Left(entity)) => {
+                entity
+                    .entity_view(world)
+                    .get::<(&Position, &EntityKind)>(|(position, kind)| {
+                        let position = **position;
+                        debug!("kind: {kind:?}");
+                        debug!("position: {position:?}");
+                    });
+            }
+            Some(Either::Right(ray_collision)) => debug!("ray_collision: {ray_collision:?}"),
+            None => debug!("no collision found"),
+        }
     }
 }