implement From for Mesh and BMesh

Author: timschmidt

src/bmesh/mod.rs

@@ -17,6 +17,7 @@ use boolmesh::{
 
 use nalgebra::{Matrix4, Point3};
 use std::{fmt::Debug, sync::OnceLock};
+use crate::mesh::Mesh;
 
 /// A solid represented by boolmesh’s `Manifold`, wired into csgrs’ `CSG` trait.
 ///
@@ -247,3 +248,47 @@ impl<S: Clone + Send + Sync + Debug> CSG for BMesh<S> {
     }
 }
 
+impl<S: Clone + Send + Sync + Debug> From<Mesh<S>> for BMesh<S> {
+    fn from(mesh: Mesh<S>) -> Self {
+        // Keep the metadata from the original mesh
+        let metadata = mesh.metadata.clone();
+
+        // Triangulate the mesh (this also fixes T-junctions etc. via your existing code)
+        let tri_mesh = mesh.triangulate();
+
+        // Extract vertices and triangle indices from the triangulated mesh
+        let (vertices, indices) = tri_mesh.get_vertices_and_indices();
+
+        // Flatten vertices into boolmesh's `Vec<Real>` layout: [x0, y0, z0, x1, y1, z1, ...]
+        let mut pos_bool: Vec<boolmesh::Real> = Vec::with_capacity(vertices.len() * 3);
+        for v in &vertices {
+            pos_bool.push(v.x as boolmesh::Real);
+            pos_bool.push(v.y as boolmesh::Real);
+            pos_bool.push(v.z as boolmesh::Real);
+        }
+
+        // Flatten triangle indices into `Vec<usize>`
+        let mut idx_bool: Vec<usize> = Vec::with_capacity(indices.len() * 3);
+        for tri in &indices {
+            idx_bool.push(tri[0] as usize);
+            idx_bool.push(tri[1] as usize);
+            idx_bool.push(tri[2] as usize);
+        }
+
+        // If there are no triangles, treat as empty BMesh
+        let manifold = if idx_bool.is_empty() {
+            None
+        } else {
+            Some(
+                Manifold::new(&pos_bool, &idx_bool)
+                    .expect("boolmesh::Manifold::new failed when converting from Mesh"),
+            )
+        };
+
+        BMesh {
+            manifold,
+            bounding_box: OnceLock::new(),
+            metadata,
+        }
+    }
+}

src/mesh/mod.rs

@@ -26,6 +26,7 @@ use std::{
     num::NonZeroU32,
     sync::OnceLock,
 };
+use crate::bmesh::BMesh;
 
 #[cfg(feature = "parallel")]
 use rayon::{iter::IntoParallelRefIterator, prelude::*};
@@ -1169,3 +1170,52 @@ impl<S: Clone + Send + Sync + Debug> From<Sketch<S>> for Mesh<S> {
         }
     }
 }
+
+impl<S: Clone + Send + Sync + Debug> From<BMesh<S>> for Mesh<S> {
+    fn from(bmesh: BMesh<S>) -> Self {
+        // Empty BMesh -> empty Mesh
+        let Some(manifold) = bmesh.manifold else {
+            return Mesh::<S>::new();
+        };
+
+        // Convert boolmesh vertices (glam) into nalgebra points
+        let mut points: Vec<Point3<Real>> = Vec::with_capacity(manifold.ps.len());
+        for p in &manifold.ps {
+            points.push(Point3::new(p.x as Real, p.y as Real, p.z as Real));
+        }
+
+        // Each 3 half-edges in hs correspond to 1 triangle face
+        let mut polygons: Vec<Polygon<S>> = Vec::with_capacity(manifold.hs.len() / 3);
+
+        for halfs in manifold.hs.chunks_exact(3) {
+            let i0 = halfs[0].tail;
+            let i1 = halfs[1].tail;
+            let i2 = halfs[2].tail;
+
+            // Safeguard against invalid indices
+            if i0 >= points.len() || i1 >= points.len() || i2 >= points.len() {
+                continue;
+            }
+
+            let p0 = points[i0];
+            let p1 = points[i1];
+            let p2 = points[i2];
+
+            // Compute triangle normal
+            let e1: Vector3<Real> = p1 - p0;
+            let e2: Vector3<Real> = p2 - p0;
+            let mut n = e1.cross(&e2);
+            if let Some(unit) = n.try_normalize(1e-12) {
+                n = unit;
+            }
+
+            let v0 = Vertex::new(p0, n);
+            let v1 = Vertex::new(p1, n);
+            let v2 = Vertex::new(p2, n);
+
+            polygons.push(Polygon::new(vec![v0, v1, v2], bmesh.metadata.clone()));
+        }
+
+        Mesh::from_polygons(&polygons, bmesh.metadata.clone())
+    }
+}