Aabb: add intersect_ray() + lots of extra tests

Author: Bromeon

godot-core/src/builtin/aabb.rs

@@ -344,22 +344,56 @@ impl Aabb {
 
     /// Returns `true` if the given ray intersects with this AABB. Ray length is infinite.
     ///
-    /// # Panics
+    /// Semantically equivalent to `self.intersects_ray(ray_from, ray_dir).is_some()`; might be microscopically faster.
+    ///
+    /// # Panics (Debug)
     /// If `self.size` is negative.
     #[inline]
-    pub fn intersects_ray(self, from: Vector3, dir: Vector3) -> bool {
+    pub fn intersects_ray(self, ray_from: Vector3, ray_dir: Vector3) -> bool {
+        let (tnear, tfar) = self.compute_ray_tnear_tfar(ray_from, ray_dir);
+
+        tnear <= tfar
+    }
+
+    /// Returns the point where the given (infinite) ray intersects with this AABB, or `None` if there is no intersection.
+    ///
+    /// # Panics (Debug)
+    /// If `self.size` is negative, or if `ray_dir` is zero. Note that this differs from Godot, which treats rays that degenerate to points as
+    /// intersecting if inside, and not if outside the AABB.
+    #[inline]
+    pub fn intersect_ray(self, ray_from: Vector3, ray_dir: Vector3) -> Option<Vector3> {
+        let (tnear, tfar) = self.compute_ray_tnear_tfar(ray_from, ray_dir);
+
+        if tnear <= tfar {
+            // if tnear < 0: the ray starts inside the box -> take other intersection point.
+            let t = if tnear < 0.0 { tfar } else { tnear };
+            Some(ray_from + ray_dir * t)
+        } else {
+            None
+        }
+    }
+
+    // Credits: https://tavianator.com/2011/ray_box.html
+    fn compute_ray_tnear_tfar(self, ray_from: Vector3, ray_dir: Vector3) -> (real, real) {
         self.assert_nonnegative();
+        debug_assert!(
+            ray_dir != Vector3::ZERO,
+            "ray direction must not be zero; use contains_point() for point checks"
+        );
 
-        let tmin = (self.position - from) / dir;
-        let tmax = (self.end() - from) / dir;
+        // Note: leads to -inf/inf for each component that is 0. This should generally balance out, unless all are zero.
+        let recip_dir = ray_dir.recip();
+
+        let tmin = (self.position - ray_from) * recip_dir;
+        let tmax = (self.end() - ray_from) * recip_dir;
 
         let t1 = tmin.coord_min(tmax);
         let t2 = tmin.coord_max(tmax);
 
         let tnear = t1.x.max(t1.y).max(t1.z);
-        let tfar = t2.y.min(t2.x).min(t2.z);
+        let tfar = t2.x.min(t2.y).min(t2.z);
 
-        tnear <= tfar
+        (tnear, tfar)
     }
 
     /// Returns `true` if the given ray intersects with this AABB. Segment length is finite.
@@ -571,6 +605,7 @@ mod test {
         };
         let from1 = Vector3::new(1.0, 1.0, -1.0);
         let dir1 = Vector3::new(0.0, 0.0, 1.0);
+
         assert!(aabb1.intersects_ray(from1, dir1));
 
         // Test case 2: Ray misses the AABB
@@ -619,15 +654,159 @@ mod test {
         assert!(aabb6.intersects_ray(from6, dir6));
     }
 
+    #[test] // Ported from Godot tests.
+    fn test_intersect_ray_2() {
+        let aabb = Aabb {
+            position: Vector3::new(-1.5, 2.0, -2.5),
+            size: Vector3::new(4.0, 5.0, 6.0),
+        };
+
+        assert_eq!(
+            aabb.intersect_ray(Vector3::new(-100.0, 3.0, 0.0), Vector3::new(1.0, 0.0, 0.0)),
+            Some(Vector3::new(-1.5, 3.0, 0.0)),
+            "intersect_ray(), ray points directly at AABB -> Some"
+        );
+
+        assert_eq!(
+            aabb.intersect_ray(Vector3::new(10.0, 10.0, 0.0), Vector3::new(0.0, 1.0, 0.0)),
+            None,
+            "intersect_ray(), ray parallel and outside the AABB -> None"
+        );
+
+        assert_eq!(
+            aabb.intersect_ray(Vector3::ONE, Vector3::new(0.0, 1.0, 0.0)),
+            Some(Vector3::new(1.0, 2.0, 1.0)),
+            "intersect_ray(), ray originating inside the AABB -> Some"
+        );
+
+        assert_eq!(
+            aabb.intersect_ray(Vector3::new(-10.0, 0.0, 0.0), Vector3::new(-1.0, 0.0, 0.0)),
+            None,
+            "intersect_ray(), ray points away from AABB -> None"
+        );
+
+        assert_eq!(
+            aabb.intersect_ray(Vector3::new(0.0, 0.0, 0.0), Vector3::ONE),
+            Some(Vector3::new(2.0, 2.0, 2.0)),
+            "intersect_ray(), ray along the AABB diagonal -> Some"
+        );
+
+        assert_eq!(
+            aabb.intersect_ray(
+                aabb.position + Vector3::splat(0.0001),
+                Vector3::new(-1.0, 0.0, 0.0)
+            ),
+            Some(Vector3::new(-1.5, 2.0001, -2.4999)),
+            "intersect_ray(), ray starting on the AABB's edge -> Some"
+        );
+
+        assert_eq!(
+            aabb.intersect_ray(Vector3::new(0.0, 0.0, 0.0), Vector3::new(0.0, 1.0, 0.0)),
+            Some(Vector3::new(0.0, 2.0, 0.0)),
+            "intersect_ray(): ray has 2 axes parallel to AABB -> Some"
+        );
+    }
+
+    #[test] // Ported from Godot tests.
+    fn test_intersect_aabb() {
+        let aabb_big = Aabb {
+            position: Vector3::new(-1.5, 2.0, -2.5),
+            size: Vector3::new(4.0, 5.0, 6.0),
+        };
+
+        let aabb_small = Aabb {
+            position: Vector3::new(-1.5, 2.0, -2.5),
+            size: Vector3::ONE,
+        };
+        assert!(
+            aabb_big.intersects(aabb_small),
+            "intersects() with fully contained AABB (touching the edge) should return true."
+        );
+
+        let aabb_small = Aabb {
+            position: Vector3::new(0.5, 1.5, -2.0),
+            size: Vector3::ONE,
+        };
+        assert!(
+            aabb_big.intersects(aabb_small),
+            "intersects() with partially contained AABB (overflowing on Y axis) should return true."
+        );
+
+        let aabb_small = Aabb {
+            position: Vector3::new(10.0, -10.0, -10.0),
+            size: Vector3::ONE,
+        };
+        assert!(
+            !aabb_big.intersects(aabb_small),
+            "intersects() with non-contained AABB should return false."
+        );
+
+        let aabb_small = Aabb {
+            position: Vector3::new(-1.5, 2.0, -2.5),
+            size: Vector3::ONE,
+        };
+        let inter = aabb_big.intersection(aabb_small);
+        assert!(
+            inter.unwrap().approx_eq(&aabb_small),
+            "intersection() with fully contained AABB should return the smaller AABB."
+        );
+
+        let aabb_small = Aabb {
+            position: Vector3::new(0.5, 1.5, -2.0),
+            size: Vector3::ONE,
+        };
+        let expected = Aabb {
+            position: Vector3::new(0.5, 2.0, -2.0),
+            size: Vector3::new(1.0, 0.5, 1.0),
+        };
+        let inter = aabb_big.intersection(aabb_small);
+        assert!(
+            inter.unwrap().approx_eq(&expected),
+            "intersect() with partially contained AABB (overflowing on Y axis) should match expected."
+        );
+
+        let aabb_small = Aabb {
+            position: Vector3::new(10.0, -10.0, -10.0),
+            size: Vector3::ONE,
+        };
+        let inter = aabb_big.intersection(aabb_small);
+        assert!(
+            inter.is_none(),
+            "intersect() with non-contained AABB should return None."
+        );
+    }
+
+    #[test]
+    #[should_panic]
+    #[cfg(debug_assertions)]
+    fn test_intersect_ray_zero_dir_inside() {
+        let aabb = Aabb {
+            position: Vector3::new(-1.5, 2.0, -2.5),
+            size: Vector3::new(4.0, 5.0, 6.0),
+        };
+
+        aabb.intersect_ray(Vector3::new(-1.0, 3.0, -2.0), Vector3::ZERO);
+    }
+
+    #[test]
+    #[should_panic]
+    #[cfg(debug_assertions)]
+    fn test_intersect_ray_zero_dir_outside() {
+        let aabb = Aabb {
+            position: Vector3::new(-1.5, 2.0, -2.5),
+            size: Vector3::new(4.0, 5.0, 6.0),
+        };
+
+        aabb.intersect_ray(Vector3::new(-1000.0, 3.0, -2.0), Vector3::ZERO);
+    }
+
     #[test]
     fn test_intersects_plane() {
-        // Create an AABB
         let aabb = Aabb {
             position: Vector3::new(-1.0, -1.0, -1.0),
             size: Vector3::new(2.0, 2.0, 2.0),
         };
 
-        // Define planes for testing
         let plane_inside = Plane {
             normal: Vector3::new(1.0, 0.0, 0.0),
             d: 0.0,
@@ -655,6 +834,32 @@ mod test {
         assert!(!aabb.intersects_plane(plane_parallel));
     }
 
+    #[test] // Ported from Godot tests.
+    fn test_intersects_plane_2() {
+        let aabb_big = Aabb {
+            position: Vector3::new(-1.5, 2.0, -2.5),
+            size: Vector3::new(4.0, 5.0, 6.0),
+        };
+
+        let plane1 = Plane::new(Vector3::new(0.0, 1.0, 0.0), 4.0);
+        assert!(
+            aabb_big.intersects_plane(plane1),
+            "intersects_plane() should return true (plane near top)."
+        );
+
+        let plane2 = Plane::new(Vector3::new(0.0, -1.0, 0.0), -4.0);
+        assert!(
+            aabb_big.intersects_plane(plane2),
+            "intersects_plane() should return true (plane near bottom)."
+        );
+
+        let plane3 = Plane::new(Vector3::new(0.0, 1.0, 0.0), 200.0);
+        assert!(
+            !aabb_big.intersects_plane(plane3),
+            "intersects_plane() should return false (plane far away)."
+        );
+    }
+
     #[test]
     fn test_aabb_intersects_segment() {
         let aabb = Aabb {
@@ -672,4 +877,48 @@ mod test {
         let to = Vector3::new(-1.0, 1.0, 1.0);
         assert!(!aabb.intersects_segment(from, to));
     }
+
+    #[test] // Ported from Godot tests.
+    fn test_intersects_segment_2() {
+        let aabb = Aabb {
+            position: Vector3::new(-1.5, 2.0, -2.5),
+            size: Vector3::new(4.0, 5.0, 6.0),
+        };
+
+        // True cases.
+        assert!(
+            aabb.intersects_segment(Vector3::new(1.0, 3.0, 0.0), Vector3::new(0.0, 3.0, 0.0)),
+            "intersects_segment(), segment fully inside -> true"
+        );
+        assert!(
+            aabb.intersects_segment(Vector3::new(0.0, 3.0, 0.0), Vector3::new(0.0, -300.0, 0.0)),
+            "intersects_segment(), segment crossing the box -> true"
+        );
+        assert!(
+            aabb.intersects_segment(
+                Vector3::new(-50.0, 3.0, -50.0),
+                Vector3::new(50.0, 3.0, 50.0)
+            ),
+            "intersects_segment(), diagonal crossing the box -> true"
+        );
+
+        // False case.
+        assert!(
+            !aabb.intersects_segment(
+                Vector3::new(-50.0, 25.0, -50.0),
+                Vector3::new(50.0, 25.0, 50.0)
+            ),
+            "intersects_segment(), segment above the box -> false"
+        );
+
+        // Degenerate segments (points).
+        assert!(
+            aabb.intersects_segment(Vector3::new(0.0, 3.0, 0.0), Vector3::new(0.0, 3.0, 0.0)),
+            "intersects_segment(), segment of length 0 *inside* the box -> true"
+        );
+        assert!(
+            !aabb.intersects_segment(Vector3::new(0.0, 300.0, 0.0), Vector3::new(0.0, 300.0, 0.0)),
+            "intersects_segment(), segment of length 0 *outside* the box -> false"
+        );
+    }
 }