Add RayTest2d and RayTest3d

crates/bevy_math/src/bounding/mod.rs

@@ -59,3 +59,8 @@ mod bounded2d;
 pub use bounded2d::*;
 mod bounded3d;
 pub use bounded3d::*;
+
+mod raytest2d;
+pub use raytest2d::*;
+mod raytest3d;
+pub use raytest3d::*;

crates/bevy_math/src/bounding/raytest2d.rs

@@ -0,0 +1,98 @@
+use super::{Aabb2d, BoundingCircle, IntersectsVolume};
+use crate::{primitives::Direction2d, Ray2d, Vec2};
+
+/// A raycast intersection test for 2D bounding volumes
+pub struct RayTest2d {
+    /// The ray for the test
+    pub ray: Ray2d,
+    /// The maximum time of impact of the ray
+    pub max: f32,
+    /// The multiplicative inverse direction of the ray
+    dir_recip: Vec2,
+}
+
+impl RayTest2d {
+    /// Construct a [`RayTest2d`] from an origin, [`Direction2d`] and max time of impact.
+    pub fn new(origin: Vec2, direction: Direction2d, max: f32) -> Self {
+        Self::from_ray(Ray2d { origin, direction }, max)
+    }
+
+    /// Construct a [`RayTest2d`] from a [`Ray2d`] and max time of impact.
+    pub fn from_ray(ray: Ray2d, max: f32) -> Self {
+        Self {
+            ray,
+            dir_recip: ray.direction.recip(),
+            max,
+        }
+    }
+
+    /// Get the cached multiplicate inverse of the direction of the ray
+    pub fn dir_recip(&self) -> Vec2 {
+        self.dir_recip
+    }
+
+    /// Get the time of impact for an intersection with an [`Aabb2d`], if any.
+    pub fn aabb_intersection_at(&self, aabb: &Aabb2d) -> Option<f32> {
+        let (min_x, max_x) = if self.ray.direction.x.is_sign_positive() {
+            (aabb.min.x, aabb.max.x)
+        } else {
+            (aabb.max.x, aabb.min.x)
+        };
+        let (min_y, max_y) = if self.ray.direction.y.is_sign_positive() {
+            (aabb.min.y, aabb.max.y)
+        } else {
+            (aabb.max.y, aabb.min.y)
+        };
+
+        // Calculate the minimum/maximum time for each based on how much the direction goes that
+        // way. These values van get arbitrarily large, or even become NaN, which is handled by the
+        // min/max operations below
+        let tmin_x = (min_x - self.ray.origin.x) * self.dir_recip.x;
+        let tmin_y = (min_y - self.ray.origin.y) * self.dir_recip.y;
+        let tmax_x = (max_x - self.ray.origin.x) * self.dir_recip.x;
+        let tmax_y = (max_y - self.ray.origin.y) * self.dir_recip.y;
+
+        // An axis that is not relevant to the ray direction will be NaN. When one of the arguments
+        // to min/max is NaN, the other argument is used.
+        // An axis for which the direction is the wrong way will return an arbitrarily large
+        // negative value.
+        let tmin = tmin_x.max(tmin_y).max(0.);
+        let tmax = tmax_y.min(tmax_x).min(self.max);
+
+        if tmin <= tmax {
+            Some(tmin)
+        } else {
+            None
+        }
+    }
+
+    /// Get the time of impact for an intersection with a [`BoundingCircle`], if any.
+    pub fn circle_intersection_at(&self, sphere: &BoundingCircle) -> Option<f32> {
+        let offset = self.ray.origin - sphere.center;
+        let projected = offset.dot(*self.ray.direction);
+        let closest_point = offset - projected * *self.ray.direction;
+        let distance_squared = sphere.radius().powi(2) - closest_point.length_squared();
+        if distance_squared < 0. || projected.powi(2).copysign(-projected) < -distance_squared {
+            None
+        } else {
+            let toi = -projected - distance_squared.sqrt();
+            if toi > self.max {
+                None
+            } else {
+                Some(toi.max(0.))
+            }
+        }
+    }
+}
+
+impl IntersectsVolume<Aabb2d> for RayTest2d {
+    fn intersects(&self, volume: &Aabb2d) -> bool {
+        self.aabb_intersection_at(volume).is_some()
+    }
+}
+
+impl IntersectsVolume<BoundingCircle> for RayTest2d {
+    fn intersects(&self, volume: &BoundingCircle) -> bool {
+        self.circle_intersection_at(volume).is_some()
+    }
+}

crates/bevy_math/src/bounding/raytest3d.rs

@@ -0,0 +1,105 @@
+use super::{Aabb3d, BoundingSphere, IntersectsVolume};
+use crate::{primitives::Direction3d, Ray3d, Vec3};
+
+/// A raycast intersection test for 3D bounding volumes
+pub struct RayTest3d {
+    /// The ray for the test
+    pub ray: Ray3d,
+    /// The maximum time of impact of the ray
+    pub max: f32,
+    /// The multiplicative inverse direction of the ray
+    dir_recip: Vec3,
+}
+
+impl RayTest3d {
+    /// Construct a [`RayTest3d`] from an origin, [`Direction3d`] and max time of impact.
+    pub fn new(origin: Vec3, direction: Direction3d, max: f32) -> Self {
+        Self::from_ray(Ray3d { origin, direction }, max)
+    }
+
+    /// Construct a [`RayTest3d`] from a [`Ray3d`] and max time of impact.
+    pub fn from_ray(ray: Ray3d, max: f32) -> Self {
+        Self {
+            ray,
+            dir_recip: ray.direction.recip(),
+            max,
+        }
+    }
+
+    /// Get the cached multiplicate inverse of the direction of the ray
+    pub fn dir_recip(&self) -> Vec3 {
+        self.dir_recip
+    }
+
+    /// Get the time of impact for an intersection with an [`Aabb3d`], if any.
+    pub fn aabb_intersection_at(&self, aabb: &Aabb3d) -> Option<f32> {
+        let (min_x, max_x) = if self.ray.direction.x.is_sign_positive() {
+            (aabb.min.x, aabb.max.x)
+        } else {
+            (aabb.max.x, aabb.min.x)
+        };
+        let (min_y, max_y) = if self.ray.direction.y.is_sign_positive() {
+            (aabb.min.y, aabb.max.y)
+        } else {
+            (aabb.max.y, aabb.min.y)
+        };
+        let (min_z, max_z) = if self.ray.direction.z.is_sign_positive() {
+            (aabb.min.z, aabb.max.z)
+        } else {
+            (aabb.max.z, aabb.min.z)
+        };
+
+        // Calculate the minimum/maximum time for each based on how much the direction goes that
+        // way. These values van get arbitrarily large, or even become NaN, which is handled by the
+        // min/max operations below
+        let tmin_x = (min_x - self.ray.origin.x) * self.dir_recip.x;
+        let tmin_y = (min_y - self.ray.origin.y) * self.dir_recip.y;
+        let tmin_z = (min_z - self.ray.origin.z) * self.dir_recip.z;
+        let tmax_x = (max_x - self.ray.origin.x) * self.dir_recip.x;
+        let tmax_y = (max_y - self.ray.origin.y) * self.dir_recip.y;
+        let tmax_z = (max_z - self.ray.origin.z) * self.dir_recip.z;
+
+        // An axis that is not relevant to the ray direction will be NaN. When one of the arguments
+        // to min/max is NaN, the other argument is used.
+        // An axis for which the direction is the wrong way will return an arbitrarily large
+        // negative value.
+        let tmin = tmin_x.max(tmin_y).max(tmin_z).max(0.);
+        let tmax = tmax_z.min(tmax_y).min(tmax_x).min(self.max);
+
+        if tmin <= tmax {
+            Some(tmin)
+        } else {
+            None
+        }
+    }
+
+    /// Get the time of impact for an intersection with a [`BoundingSphere`], if any.
+    pub fn sphere_intersection_at(&self, sphere: &BoundingSphere) -> Option<f32> {
+        let offset = self.ray.origin - sphere.center;
+        let projected = offset.dot(*self.ray.direction);
+        let closest_point = offset - projected * *self.ray.direction;
+        let distance_squared = sphere.radius().powi(2) - closest_point.length_squared();
+        if distance_squared < 0. || projected.powi(2).copysign(-projected) < -distance_squared {
+            None
+        } else {
+            let toi = -projected - distance_squared.sqrt();
+            if toi > self.max {
+                None
+            } else {
+                Some(toi.max(0.))
+            }
+        }
+    }
+}
+
+impl IntersectsVolume<Aabb3d> for RayTest3d {
+    fn intersects(&self, volume: &Aabb3d) -> bool {
+        self.aabb_intersection_at(volume).is_some()
+    }
+}
+
+impl IntersectsVolume<BoundingSphere> for RayTest3d {
+    fn intersects(&self, volume: &BoundingSphere) -> bool {
+        self.sphere_intersection_at(volume).is_some()
+    }
+}