Revert lib changes

This partially reverts commit 240195f.

Author: TimTheBig

src/bsp.rs

@@ -1,7 +1,7 @@
 //! This module contains the implementation of the [BSP](https://en.wikipedia.org/wiki/Binary_space_partitioning) tree data structure
 
 use crate::float_types::EPSILON;
-use crate::plane::{BACK, COPLANAR, FRONT, Plane, SPANNING};
+use crate::plane::{Plane, BACK, FRONT, COPLANAR, SPANNING};
 use crate::polygon::Polygon;
 use crate::vertex::Vertex;
 use std::fmt::Debug;
@@ -15,13 +15,13 @@ pub struct Node<S: Clone> {
     /// Splitting plane for this node *or* **None** for a leaf that
     /// only stores polygons.
     pub plane: Option<Plane>,
-
+    
     /// Polygons in *front* half‑spaces.
     pub front: Option<Box<Node<S>>>,
-
+    
     /// Polygons in *back* half‑spaces.
     pub back: Option<Box<Node<S>>>,
-
+    
     /// Polygons that lie *exactly* on `plane`
     /// (after the node has been built).
     pub polygons: Vec<Polygon<S>>,
@@ -55,10 +55,10 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
         match (&mut self.front, &mut self.back) {
             (Some(front_node), Some(back_node)) => {
                 join(|| front_node.invert(), || back_node.invert());
-            },
+            }
             (Some(front_node), None) => front_node.invert(),
             (None, Some(back_node)) => back_node.invert(),
-            (None, None) => {},
+            (None, None) => {}
         }
 
         #[cfg(not(feature = "parallel"))]
@@ -219,10 +219,10 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
         match (&mut self.front, &mut self.back) {
             (Some(front_node), Some(back_node)) => {
                 join(|| front_node.clip_to(bsp), || back_node.clip_to(bsp));
-            },
+            }
             (Some(front_node), None) => front_node.clip_to(bsp),
             (None, Some(back_node)) => back_node.clip_to(bsp),
-            (None, None) => {},
+            (None, None) => {}
         }
     }
 
@@ -329,20 +329,20 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
                 let front_node = self.front.as_mut().unwrap();
                 let back_node = self.back.as_mut().unwrap();
                 join(|| front_node.build(&front), || back_node.build(&back));
-            },
+            }
             (true, false) => {
                 if self.front.is_none() {
                     self.front = Some(Box::new(Node::new(&[])));
                 }
                 self.front.as_mut().unwrap().build(&front);
-            },
+            }
             (false, true) => {
                 if self.back.is_none() {
                     self.back = Some(Box::new(Node::new(&[])));
                 }
                 self.back.as_mut().unwrap().build(&back);
-            },
-            (false, false) => {},
+            }
+            (false, false) => {}
         }
     }
 
@@ -377,11 +377,11 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
                     // Depending on normal alignment, it may be “coplanar_front” or “coplanar_back.”
                     // Usually we don’t care — we just return them as “in the plane.”
                     coplanar_polygons.push(poly.clone());
-                },
+                }
 
                 FRONT | BACK => {
                     // Entirely on one side => no intersection. We skip it.
-                },
+                }
 
                 SPANNING => {
                     // The polygon crosses the plane. We'll gather the intersection points
@@ -422,11 +422,11 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
                     }
                     // If crossing_points.len() was not a multiple of 2, you can handle leftover
                     // points or flag them as errors, etc. We'll skip that detail here.
-                },
+                }
 
                 _ => {
                     // Shouldn't happen in a typical classification, but we can ignore
-                },
+                }
             }
         }
 
@@ -463,11 +463,11 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
                     COPLANAR => {
                         // Entire polygon in plane
                         (vec![poly.clone()], Vec::new())
-                    },
+                    }
                     FRONT | BACK => {
                         // Entirely on one side => no intersection
                         (Vec::new(), Vec::new())
-                    },
+                    }
                     SPANNING => {
                         // The polygon crosses the plane => gather intersection edges
                         let mut crossing_points = Vec::new();
@@ -499,7 +499,7 @@ impl<S: Clone + Send + Sync + Debug> Node<S> {
                             edges.push([chunk[0].clone(), chunk[1].clone()]);
                         }
                         (Vec::new(), edges)
-                    },
+                    }
                     _ => (Vec::new(), Vec::new()),
                 }
             })

src/convex_hull.rs

@@ -24,7 +24,11 @@ impl<S: Clone + Debug + Send + Sync> CSG<S> {
         let points: Vec<Vec<Real>> = self
             .polygons
             .iter()
-            .flat_map(|poly| poly.vertices.iter().map(|v| vec![v.pos.x, v.pos.y, v.pos.z]))
+            .flat_map(|poly| {
+                poly.vertices
+                    .iter()
+                    .map(|v| vec![v.pos.x, v.pos.y, v.pos.z])
+            })
             .collect();
 
         // Attempt to compute the convex hull using the robust wrapper
@@ -33,7 +37,7 @@ impl<S: Clone + Debug + Send + Sync> CSG<S> {
             Err(_) => {
                 // Fallback to an empty CSG if hull generation fails
                 return CSG::new();
-            },
+            }
         };
 
         let (verts, indices) = hull.vertices_indices();