Add triangle_math tests and fix Triangle3d::bounding_sphere bug

crates/bevy_math/src/bounding/bounded3d/primitive_impls.rs

@@ -326,8 +326,9 @@ impl Bounded3d for Triangle3d {
  fn bounding_sphere(&self, translation: Vec3, rotation: Quat) -> BoundingSphere {
  if self.is_degenerate() {
  let (p1, p2) = self.largest_side();
+ let mid_point = (p1 + p2) / 2.0;
  let (segment, _) = Segment3d::from_points(p1, p2);
- return segment.bounding_sphere(translation, rotation);
+ return segment.bounding_sphere(mid_point, rotation);
  }
 
  let [a, b, c] = self.vertices;
@@ -343,8 +344,9 @@ impl Bounded3d for Triangle3d {
  };
 
  if let Some((p1, p2)) = side_opposite_to_non_acute {
- let (segment, _) = Segment3d::from_points(p1, p2);
- segment.bounding_sphere(translation, rotation)
+ let mid_point = (p1 + p2) / 2.0;
+ let radius = mid_point.distance(p1);
+ BoundingSphere::new(mid_point + translation, radius)
  } else {
  let circumcenter = self.circumcenter();
  let radius = circumcenter.distance(a);
@@ -355,13 +357,14 @@ impl Bounded3d for Triangle3d {
 
 #[cfg(test)]
 mod tests {
+ use crate::bounding::BoundingVolume;
  use glam::{Quat, Vec3, Vec3A};
 
  use crate::{
  bounding::Bounded3d,
  primitives::{
  Capsule3d, Cone, ConicalFrustum, Cuboid, Cylinder, InfinitePlane3d, Line3d, Polyline3d,
- Segment3d, Sphere, Torus,
+ Segment3d, Sphere, Torus, Triangle3d,
  },
  Dir3,
  };
@@ -607,4 +610,74 @@ mod tests {
  assert_eq!(bounding_sphere.center, translation.into());
  assert_eq!(bounding_sphere.radius(), 1.5);
  }
+
+ #[test]
+ fn triangle3d() {
+ let zero_degenerate_triangle = Triangle3d::new(Vec3::ZERO, Vec3::ZERO, Vec3::ZERO);
+
+ let br = zero_degenerate_triangle.aabb_3d(Vec3::ZERO, Quat::IDENTITY);
+ assert_eq!(
+ br.center(),
+ Vec3::ZERO.into(),
+ "incorrect bounding box center"
+ );
+ assert_eq!(
+ br.half_size(),
+ Vec3::ZERO.into(),
+ "incorrect bounding box half extents"
+ );
+
+ let dup_degenerate_triangle = Triangle3d::new(Vec3::ZERO, Vec3::X, Vec3::X);
+ let bs = dup_degenerate_triangle.bounding_sphere(Vec3::ZERO, Quat::IDENTITY);
+ assert_eq!(
+ bs.center,
+ Vec3::new(0.5, 0.0, 0.0).into(),
+ "incorrect bounding sphere center"
+ );
+ assert_eq!(bs.sphere.radius, 0.5, "incorrect bounding sphere radius");
+ let br = dup_degenerate_triangle.aabb_3d(Vec3::ZERO, Quat::IDENTITY);
+ assert_eq!(
+ br.center(),
+ Vec3::new(0.5, 0.0, 0.0).into(),
+ "incorrect bounding box center"
+ );
+ assert_eq!(
+ br.half_size(),
+ Vec3::new(0.5, 0.0, 0.0).into(),
+ "incorrect bounding box half extents"
+ );
+
+ let collinear_degenerate_triangle = Triangle3d::new(Vec3::NEG_X, Vec3::ZERO, Vec3::X);
+ let bs = collinear_degenerate_triangle.bounding_sphere(Vec3::ZERO, Quat::IDENTITY);
+ assert_eq!(
+ bs.center,
+ Vec3::ZERO.into(),
+ "incorrect bounding sphere center"
+ );
+ assert_eq!(bs.sphere.radius, 1.0, "incorrect bounding sphere radius");
+ let br = collinear_degenerate_triangle.aabb_3d(Vec3::ZERO, Quat::IDENTITY);
+ assert_eq!(
+ br.center(),
+ Vec3::ZERO.into(),
+ "incorrect bounding box center"
+ );
+ assert_eq!(
+ br.half_size(),
+ Vec3::new(1.0, 0.0, 0.0).into(),
+ "incorrect bounding box half extents"
+ );
+ }
+
+ #[test]
+ #[should_panic]
+ fn degenerate_bounding_sphere_should_panic() {
+ let zero_degenerate_triangle = Triangle3d::new(Vec3::ZERO, Vec3::ZERO, Vec3::ZERO);
+ let bs = zero_degenerate_triangle.bounding_sphere(Vec3::ZERO, Quat::IDENTITY); // DIVISION BY ZERO
+ assert_eq!(
+ bs.center,
+ Vec3::ZERO.into(),
+ "incorrect bounding sphere center"
+ );
+ assert_eq!(bs.sphere.radius, 0.0, "incorrect bounding sphere radius");
+ }
 }

crates/bevy_math/src/primitives/dim3.rs

@@ -1010,7 +1010,7 @@ mod tests {
  // Reference values were computed by hand and/or with external tools
 
  use super::*;
- use crate::Quat;
+ use crate::{InvalidDirectionError, Quat};
  use approx::assert_relative_eq;
 
  #[test]
@@ -1210,8 +1210,86 @@ mod tests {
  assert_relative_eq!(Tetrahedron::default().centroid(), Vec3::ZERO);
  }
 
+ #[test]
+ fn extrusion_math() {
+ let circle = Circle::new(0.75);
+ let cylinder = Extrusion::new(circle, 2.5);
+ assert_eq!(cylinder.area(), 15.315264, "incorrect surface area");
+ assert_eq!(cylinder.volume(), 4.417865, "incorrect volume");
+
+ let annulus = crate::primitives::Annulus::new(0.25, 1.375);
+ let tube = Extrusion::new(annulus, 0.333);
+ assert_eq!(tube.area(), 14.886437, "incorrect surface area");
+ assert_eq!(tube.volume(), 1.9124937, "incorrect volume");
+
+ let polygon = crate::primitives::RegularPolygon::new(3.8, 7);
+ let regular_prism = Extrusion::new(polygon, 1.25);
+ assert_eq!(regular_prism.area(), 107.8808, "incorrect surface area");
+ assert_eq!(regular_prism.volume(), 49.392204, "incorrect volume");
+ }
+
  #[test]
  fn triangle_math() {
+ // Default triangle tests
+ let mut default_triangle = Triangle3d::default();
+ let reverse_default_triangle = Triangle3d::new(
+ Vec3::new(0.5, -0.5, 0.0),
+ Vec3::new(-0.5, -0.5, 0.0),
+ Vec3::new(0.0, 0.5, 0.0),
+ );
+ assert_eq!(default_triangle.area(), 0.5, "incorrect area");
+ assert_relative_eq!(
+ default_triangle.perimeter(),
+ 1.0 + 2.0 * 1.25_f32.sqrt(),
+ epsilon = 10e-9
+ );
+ assert_eq!(default_triangle.normal(), Ok(Dir3::Z), "incorrect normal");
+ assert!(
+ !default_triangle.is_degenerate(),
+ "incorrect degenerate check"
+ );
+ assert_eq!(
+ default_triangle.centroid(),
+ Vec3::new(0.0, -0.16666667, 0.0),
+ "incorrect centroid"
+ );
+ assert_eq!(
+ default_triangle.largest_side(),
+ (Vec3::new(0.0, 0.5, 0.0), Vec3::new(-0.5, -0.5, 0.0))
+ );
+ default_triangle.reverse();
+ assert_eq!(
+ default_triangle, reverse_default_triangle,
+ "incorrect reverse"
+ );
+ assert_eq!(
+ default_triangle.circumcenter(),
+ Vec3::new(0.0, -0.125, 0.0),
+ "incorrect circumcenter"
+ );
+
+ // Custom triangle tests
+ let right_triangle = Triangle3d::new(Vec3::ZERO, Vec3::X, Vec3::Y);
+ let obtuse_triangle = Triangle3d::new(Vec3::NEG_X, Vec3::X, Vec3::new(0.0, 0.1, 0.0));
+ let acute_triangle = Triangle3d::new(Vec3::ZERO, Vec3::X, Vec3::new(0.5, 5.0, 0.0));
+
+ assert_eq!(
+ right_triangle.circumcenter(),
+ Vec3::new(0.5, 0.5, 0.0),
+ "incorrect circumcenter"
+ );
+ assert_eq!(
+ obtuse_triangle.circumcenter(),
+ Vec3::new(0.0, -4.95, 0.0),
+ "incorrect circumcenter"
+ );
+ assert_eq!(
+ acute_triangle.circumcenter(),
+ Vec3::new(0.5, 2.475, 0.0),
+ "incorrect circumcenter"
+ );
+
+ // Arbitrary triangle tests
  let [a, b, c] = [Vec3::ZERO, Vec3::new(1., 1., 0.5), Vec3::new(-3., 2.5, 1.)];
  let triangle = Triangle3d::new(a, b, c);
 
@@ -1233,25 +1311,53 @@ mod tests {
  "incorrect normal"
  );
 
- let degenerate = Triangle3d::new(Vec3::NEG_ONE, Vec3::ZERO, Vec3::ONE);
- assert!(degenerate.is_degenerate(), "did not find degenerate");
- }
-
- #[test]
- fn extrusion_math() {
- let circle = Circle::new(0.75);
- let cylinder = Extrusion::new(circle, 2.5);
- assert_eq!(cylinder.area(), 15.315264, "incorrect surface area");
- assert_eq!(cylinder.volume(), 4.417865, "incorrect volume");
+ // Degenerate triangle tests
+ let zero_degenerate_triangle = Triangle3d::new(Vec3::ZERO, Vec3::ZERO, Vec3::ZERO);
+ assert!(
+ zero_degenerate_triangle.is_degenerate(),
+ "incorrect degenerate check"
+ );
+ assert_eq!(
+ zero_degenerate_triangle.normal(),
+ Err(InvalidDirectionError::Zero),
+ "incorrect normal"
+ );
+ assert_eq!(
+ zero_degenerate_triangle.largest_side(),
+ (Vec3::ZERO, Vec3::ZERO),
+ "incorrect largest side"
+ );
 
- let annulus = crate::primitives::Annulus::new(0.25, 1.375);
- let tube = Extrusion::new(annulus, 0.333);
- assert_eq!(tube.area(), 14.886437, "incorrect surface area");
- assert_eq!(tube.volume(), 1.9124937, "incorrect volume");
+ let dup_degenerate_triangle = Triangle3d::new(Vec3::ZERO, Vec3::X, Vec3::X);
+ assert!(
+ dup_degenerate_triangle.is_degenerate(),
+ "incorrect degenerate check"
+ );
+ assert_eq!(
+ dup_degenerate_triangle.normal(),
+ Err(InvalidDirectionError::Zero),
+ "incorrect normal"
+ );
+ assert_eq!(
+ dup_degenerate_triangle.largest_side(),
+ (Vec3::ZERO, Vec3::X),
+ "incorrect largest side"
+ );
 
- let polygon = crate::primitives::RegularPolygon::new(3.8, 7);
- let regular_prism = Extrusion::new(polygon, 1.25);
- assert_eq!(regular_prism.area(), 107.8808, "incorrect surface area");
- assert_eq!(regular_prism.volume(), 49.392204, "incorrect volume");
+ let collinear_degenerate_triangle = Triangle3d::new(Vec3::NEG_X, Vec3::ZERO, Vec3::X);
+ assert!(
+ collinear_degenerate_triangle.is_degenerate(),
+ "incorrect degenerate check"
+ );
+ assert_eq!(
+ collinear_degenerate_triangle.normal(),
+ Err(InvalidDirectionError::Zero),
+ "incorrect normal"
+ );
+ assert_eq!(
+ collinear_degenerate_triangle.largest_side(),
+ (Vec3::NEG_X, Vec3::X),
+ "incorrect largest side"
+ );
  }
 }