continue pushing generic numeric type through the library, breaking all the things

Author: timschmidt

src/aabb.rs

@@ -6,13 +6,13 @@ pub struct Aabb<T: Scalar> {
     pub maxs: Point3<T>,
 }
 
-impl<T> Aabb<T: Scalar> {
+impl<T> Aabb<T> {
     #[inline]
     pub const fn new(mins: Point3<T>, maxs: Point3<T>) -> Self {
         Self { mins, maxs }
     }
 
-    pub fn intersects(&self, other: &Aabb) -> bool {
+    pub fn intersects(&self, other: &Aabb<T>) -> bool {
         self.max.x >= other.min.x && self.min.x <= other.max.x &&
         self.max.y >= other.min.y && self.min.y <= other.max.y &&
         self.max.z >= other.min.z && self.min.z <= other.max.z

src/io/amf.rs

@@ -10,7 +10,7 @@ use crate::math_ndsp::Point3;
 use std::fmt::Debug;
 use std::io::Write;
 
-impl<S: Clone + Debug + Send + Sync> Mesh<S> {
+impl<S: Clone + Debug + Send + Sync, T> Mesh<S, T> {
     /// Export this Mesh to AMF format as a string
     ///
     /// Creates an AMF (Additive Manufacturing File Format) file containing:
@@ -246,7 +246,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
     }
 }
 
-impl<S: Clone + Debug + Send + Sync> Sketch<S> {
+impl<S: Clone + Debug + Send + Sync, T> Sketch<S, T> {
     /// Export this Mesh to AMF format as a string
     ///
     /// Creates an AMF (Additive Manufacturing File Format) file containing:

src/io/dxf.rs

@@ -16,7 +16,7 @@ use dxf::Drawing;
 #[cfg(feature = "dxf-io")]
 use dxf::entities::*;
 
-impl<S: Clone + Debug + Send + Sync> Mesh<S> {
+impl<S: Clone + Debug + Send + Sync, T> Mesh<S, T> {
     /// Import a Mesh object from DXF data.
     ///
     /// ## Parameters
@@ -26,7 +26,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
     /// ## Returns
     /// A `Result` containing the Mesh object or an error if parsing fails.
     #[cfg(feature = "dxf-io")]
-    pub fn from_dxf(dxf_data: &[u8], metadata: Option<S>) -> Result<Mesh<S>, Box<dyn Error>> {
+    pub fn from_dxf(dxf_data: &[u8], metadata: Option<S>) -> Result<Mesh<S, T>, Box<dyn Error>> {
         // Load the DXF drawing from the provided data
         let drawing = Drawing::load(&mut Cursor::new(dxf_data))?;
 

src/io/obj.rs

@@ -13,7 +13,7 @@ use crate::math_ndsp::{Point3, Vector3};
 use std::fmt::Debug;
 use std::io::{BufRead, Write};
 
-impl<S: Clone + Debug + Send + Sync> Mesh<S> {
+impl<S: Clone + Debug + Send + Sync, T> Mesh<S, T> {
     /// Export this Mesh to OBJ format as a string
     ///
     /// Creates a Wavefront OBJ file containing:
@@ -142,7 +142,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
     /// # Ok(())
     /// # }
     /// ```
-    pub fn from_obj<R: BufRead>(reader: R, metadata: Option<S>) -> std::io::Result<Mesh<S>> {
+    pub fn from_obj<R: BufRead>(reader: R, metadata: Option<S>) -> std::io::Result<Mesh<S, T>> {
         let mut vertices = Vec::new();
         let mut normals = Vec::new();
         let mut polygons = Vec::new();
@@ -295,7 +295,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
     }
 }
 
-impl<S: Clone + Debug + Send + Sync> Sketch<S> {
+impl<S: Clone + Debug + Send + Sync, T> Sketch<S, T> {
     /// Export this Mesh to OBJ format as a string
     ///
     /// Creates a Wavefront OBJ file containing:

src/io/ply.rs

@@ -18,7 +18,7 @@ struct PlyVertex {
     normal: Vector3<Real>,
 }
 
-impl<S: Clone + Debug + Send + Sync> Mesh<S> {
+impl<S: Clone + Debug + Send + Sync, T> Mesh<S, T> {
     /// Export this Mesh to PLY format as a string
     ///
     /// Creates a Stanford PLY file containing:
@@ -121,7 +121,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
     }
 }
 
-impl<S: Clone + Debug + Send + Sync> Sketch<S> {
+impl<S: Clone + Debug + Send + Sync, T> Sketch<S, T> {
     /// Export this Sketch to PLY format as a string
     ///
     /// Creates a Stanford PLY file containing:

src/io/stl.rs

@@ -12,7 +12,7 @@ use core2::io::Cursor;
 
 use stl_io;
 
-impl<S: Clone + Debug + Send + Sync> Mesh<S> {
+impl<S: Clone + Debug + Send + Sync, T> Mesh<S, T> {
     /// Export to ASCII STL
     /// Convert this Mesh to an **ASCII STL** string with the given `name`.
     ///
@@ -117,7 +117,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
 
     /// Create a Mesh object from STL data using 'stl_io'.
     #[cfg(feature = "stl-io")]
-    pub fn from_stl(stl_data: &[u8], metadata: Option<S>) -> Result<Mesh<S>, std::io::Error> {
+    pub fn from_stl(stl_data: &[u8], metadata: Option<S>) -> Result<Mesh<S, T>, std::io::Error> {
         // Create an in-memory cursor from the STL data
         let mut cursor = Cursor::new(stl_data);
 
@@ -176,7 +176,7 @@ impl<S: Clone + Debug + Send + Sync> Mesh<S> {
     }
 }
 
-impl<S: Clone + Debug + Send + Sync> Sketch<S> {
+impl<S: Clone + Debug + Send + Sync, T> Sketch<S, T> {
     /// Export to ASCII STL
     /// Convert this Sketch to an **ASCII STL** string with the given 'name'.
     ///

src/io/svg.rs

@@ -539,7 +539,7 @@ pub trait ToSVG {
     fn to_svg(&self) -> String;
 }
 
-impl<S: Clone> ToSVG for Sketch<S> {
+impl<S: Clone, T> ToSVG for Sketch<S, T> {
     fn to_svg(&self) -> String {
         use geo::Geometry::*;
         use svg::node::element;

src/math_ndsp.rs

@@ -1129,7 +1129,7 @@ impl<T: Scalar> Rotation3<T> {
 
     /// Create a rotation from an (optionally non-unit) axis and angle (radians).
     /// Matches nalgebra’s `Rotation3::from_axis_angle`.
-    pub fn from_axis_angle(axis: &Vector3, angle: T) -> Self {
+    pub fn from_axis_angle(axis: &Vector3<T>, angle: T) -> Self {
         let mut k = *axis;
         let n2 = k.dot(&k);
         if n2 <= consts::EPSILON * consts::EPSILON {
@@ -1161,7 +1161,7 @@ impl<T: Scalar> Rotation3<T> {
 
     /// Small, numerically robust equivalent of nalgebra’s `rotation_between`.
     /// Returns `None` if an input is near-zero length.
-    pub fn rotation_between(a: &Vector3, b: &Vector3) -> Option<Self> {
+    pub fn rotation_between(a: &Vector3<T>, b: &Vector3<T>) -> Option<Self> {
         let la = a.norm();
         let lb = b.norm();
         if la <= consts::EPSILON || lb <= consts::EPSILON {
@@ -1203,17 +1203,17 @@ impl<T: Scalar> Rotation3<T> {
     }
 }
 
-impl core::ops::Mul for Rotation3 {
-    type Output = Rotation3;
+impl<T> core::ops::Mul for Rotation3<T> {
+    type Output = Rotation3<T>;
     #[inline]
-    fn mul(self, rhs: Rotation3) -> Rotation3 {
+    fn mul(self, rhs: Rotation3<T>) -> Rotation3<T> {
         Rotation3 { mat: self.mat * rhs.mat }
     }
 }
 
 impl<T: Scalar> From<Matrix3<T>> for Rotation3<T> {
     #[inline]
-    fn from(mat: Matrix3) -> Self { Self { mat } }
+    fn from(mat: Matrix3<T>) -> Self { Self { mat } }
 }
 
 // ------------------------------------------------------------
@@ -1236,7 +1236,7 @@ impl<T: Scalar> Translation3<T> {
 
     /// Matches nalgebra’s `Translation3::from(Vector3)`.
     #[inline]
-    pub fn from(v: Vector3) -> Self {
+    pub fn from(v: Vector3<T>) -> Self {
         Self { v }
     }
 
@@ -1248,7 +1248,7 @@ impl<T: Scalar> Translation3<T> {
 
 impl<T: Scalar> From<Vector3<T>> for Translation3<T> {
     #[inline]
-    fn from(v: Vector3) -> Self { Self { v } }
+    fn from(v: Vector3<T>) -> Self { Self { v } }
 }
 
 // ------------------------------------------------------------
@@ -1259,7 +1259,7 @@ pub struct Isometry3<T> {
     pub rotation: Rotation3<T>,
 }
 
-impl Isometry3 {
+impl<T> Isometry3<T> {
     #[inline]
     pub fn identity() -> Self {
         Self { translation: Translation3::identity(),
@@ -1268,15 +1268,15 @@ impl Isometry3 {
 
     /// Keep nalgebra’s call site working: `Isometry3::from_parts(Translation3, rot.into())`.
     #[inline]
-    pub fn from_parts<R>(translation: Translation3, rotation: R) -> Self
+    pub fn from_parts<R>(translation: Translation3<T>, rotation: R) -> Self
     where
         R: Into<Rotation3>,
     {
         Self { translation, rotation: rotation.into() }
     }
 
     #[inline]
-    pub fn to_homogeneous(&self) -> Matrix4 {
+    pub fn to_homogeneous(&self) -> Matrix4<T> {
         Matrix4::from_rotation_translation(self.rotation.mat, self.translation.v)
     }
 
@@ -1290,7 +1290,7 @@ impl Isometry3 {
 
     /// Vector transform (ignores translation): v' = R·v
     #[inline]
-    pub fn transform_vector(&self, v: &Vector3) -> Vector3 {
+    pub fn transform_vector(&self, v: &Vector3<T>) -> Vector3<T> {
         self.rotation.mat * *v
     }
 }

src/mesh/bsp.rs

@@ -13,29 +13,29 @@ use std::fmt::Debug;
 
 /// A [BSP](https://en.wikipedia.org/wiki/Binary_space_partitioning) tree node, containing polygons plus optional front/back subtrees
 #[derive(Debug, Clone)]
-pub struct Node<S: Clone> {
+pub struct Node<S: Clone, T> {
     /// Splitting plane for this node *or* **None** for a leaf that
     /// only stores polygons.
-    pub plane: Option<Plane>,
+    pub plane: Option<Plane<T>>,
 
     /// Polygons in *front* half‑spaces.
-    pub front: Option<Box<Node<S>>>,
+    pub front: Option<Box<Node<S, T>>>,
 
     /// Polygons in *back* half‑spaces.
-    pub back: Option<Box<Node<S>>>,
+    pub back: Option<Box<Node<S, T>>>,
 
     /// Polygons that lie *exactly* on `plane`
     /// (after the node has been built).
     pub polygons: Vec<Polygon<S, T>>,
 }
 
-impl<S: Clone + Send + Sync + Debug> Default for Node<S> {
+impl<S: Clone + Send + Sync + Debug, T> Default for Node<S, T> {
     fn default() -> Self {
         Self::new()
     }
 }
 
-impl<S: Clone + Send + Sync + Debug> Node<S> {
+impl<S: Clone + Send + Sync + Debug, T> Node<S, T> {
     /// Create a new empty BSP node
     pub const fn new() -> Self {
         Self {
@@ -47,7 +47,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
     }
 
     /// Creates a new BSP node from polygons
-    pub fn from_polygons(polygons: &[Polygon<S>]) -> Self {
+    pub fn from_polygons(polygons: &[Polygon<S, T>]) -> Self {
         let mut node = Self::new();
         if !polygons.is_empty() {
             node.build(polygons);
@@ -74,7 +74,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
         std::mem::swap(&mut self.front, &mut self.back);
     }
 
-    pub fn pick_best_splitting_plane(&self, polygons: &[Polygon<S>]) -> Plane {
+    pub fn pick_best_splitting_plane(&self, polygons: &[Polygon<S, T>]) -> Plane<T> {
         const K_SPANS: Real = 8.0; // Weight for spanning polygons
         const K_BALANCE: Real = 1.0; // Weight for front/back balance
 
@@ -115,7 +115,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
     /// Polygons entirely in BACK half-space are clipped (removed).
     /// **Algorithm**: O(n log d) where n is polygon count, d is tree depth.
     #[cfg(not(feature = "parallel"))]
-    pub fn clip_polygons(&self, polygons: &[Polygon<S>]) -> Vec<Polygon<S>> {
+    pub fn clip_polygons(&self, polygons: &[Polygon<S, T>]) -> Vec<Polygon<S, T>> {
         // If this node has no plane (i.e. it’s empty), just return
         if self.plane.is_none() {
             return polygons.to_vec();
@@ -161,7 +161,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
 
     /// Remove all polygons in this BSP tree that are inside the other BSP tree
     #[cfg(not(feature = "parallel"))]
-    pub fn clip_to(&mut self, bsp: &Node<S>) {
+    pub fn clip_to(&mut self, bsp: &Node<S, T>) {
         self.polygons = bsp.clip_polygons(&self.polygons);
         if let Some(ref mut front) = self.front {
             front.clip_to(bsp);
@@ -173,7 +173,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
 
     /// Return all polygons in this BSP tree using an iterative approach,
     /// avoiding potential stack overflow of recursive approach
-    pub fn all_polygons(&self) -> Vec<Polygon<S>> {
+    pub fn all_polygons(&self) -> Vec<Polygon<S, T>> {
         let mut result = Vec::new();
         let mut stack = vec![self];
 
@@ -192,7 +192,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
 
     /// Build a BSP tree from the given polygons
     #[cfg(not(feature = "parallel"))]
-    pub fn build(&mut self, polygons: &[Polygon<S>]) {
+    pub fn build(&mut self, polygons: &[Polygon<S, T>]) {
         if polygons.is_empty() {
             return;
         }
@@ -238,7 +238,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
     /// - All polygons that are coplanar with the plane (within EPSILON),
     /// - A list of line‐segment intersections (each a [Vertex; 2]) from polygons that span the plane.
     #[cfg(not(feature = "parallel"))]
-    pub fn slice(&self, slicing_plane: &Plane) -> (Vec<Polygon<S>>, Vec<[Vertex; 2]>) {
+    pub fn slice(&self, slicing_plane: &Plane<T>) -> (Vec<Polygon<S, T>>, Vec<[Vertex; 2]>) {
         let all_polys = self.all_polygons();
 
         let mut coplanar_polygons = Vec::new();

src/mesh/connectivity.rs

@@ -62,7 +62,7 @@ impl VertexIndexMap {
     }
 }
 
-impl<S: Clone + Debug + Send + Sync> Mesh<S> {
+impl<S: Clone + Debug + Send + Sync, T> Mesh<S, T> {
     /// **Mathematical Foundation: Robust Mesh Connectivity Analysis**
     ///
     /// Build a proper vertex adjacency graph using epsilon-based vertex matching: