feat: improvements

bampy/src/lib.rs

@@ -1,46 +1,49 @@
-use bvh::{aabb::Bounded, bvh::Bvh};
-use nalgebra::Point;
+use std::collections::LinkedList;
+
+use nalgebra::{vector, Vector3};
 use wasm_bindgen::prelude::wasm_bindgen;
 
-use crate::slicer::{base_slices, SlicerOptions, Triangle};
+use crate::slicer::{
+    base_slices::create_base_slices, split_surface::split_surface, Mesh, SlicerOptions, Triangle,
+};
 
 mod slicer;
 mod util;
 
+const BED_NORMAL: Vector3<f32> = vector![0f32, 0f32, 1f32];
+
 #[wasm_bindgen]
-pub fn slice(positions: &[f32], face_normals: &[f32], layer_height: f32) {
-    debug_assert_eq!(positions.len() % 9, 0);
-    debug_assert_eq!(face_normals.len() % 3, 0);
-    debug_assert_eq!(positions.len() / 9, face_normals.len() / 3);
+pub fn slice(positions: &[f32], layer_height: f32, max_angle: f32) {
+    std::panic::set_hook(Box::new(console_error_panic_hook::hook));
 
-    let mut triangles = Vec::with_capacity(positions.len() / 9);
+    assert_eq!(positions.len() % 9, 0);
+
+    let mut surface_triangles = LinkedList::<Triangle<f32>>::new();
+    let mut slicable_triangles = Vec::with_capacity(positions.len() / 9);
     for i in (0..positions.len()).step_by(9) {
-        let triangle = Triangle {
-            a: Point::<f32, 3>::new(positions[i], positions[i + 1], positions[i + 2]),
-            b: Point::<f32, 3>::new(positions[i + 3], positions[i + 4], positions[i + 5]),
-            c: Point::<f32, 3>::new(positions[i + 6], positions[i + 7], positions[i + 8]),
-            normal: Point::<f32, 3>::new(
-                face_normals[i / 9],
-                face_normals[i / 9 + 1],
-                face_normals[i / 9 + 2],
-            ),
-            node_index: 0,
-        };
-        triangles.push(triangle);
-    }
+        let triangle = Triangle::new(
+            vector![positions[i], positions[i + 1], positions[i + 2]],
+            vector![positions[i + 3], positions[i + 4], positions[i + 5]],
+            vector![positions[i + 6], positions[i + 7], positions[i + 8]],
+        );
 
-    let mut aabb = triangles[0].aabb();
-    for triangle in &triangles {
-        aabb.grow_mut(&triangle.a);
-        aabb.grow_mut(&triangle.b);
-        aabb.grow_mut(&triangle.c);
+        if triangle.normal.angle(&BED_NORMAL) > max_angle {
+            slicable_triangles.push(triangle);
+        } else {
+            surface_triangles.push_back(triangle);
+        }
     }
+    slicable_triangles.shrink_to_fit();
 
-    let slicer_options = SlicerOptions {
-        aabb,
-        bvh: Bvh::build(&mut triangles),
-        triangles,
-        layer_height,
-    };
-    let base_slices = base_slices::create_base_slices(&slicer_options, &vec![]);
+    console_log!("Computing BVH");
+
+    let slicer_options = SlicerOptions { layer_height };
+
+    console_log!("Creating Surfaces");
+    let surfaces = split_surface(surface_triangles);
+
+    console_log!("Creating Slices");
+    let slicable = Mesh::from(slicable_triangles);
+    let base_slices = create_base_slices(&slicer_options, &slicable);
+    console_log!("Done");
 }