begin converting EPSILON

Author: timschmidt

src/main.rs

@@ -5,7 +5,6 @@
 use csgrs::mesh::plane::Plane;
 use csgrs::traits::CSG;
 use crate::math_ndsp::{Point3, Vector3};
-use crate::math_ndsp::consts{Real};
 
 use std::fs;
 

src/math_ndsp.rs

@@ -38,17 +38,33 @@ impl<T> Scalar for T where
 {}
 
 /// A small generic epsilon helper
-#[inline]
-fn eps<T: Scalar>() -> T { T::mixed_from(1e-9) }
+#[inline] pub fn eps<T: Scalar>() -> T { T::mixed_from(1e-9) }
+#[inline] pub fn zero<T: Scalar>() -> T { T::mixed_zero() }
+#[inline] pub fn one<T: Scalar>()  -> T { T::mixed_one() }
+#[inline] pub fn two<T: Scalar>()  -> T { T::mixed_from(2.0) }
+#[inline] pub fn deg_to_rad<T: Scalar>(deg: T) -> T {
+    deg * (T::mixed_pi() / T::mixed_from(180.0))
+}
 
-pub mod consts {
-    // We keep the library on f64 for now (simple migration).
-    pub type Real = f64;
+// Integer power (avoid `.powi()` calls)
+#[inline] pub fn powi<T: Scalar>(mut x: T, mut e: i32) -> T {
+    if e == 0 { return one() }
+    let mut base = x;
+    let mut acc = one();
+    let neg = e < 0;
+    if neg { e = -e; }
+    while e > 0 { if (e & 1) != 0 { acc = acc * base; } base = base * base; e >>= 1; }
+    if neg { one::<T>() / acc } else { acc }
+}
+
+// Generic min/max (avoid f64::min/max and NaN surprises)
+#[inline] pub fn min<T: Scalar + PartialOrd>(a: T, b: T) -> T { if a <= b { a } else { b } }
+#[inline] pub fn max<T: Scalar + PartialOrd>(a: T, b: T) -> T { if a >= b { a } else { b } }
 
-    pub const EPSILON: Real     = 1.0e-8;
-    pub const PI: Real          = core::f64::consts::PI;
-    pub const TAU: Real         = core::f64::consts::TAU;
-    pub const FRAC_PI_2: Real   = core::f64::consts::FRAC_PI_2;
+pub mod consts {
+    pub const PI: f64          = core::f64::consts::PI;
+    pub const TAU: f64         = core::f64::consts::TAU;
+    pub const FRAC_PI_2: f64   = core::f64::consts::FRAC_PI_2;
 }
 
 /* ----------------------------- Vector2 / Point2 ----------------------------- */

src/tests.rs

@@ -1,5 +1,5 @@
 use crate::errors::ValidationError;
-use crate::math_ndsp::consts::{EPSILON, FRAC_PI_2, PI, Real};
+use crate::math_ndsp::consts::{FRAC_PI_2, PI};
 use crate::mesh::Mesh;
 use crate::mesh::bsp::Node;
 use crate::mesh::plane::Plane;
@@ -178,12 +178,12 @@ fn test_vertex_interpolate() {
     let v1 = Vertex::new(Point3::origin(), Vector3::x());
     let v2 = Vertex::new(Point3::new(2.0, 2.0, 2.0), Vector3::y());
     let v_mid = v1.interpolate(&v2, 0.5);
-    assert!(approx_eq(v_mid.pos.x, 1.0, EPSILON));
-    assert!(approx_eq(v_mid.pos.y, 1.0, EPSILON));
-    assert!(approx_eq(v_mid.pos.z, 1.0, EPSILON));
-    assert!(approx_eq(v_mid.normal.x, 0.5, EPSILON));
-    assert!(approx_eq(v_mid.normal.y, 0.5, EPSILON));
-    assert!(approx_eq(v_mid.normal.z, 0.0, EPSILON));
+    assert!(approx_eq(v_mid.pos.x, 1.0, eps::<T>()));
+    assert!(approx_eq(v_mid.pos.y, 1.0, eps::<T>()));
+    assert!(approx_eq(v_mid.pos.z, 1.0, eps::<T>()));
+    assert!(approx_eq(v_mid.normal.x, 0.5, eps::<T>()));
+    assert!(approx_eq(v_mid.normal.y, 0.5, eps::<T>()));
+    assert!(approx_eq(v_mid.normal.z, 0.0, eps::<T>()));
 }
 
 // ------------------------------------------------------------
@@ -229,11 +229,11 @@ fn test_plane_split_polygon() {
 
     // Quick check: all front vertices should have y >= 0 (within an epsilon).
     for v in &front_poly.vertices {
-        assert!(v.pos.y >= -EPSILON);
+        assert!(v.pos.y >= -eps::<T>());
     }
     // All back vertices should have y <= 0 (within an epsilon).
     for v in &back_poly.vertices {
-        assert!(v.pos.y <= EPSILON);
+        assert!(v.pos.y <= eps::<T>());
     }
 }
 
@@ -251,9 +251,9 @@ fn test_polygon_new() {
     assert_eq!(poly.vertices.len(), 3);
     assert_eq!(poly.metadata, None);
     // Plane normal should be +Z for the above points
-    assert!(approx_eq(poly.plane.normal().x, 0.0, EPSILON));
-    assert!(approx_eq(poly.plane.normal().y, 0.0, EPSILON));
-    assert!(approx_eq(poly.plane.normal().z, 1.0, EPSILON));
+    assert!(approx_eq(poly.plane.normal().x, 0.0, eps::<T>()));
+    assert!(approx_eq(poly.plane.normal().y, 0.0, eps::<T>()));
+    assert!(approx_eq(poly.plane.normal().z, 1.0, eps::<T>()));
 }
 
 #[test]
@@ -273,17 +273,17 @@ fn test_polygon_flip() {
     assert!(approx_eq(
         poly.plane.normal().x,
         -plane_normal_before.x,
-        EPSILON
+        eps::<T>()
     ));
     assert!(approx_eq(
         poly.plane.normal().y,
         -plane_normal_before.y,
-        EPSILON
+        eps::<T>()
     ));
     assert!(approx_eq(
         poly.plane.normal().z,
         -plane_normal_before.z,
-        EPSILON
+        eps::<T>()
     ));
 }
 
@@ -339,11 +339,11 @@ fn test_polygon_recalc_plane_and_normals() {
         None,
     );
     poly.set_new_normal();
-    assert!(approx_eq(poly.plane.normal().z, 1.0, EPSILON));
+    assert!(approx_eq(poly.plane.normal().z, 1.0, eps::<T>()));
     for v in &poly.vertices {
-        assert!(approx_eq(v.normal.x, 0.0, EPSILON));
-        assert!(approx_eq(v.normal.y, 0.0, EPSILON));
-        assert!(approx_eq(v.normal.z, 1.0, EPSILON));
+        assert!(approx_eq(v.normal.x, 0.0, eps::<T>()));
+        assert!(approx_eq(v.normal.y, 0.0, eps::<T>()));
+        assert!(approx_eq(v.normal.z, 1.0, eps::<T>()));
     }
 }
 
@@ -385,9 +385,9 @@ fn test_node_invert() {
     node.invert();
     // The plane normal should be flipped, polygons should be flipped, and front/back swapped (they were None).
     let flipped_normal = node.plane.as_ref().unwrap().normal();
-    assert!(approx_eq(flipped_normal.x, -original_normal.x, EPSILON));
-    assert!(approx_eq(flipped_normal.y, -original_normal.y, EPSILON));
-    assert!(approx_eq(flipped_normal.z, -original_normal.z, EPSILON));
+    assert!(approx_eq(flipped_normal.x, -original_normal.x, eps::<T>()));
+    assert!(approx_eq(flipped_normal.y, -original_normal.y, eps::<T>()));
+    assert!(approx_eq(flipped_normal.z, -original_normal.z, eps::<T>()));
     // We shouldn't lose polygons by inverting
     assert_eq!(node.polygons.len(), original_count);
     // If we invert back, we should get the same geometry
@@ -590,10 +590,10 @@ fn test_csg_intersect() {
     // The intersection bounding box should be smaller than or equal to each
     let bb_cube = c1.bounding_box();
     let bb_sphere = c2.bounding_box();
-    assert!(bb_isect.mins.x >= bb_cube.mins.x - EPSILON);
-    assert!(bb_isect.mins.x >= bb_sphere.mins.x - EPSILON);
-    assert!(bb_isect.maxs.x <= bb_cube.maxs.x + EPSILON);
-    assert!(bb_isect.maxs.x <= bb_sphere.maxs.x + EPSILON);
+    assert!(bb_isect.mins.x >= bb_cube.mins.x - eps::<T>());
+    assert!(bb_isect.mins.x >= bb_sphere.mins.x - eps::<T>());
+    assert!(bb_isect.maxs.x <= bb_cube.maxs.x + eps::<T>());
+    assert!(bb_isect.maxs.x <= bb_sphere.maxs.x + eps::<T>());
 }
 
 #[test]
@@ -630,17 +630,17 @@ fn test_csg_inverse() {
     assert!(approx_eq(
         orig_poly.plane.normal().x,
         -inv_poly.plane.normal().x,
-        EPSILON
+        eps::<T>()
     ));
     assert!(approx_eq(
         orig_poly.plane.normal().y,
         -inv_poly.plane.normal().y,
-        EPSILON
+        eps::<T>()
     ));
     assert!(approx_eq(
         orig_poly.plane.normal().z,
         -inv_poly.plane.normal().z,
-        EPSILON
+        eps::<T>()
     ));
     assert_eq!(
         c1.polygons.len(),
@@ -657,8 +657,8 @@ fn test_csg_cube() {
     assert_eq!(c.polygons.len(), 6);
     // Check bounding box
     let bb = c.bounding_box();
-    assert!(approx_eq(bb.mins.x, 0.0, EPSILON));
-    assert!(approx_eq(bb.maxs.x, 2.0, EPSILON));
+    assert!(approx_eq(bb.mins.x, 0.0, eps::<T>()));
+    assert!(approx_eq(bb.maxs.x, 2.0, eps::<T>()));
 }
 
 // --------------------------------------------------------
@@ -731,15 +731,15 @@ fn test_csg_transform_translate_rotate_scale() {
 
     // Quick bounding box checks
     let bb_t = translated.bounding_box();
-    assert!(approx_eq(bb_t.mins.x, -1.0 + 1.0, EPSILON));
-    assert!(approx_eq(bb_t.mins.y, -1.0 + 2.0, EPSILON));
-    assert!(approx_eq(bb_t.mins.z, -1.0 + 3.0, EPSILON));
+    assert!(approx_eq(bb_t.mins.x, -1.0 + 1.0, eps::<T>()));
+    assert!(approx_eq(bb_t.mins.y, -1.0 + 2.0, eps::<T>()));
+    assert!(approx_eq(bb_t.mins.z, -1.0 + 3.0, eps::<T>()));
 
     let bb_s = scaled.bounding_box();
-    assert!(approx_eq(bb_s.mins.x, -2.0, EPSILON)); // scaled by 2 in X
-    assert!(approx_eq(bb_s.maxs.x, 2.0, EPSILON));
-    assert!(approx_eq(bb_s.mins.y, -1.0, EPSILON));
-    assert!(approx_eq(bb_s.maxs.y, 1.0, EPSILON));
+    assert!(approx_eq(bb_s.mins.x, -2.0, eps::<T>())); // scaled by 2 in X
+    assert!(approx_eq(bb_s.maxs.x, 2.0, eps::<T>()));
+    assert!(approx_eq(bb_s.mins.y, -1.0, eps::<T>()));
+    assert!(approx_eq(bb_s.maxs.y, 1.0, eps::<T>()));
 
     // For rotated, let's just check one polygon's vertices to see if z got mapped to y, etc.
     // (A thorough check would be more geometry-based.)
@@ -760,8 +760,8 @@ fn test_csg_mirror() {
     let mirror_x = c.mirror(plane_x);
     let bb_mx = mirror_x.bounding_box();
     // The original cube was from x=0..2, so mirrored across X=0 should be -2..0
-    assert!(approx_eq(bb_mx.mins.x, -2.0, EPSILON));
-    assert!(approx_eq(bb_mx.maxs.x, 0.0, EPSILON));
+    assert!(approx_eq(bb_mx.mins.x, -2.0, eps::<T>()));
+    assert!(approx_eq(bb_mx.maxs.x, 0.0, eps::<T>()));
 }
 
 #[test]
@@ -810,9 +810,9 @@ fn test_csg_renormalize() {
     // Now each polygon's vertices should match the plane's normal
     for poly in &cube.polygons {
         for v in &poly.vertices {
-            assert!(approx_eq(v.normal.x, poly.plane.normal().x, EPSILON));
-            assert!(approx_eq(v.normal.y, poly.plane.normal().y, EPSILON));
-            assert!(approx_eq(v.normal.z, poly.plane.normal().z, EPSILON));
+            assert!(approx_eq(v.normal.x, poly.plane.normal().x, eps::<T>()));
+            assert!(approx_eq(v.normal.y, poly.plane.normal().y, eps::<T>()));
+            assert!(approx_eq(v.normal.z, poly.plane.normal().z, eps::<T>()));
         }
     }
 }
@@ -827,8 +827,8 @@ fn test_csg_ray_intersections() {
     // Expect 2 intersections with the cube's side at x=-1 and x=1
     assert_eq!(hits.len(), 2);
     // The distances should be 1 unit from -2.0 -> -1 => t=1, and from -2.0 -> +1 => t=3
-    assert!(approx_eq(hits[0].1, 1.0, EPSILON));
-    assert!(approx_eq(hits[1].1, 3.0, EPSILON));
+    assert!(approx_eq(hits[0].1, 1.0, eps::<T>()));
+    assert!(approx_eq(hits[1].1, 3.0, eps::<T>()));
 }
 
 #[test]
@@ -871,8 +871,8 @@ fn test_csg_extrude() {
     assert_eq!(extruded.polygons.len(), 8);
     // Check bounding box
     let bb = extruded.bounding_box();
-    assert!(approx_eq(bb.mins.z, 0.0, EPSILON));
-    assert!(approx_eq(bb.maxs.z, 5.0, EPSILON));
+    assert!(approx_eq(bb.mins.z, 0.0, eps::<T>()));
+    assert!(approx_eq(bb.maxs.z, 5.0, eps::<T>()));
 }
 
 #[test]
@@ -982,7 +982,7 @@ fn test_csg_to_rigid_body() {
     );
     let rb = rb_set.get(handle).unwrap();
     let pos = rb.translation();
-    assert!(approx_eq(pos.x, 10.0, EPSILON));
+    assert!(approx_eq(pos.x, 10.0, eps::<T>()));
 }
 
 #[test]
@@ -1515,8 +1515,8 @@ fn test_union_of_extruded_shapes() {
 
     // Its bounding box should span at least from z=0 to z=1.5
     let bbox = unioned.bounding_box();
-    assert!(bbox.mins.z <= 0.0 + EPSILON);
-    assert!(bbox.maxs.z >= 1.5 - EPSILON);
+    assert!(bbox.mins.z <= 0.0 + eps::<T>());
+    assert!(bbox.maxs.z >= 1.5 - eps::<T>());
 }
 
 #[test]
@@ -1537,7 +1537,7 @@ fn test_flatten_cube() {
     let bbox = flattened.bounding_box();
     let thickness = bbox.maxs.z - bbox.mins.z;
     assert!(
-        thickness.abs() < EPSILON,
+        thickness.abs() < eps::<T>(),
         "Flattened shape should have negligible thickness in z"
     );
 }

src/traits.rs

@@ -1,7 +1,6 @@
 use crate::aabb::Aabb;
-use crate::math_ndsp::consts::{Real, EPSILON};
 use crate::mesh::plane::Plane;
-use crate::math_ndsp::{Matrix3, Matrix4, Rotation3, Translation3, Vector3, Scalar};
+use crate::math_ndsp::{Matrix3, Matrix4, Rotation3, Translation3, Vector3, Scalar, eps};
 
 /// Boolean operations + transformations
 pub trait CSG: Sized + Clone {
@@ -120,7 +119,7 @@ pub trait CSG: Sized + Clone {
     fn mirror(&self, plane: Plane<T>) -> Self {
         // Normal might not be unit, so compute its length:
         let len = plane.normal().norm();
-        if len.abs() < EPSILON {
+        if len.abs() < eps::<T>() {
             // Degenerate plane? Just return clone (no transform)
             return self.clone();
         }