@woosh/meep-engine 2.131.47 → 2.132.0

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_cleanup_faceless_references.d.ts

@@ -0,0 +1,10 @@
+/**
+ * Remove vertices/edges/loops/disks etc. that are not referenced by any faces.
+ * Useful when running topology modifying algorithms such as erosion or simplification.
+ * Performs in-place modification of the mesh.
+ *
+ * If a valid mesh is passed in, after calling this - the mesh is guaranteed to be in a valid state.
+ * @param {BinaryTopology} mesh
+ */
+export function bt_mesh_cleanup_faceless_references(mesh: BinaryTopology): void;
+//# sourceMappingURL=bt_mesh_cleanup_faceless_references.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_cleanup_faceless_references.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_cleanup_faceless_references.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_cleanup_faceless_references.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,gFAgDC"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_cleanup_faceless_references.js

@@ -0,0 +1,62 @@
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_loop_kill } from "./bt_loop_kill.js";
+import { bt_edge_kill } from "./edge/bt_edge_kill.js";
+import { bt_vert_kill } from "./vertex/bt_vert_kill.js";
+
+/**
+ * Remove vertices/edges/loops/disks etc. that are not referenced by any faces.
+ * Useful when running topology modifying algorithms such as erosion or simplification.
+ * Performs in-place modification of the mesh.
+ *
+ * If a valid mesh is passed in, after calling this - the mesh is guaranteed to be in a valid state.
+ * @param {BinaryTopology} mesh
+ */
+export function bt_mesh_cleanup_faceless_references(mesh) {
+    const loop_pool = mesh.loops;
+
+    // Cull orphaned loops
+    // Loops without a face pointer are not part of any face polygon.
+    // bt_loop_kill should untangle the loop from its edge's radial cycle and vertex.
+    const loop_count = loop_pool.size;
+    for (let l = 0; l < loop_count; l++) {
+        if (!loop_pool.is_allocated(l)) {
+            continue;
+        }
+
+        if (mesh.loop_read_face(l) === NULL_POINTER) {
+            bt_loop_kill(mesh, l);
+        }
+    }
+
+    const edge_pool = mesh.edges;
+
+    // Cull disconnected edges
+    // Edges without a loop are not part of any face
+    const edge_count = edge_pool.size;
+    for (let e = 0; e < edge_count; e++) {
+        if (!edge_pool.is_allocated(e)) {
+            continue;
+        }
+
+        if (mesh.edge_read_loop(e) === NULL_POINTER) {
+            bt_edge_kill(mesh, e);
+        }
+    }
+
+    const vertex_pool = mesh.vertices;
+
+    // Cull disconnected vertices
+    // Vertices without an edge pointer are completely isolated.
+    // Note: bt_edge_kill above handles untangling killed edges from vertex disk cycles,
+    // so any vertices left entirely stranded will now safely read as NULL_POINTER.
+    const vertex_count = vertex_pool.size;
+    for (let v = 0; v < vertex_count; v++) {
+        if (!vertex_pool.is_allocated(v)) {
+            continue;
+        }
+
+        if (mesh.vertex_read_edge(v) === NULL_POINTER) {
+            bt_vert_kill(mesh, v);
+        }
+    }
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple.d.ts

@@ -0,0 +1,13 @@
+/**
+ * Breaks up shared edges and vertices between two faces.
+ * As a result duplicate vertices and edges may be created.
+ *
+ * Primary isolate faces so they can be edited independently.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face0_id
+ * @param {number} face1_id
+ * @see bt_merge_verts_by_distance
+ */
+export function bt_mesh_face_decouple(mesh: BinaryTopology, face0_id: number, face1_id: number): void;
+//# sourceMappingURL=bt_mesh_face_decouple.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_face_decouple.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple.js"],"names":[],"mappings":"AAQA;;;;;;;;;;GAUG;AACH,sEAJW,MAAM,YACN,MAAM,QAgIhB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple.js

@@ -0,0 +1,145 @@
+import { assert } from "../../../../../../assert.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_disk_edge_add } from "./bt_disk_edge_add.js";
+import { bt_disk_edge_remove } from "./bt_disk_edge_remove.js";
+import { bt_radial_loop_add } from "./bt_radial_loop_add.js";
+import { bt_radial_loop_remove } from "./bt_radial_loop_remove.js";
+import { bt_edge_create } from "./edge/bt_edge_create.js";
+
+/**
+ * Breaks up shared edges and vertices between two faces.
+ * As a result duplicate vertices and edges may be created.
+ *
+ * Primary isolate faces so they can be edited independently.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number} face0_id
+ * @param {number} face1_id
+ * @see bt_merge_verts_by_distance
+ */
+export function bt_mesh_face_decouple(
+    mesh,
+    face0_id,
+    face1_id,
+) {
+    assert.isNonNegativeInteger(face0_id, 'face0_id');
+    assert.isNonNegativeInteger(face1_id, 'face1_id');
+    assert.defined(mesh, 'mesh');
+    assert.notNull(mesh, 'mesh');
+
+    assert.equal(mesh.isBinaryTopology, true, 'mesh.isBinaryTopology !== true');
+
+    let l0 = mesh.face_read_loop(face0_id);
+    let l1 = mesh.face_read_loop(face1_id);
+
+    if (l0 === NULL_POINTER || l1 === NULL_POINTER) {
+        return;
+    }
+
+    // 1. Gather components of face0
+    const v0_set = new Set();
+    const e0_set = new Set();
+    let start0 = l0;
+    do {
+        v0_set.add(mesh.loop_read_vertex(l0));
+        e0_set.add(mesh.loop_read_edge(l0));
+        l0 = mesh.loop_read_next(l0);
+    } while (l0 !== start0);
+
+    // 2. Map intersection components from face1
+    const v1_loops = [];
+    const shared_v = new Set();
+    const shared_e = new Set();
+    const unshared_e_set = new Set();
+
+    let start1 = l1;
+    do {
+        v1_loops.push(l1);
+        const v = mesh.loop_read_vertex(l1);
+        const e = mesh.loop_read_edge(l1);
+
+        if (v0_set.has(v)) {
+            shared_v.add(v);
+        }
+        if (e0_set.has(e)) {
+            shared_e.add(e);
+        } else {
+            unshared_e_set.add(e);
+        }
+
+        l1 = mesh.loop_read_next(l1);
+    } while (l1 !== start1);
+
+    // If nothing is shared, they are already decoupled.
+    if (shared_v.size === 0 && shared_e.size === 0){
+        return;
+    }
+
+    // Pre-allocate arrays for fast coordinate/normal copying
+    const temp_coords = new Float32Array(3);
+    const temp_normal = new Float32Array(3);
+
+    // 3. Duplicate shared vertices
+    const v_map = new Map();
+    for (const v of shared_v) {
+        const v_new = mesh.vertices.allocate();
+
+        mesh.vertex_read_coordinate(temp_coords, 0, v);
+        mesh.vertex_write_coordinate(v_new, temp_coords, 0);
+
+        mesh.vertex_read_normal(temp_normal, 0, v);
+        mesh.vertex_write_normal(v_new, temp_normal, 0);
+
+        mesh.vertex_write_edge(v_new, NULL_POINTER);
+        v_map.set(v, v_new);
+    }
+
+    // 4. Duplicate shared edges
+    const e_map = new Map();
+    for (const e of shared_e) {
+        const v1 = mesh.edge_read_vertex1(e);
+        const v2 = mesh.edge_read_vertex2(e);
+
+        const v1_new = v_map.has(v1) ? v_map.get(v1) : v1;
+        const v2_new = v_map.has(v2) ? v_map.get(v2) : v2;
+
+        const e_new = bt_edge_create(mesh, v1_new, v2_new);
+        e_map.set(e, e_new);
+    }
+
+    // 5. Shift unshared edges that are attached to duplicated vertices
+    for (const e of unshared_e_set) {
+        const v1 = mesh.edge_read_vertex1(e);
+        const v2 = mesh.edge_read_vertex2(e);
+
+        if (v_map.has(v1)) {
+            bt_disk_edge_remove(mesh, e, v1);
+            const v1_new = v_map.get(v1);
+            mesh.edge_write_vertex1(e, v1_new);
+            bt_disk_edge_add(mesh, e, v1_new);
+        }
+        if (v_map.has(v2)) {
+            bt_disk_edge_remove(mesh, e, v2);
+            const v2_new = v_map.get(v2);
+            mesh.edge_write_vertex2(e, v2_new);
+            bt_disk_edge_add(mesh, e, v2_new);
+        }
+    }
+
+    // 6. Redirect loops on face1 to the new duplicated edges and vertices
+    for (const loop of v1_loops) {
+        const v = mesh.loop_read_vertex(loop);
+        const e = mesh.loop_read_edge(loop);
+
+        if (v_map.has(v)) {
+            mesh.loop_write_vertex(loop, v_map.get(v));
+        }
+
+        if (e_map.has(e)) {
+            const e_new = e_map.get(e);
+
+            bt_radial_loop_remove(mesh, loop, e);
+            bt_radial_loop_add(mesh, loop, e_new);
+        }
+    }
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple_islands.d.ts

@@ -0,0 +1,12 @@
+/**
+ * Breaks up any shared edges and vertices between faces across given islands.
+ * As a result each island shares no vertices or edges with other islands.
+ *
+ * Note: Islands do not have to be connected, but must be disjoint.
+ * Note: Islands do not have to include all faces of the mesh.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number[][]} islands 2D array of face IDs
+ */
+export function bt_mesh_face_decouple_islands(mesh: BinaryTopology, islands: number[][]): void;
+//# sourceMappingURL=bt_mesh_face_decouple_islands.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple_islands.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_face_decouple_islands.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple_islands.js"],"names":[],"mappings":"AAGA;;;;;;;;;GASG;AACH,6EAFW,MAAM,EAAE,EAAE,QAmGpB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_decouple_islands.js

@@ -0,0 +1,111 @@
+import { bt_face_get_attached_faces } from "../query/bt_face_get_attached_faces.js";
+import { bt_mesh_face_decouple } from "./bt_mesh_face_decouple.js";
+
+/**
+ * Breaks up any shared edges and vertices between faces across given islands.
+ * As a result each island shares no vertices or edges with other islands.
+ *
+ * Note: Islands do not have to be connected, but must be disjoint.
+ * Note: Islands do not have to include all faces of the mesh.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number[][]} islands 2D array of face IDs
+ */
+export function bt_mesh_face_decouple_islands(mesh, islands) {
+
+    if (islands.length <= 1) {
+        // no need to decouple
+        return;
+    }
+
+    /**
+     *
+     * @type {number[]}
+     */
+    const all_island_faces = [];
+    /**
+     *
+     * @type {Map<number, number>}
+     */
+    const face_to_islands = new Map();
+
+    // build face -> island map
+    for (let island_id = 0; island_id < islands.length; island_id++) {
+        const island = islands[island_id];
+
+        const island_size = island.length;
+
+        for (let j = 0; j < island_size; j++) {
+            const face = island[j];
+
+            face_to_islands.set(face, island_id);
+            all_island_faces.push(face);
+
+        }
+    }
+
+    // crawl faces
+    const relevant_face_count = all_island_faces.length;
+
+    /**
+     *
+     * @type {number[]}
+     */
+    const other_faces = [];
+
+    /**
+     *
+     * @type {Map<number, Set<number>>}
+     */
+    const processed_pairs = new Map();
+
+    /**
+     *
+     * @param {number} face
+     * @returns {Set<number>}
+     */
+    function get_processed_pair(face) {
+        const existing = processed_pairs.get(face);
+
+        if (existing !== undefined) {
+            return existing;
+        }
+
+        const v = new Set();
+
+        processed_pairs.set(face, v);
+
+        return v;
+    }
+
+    for (let i = 0; i < relevant_face_count; i++) {
+        const face = all_island_faces[i];
+
+        const island_id = face_to_islands.get(face);
+
+        const attached_count = bt_face_get_attached_faces(other_faces, 0, mesh, face);
+
+        for (let j = 0; j < attached_count; j++) {
+            const attached_face = other_faces[j];
+
+            const neighbour_island_id = face_to_islands.get(attached_face);
+
+            if (neighbour_island_id === island_id || neighbour_island_id === undefined) {
+                continue;
+            }
+
+            const this_pairs = get_processed_pair(face);
+
+            if (this_pairs.has(attached_face)) {
+                // already processed
+                continue;
+            }
+
+            bt_mesh_face_decouple(mesh, face, attached_face);
+
+            // record processed pair
+            this_pairs.add(attached_face);
+            get_processed_pair(attached_face).add(face);
+        }
+    }
+}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_island_erode.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Shrinks an island of faces by a given distance.
+ * Conceptually, this moves the outline of the island inwards.
+ * Assumes the input mesh is triangulated, see {@link bt_mesh_triangulate}.
+ *
+ * It is assumed that the island does not share any edges/vertices with any other part of the mesh. If this assumption is violated - expect undefined behavior.
+ * An island is not restricted to all faces being co-planar, it may curve.
+ * The erosion distance may be smaller than the smallest triangle height in the island, or it may be significantly larger - there is no restriction.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number[]} faces
+ * @param {number} erode_distance
+ */
+export function bt_mesh_face_island_erode(mesh: BinaryTopology, faces: number[], erode_distance: number): void;
+//# sourceMappingURL=bt_mesh_face_island_erode.d.ts.map

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_island_erode.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"bt_mesh_face_island_erode.d.ts","sourceRoot":"","sources":["../../../../../../../../../src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_island_erode.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;GAYG;AACH,uEAHW,MAAM,EAAE,kBACR,MAAM,QAwQhB"}

package/src/core/geom/3d/topology/struct/binary/io/bt_mesh_face_island_erode.js

@@ -0,0 +1,290 @@
+import { assert } from "../../../../../../assert.js";
+import { clamp01 } from "../../../../../../math/clamp01.js";
+import { inverseLerp } from "../../../../../../math/inverseLerp.js";
+import {
+    line3_compute_segment_point_distance_eikonal
+} from "../../../../line/line3_compute_segment_point_distance_eikonal.js";
+import { NULL_POINTER } from "../BinaryTopology.js";
+import { bt_face_get_incenter } from "../query/bt_face_get_incenter.js";
+import { bt_mesh_build_boundary_distance_field } from "../query/bt_mesh_build_boundary_distance_field.js";
+import { bt_mesh_cleanup_faceless_references } from "./bt_mesh_cleanup_faceless_references.js";
+import { bt_edge_split } from "./edge/bt_edge_split.js";
+import { bt_face_kill } from "./face/bt_face_kill.js";
+import { bt_mesh_face_poke } from "./face/bt_face_poke.js";
+
+/**
+ * Shrinks an island of faces by a given distance.
+ * Conceptually, this moves the outline of the island inwards.
+ * Assumes the input mesh is triangulated, see {@link bt_mesh_triangulate}.
+ *
+ * It is assumed that the island does not share any edges/vertices with any other part of the mesh. If this assumption is violated - expect undefined behavior.
+ * An island is not restricted to all faces being co-planar, it may curve.
+ * The erosion distance may be smaller than the smallest triangle height in the island, or it may be significantly larger - there is no restriction.
+ *
+ * @param {BinaryTopology} mesh
+ * @param {number[]} faces
+ * @param {number} erode_distance
+ */
+export function bt_mesh_face_island_erode(
+    mesh,
+    faces,
+    erode_distance
+) {
+
+    if (faces.length === 0 || erode_distance <= 0) {
+        // no work to do
+        return;
+    }
+
+    /**
+     *
+     * @type {Set<number>}
+     */
+    const island_vertices = new Set();
+
+    /**
+     *
+     * @type {Set<number>}
+     */
+    const island_edges = new Set();
+
+    // 1. Map all vertices and edges of the island
+    for (let i = 0; i < faces.length; i++) {
+        const f = faces[i];
+        const l_first = mesh.face_read_loop(f);
+        if (l_first === NULL_POINTER) continue;
+
+        let l_curr = l_first;
+        do {
+            island_vertices.add(mesh.loop_read_vertex(l_curr));
+            island_edges.add(mesh.loop_read_edge(l_curr));
+            l_curr = mesh.loop_read_next(l_curr);
+        } while (l_curr !== l_first);
+    }
+
+    // 2. Identify boundary vertices (edges with only one loop)
+    const boundary_vertices = new Set();
+    const boundary_edges_set = new Set();
+
+    for (const e of island_edges) {
+        const l = mesh.edge_read_loop(e);
+        if (mesh.loop_read_radial_next(l) === l) {
+            boundary_vertices.add(mesh.edge_read_vertex1(e));
+            boundary_vertices.add(mesh.edge_read_vertex2(e));
+
+            boundary_edges_set.add(e);
+        }
+    }
+
+    if (boundary_vertices.size === 0) {
+        // no boundary vertices found
+        // should never happen if the mesh is valid
+        return;
+    }
+
+    // 3. Compute Geodesic Distance Field
+    /**
+     * Vertex -> Distance from boundary
+     * @type {Map<number, number>}
+     */
+    const vertex_boundary_distances = new Map();
+    bt_mesh_build_boundary_distance_field(vertex_boundary_distances, mesh, island_vertices, boundary_vertices);
+    // ---------------------------------------------------------
+    // 3.5. PEAK RESCUE PASS (The Fix)
+    // Handle cases where a face is "submerged" by vertex values
+    // but geometrically contains a safe zone (e.g. single triangle).
+    // ---------------------------------------------------------
+
+    // We snapshot the faces list because we might modify topology (poke)
+    const faces_to_check = [...faces];
+    const centroid = [];
+    const scratch_v1 = [];
+    const scratch_v2 = [];
+
+    for (const f of faces_to_check) {
+        // Collect face vertices and check if they are all "dead"
+        let l_curr = mesh.face_read_loop(f);
+        const l_end = l_curr;
+        let all_dead = true;
+
+        do {
+            const v = mesh.loop_read_vertex(l_curr);
+            if ((vertex_boundary_distances.get(v) || 0) >= erode_distance) {
+                all_dead = false;
+            }
+            l_curr = mesh.loop_read_next(l_curr);
+        } while (l_curr !== l_end);
+
+        if (all_dead) {
+            // This face is slated for total deletion.
+            // Check if we should rescue it by adding a peak vertex.
+
+            // 1. Calculate Centroid (incenter only for triangle, falls back to centroid for other N-gons)
+            bt_face_get_incenter(centroid, 0, mesh, f);
+
+            // 2. Calculate Centroid Distance to Boundary
+            // (For a single island face, min dist to its own boundary edges)
+            let min_dist = Infinity;
+            // Iterate edges of this face
+            l_curr = mesh.face_read_loop(f);
+            do {
+                const e = mesh.loop_read_edge(l_curr);
+
+                const v1 = mesh.edge_read_vertex1(e);
+                const v2 = mesh.edge_read_vertex2(e);
+
+                if (island_vertices.has(v1) && island_vertices.has(v2)) {
+
+                    mesh.vertex_read_coordinate(scratch_v1, 0, v1);
+                    mesh.vertex_read_coordinate(scratch_v2, 0, v2);
+
+                    const d1 = vertex_boundary_distances.get(v1);
+                    const d2 = vertex_boundary_distances.get(v2);
+
+                    if (d1 < erode_distance || d2 < erode_distance) {
+                        // only consider edges that could cross the erosion threshold
+
+                        const d = line3_compute_segment_point_distance_eikonal(
+                            d1, d2,
+                            scratch_v1[0], scratch_v1[1], scratch_v1[2],
+                            scratch_v2[0], scratch_v2[1], scratch_v2[2],
+                            centroid[0], centroid[1], centroid[2]
+                        );
+
+                        if (d < min_dist) {
+                            min_dist = d;
+                        }
+
+                    }
+
+                }
+
+                l_curr = mesh.loop_read_next(l_curr);
+            } while (l_curr !== l_end);
+
+            // If min_dist is Infinity, it means this face has NO boundary edges
+            // (it's internal). It should have inherited values from neighbors.
+            // We ignore it, or assume linear interpolation was correct.
+            // We only rescue faces touching the boundary that collapsed.
+
+            if (min_dist !== Infinity && min_dist > erode_distance) {
+                // RESCUE: The center is safe!
+                // Poke the face to create a vertex at the centroid.
+                const new_vert = bt_mesh_face_poke(mesh, f, centroid[0], centroid[1], centroid[2]);
+
+                // Update Data
+                island_vertices.add(new_vert);
+                vertex_boundary_distances.set(new_vert, min_dist);
+
+                // Read the new edges connected to the center and add to processing set
+                let e_first = mesh.vertex_read_edge(new_vert);
+
+                let e_scan = e_first;
+                do {
+                    island_edges.add(e_scan);
+
+                    const v1 = mesh.edge_read_vertex1(e_scan);
+                    const is_v1 = v1 === new_vert;
+
+                    // DEBUG checks
+                    const v2 = mesh.edge_read_vertex2(e_scan);
+                    if (is_v1) {
+                        assert.equal(v1, new_vert, 'edge vertex does not match new vertex');
+                        assert.notEqual(v2, new_vert, 'edge vertex does not match new vertex');
+                    } else {
+                        assert.equal(v2, new_vert, 'edge vertex does not match new vertex');
+                        assert.notEqual(v1, new_vert, 'edge vertex does not match new vertex');
+                    }
+
+                    e_scan = is_v1 ? mesh.edge_read_v1_disk_next(e_scan) : mesh.edge_read_v2_disk_next(e_scan);
+                } while (e_scan !== e_first);
+            }
+        }
+    }
+    // ---------------------------------------------------------
+
+    // 4. Trace the Contour & Split Edges
+
+    /**
+     *
+     * @type {{e: number, t: number}[]}
+     */
+    const edges_to_split = [];
+
+    for (const e of island_edges) {
+
+        assert.equal(mesh.edges.is_allocated(e), true, 'edge is not allocated');
+
+        const v1 = mesh.edge_read_vertex1(e);
+        const v2 = mesh.edge_read_vertex2(e);
+
+        const d1 = vertex_boundary_distances.get(v1);
+        const d2 = vertex_boundary_distances.get(v2);
+
+        // If the edge strictly crosses the erosion threshold
+        const crosses_erosion_boundary = (d1 < erode_distance && d2 > erode_distance) || (d2 < erode_distance && d1 > erode_distance);
+
+        if (crosses_erosion_boundary) {
+            // Calculate exact interpolation parameter
+            const t = clamp01(inverseLerp(d1, d2, erode_distance));
+            edges_to_split.push({ e, t });
+        }
+    }
+
+    // Execute splits
+    for (const { e, t } of edges_to_split) {
+        // splits the edge as well as adjacent faces.
+        bt_edge_split(mesh, e, t);
+    }
+
+    // Cull Dead Geometry
+    // Any vertex that had a distance < erode_distance is dead.
+    // Any face connected to a dead vertex must be destroyed.
+    /**
+     *
+     * @type {Set<number>}
+     */
+    const faces_to_kill = new Set();
+
+    for (const [vertex, distance] of vertex_boundary_distances.entries()) {
+        const EPSILON = 1e-17;
+
+        if (distance >= erode_distance - EPSILON) {
+            // too far, survives
+            continue;
+        }
+
+        const e_first = mesh.vertex_read_edge(vertex);
+
+        if (e_first === NULL_POINTER) {
+            continue;
+        }
+
+        let e_curr = e_first;
+        do {
+            // Traverse radial loops to get all connected faces
+            const l_first = mesh.edge_read_loop(e_curr);
+            if (l_first !== NULL_POINTER) {
+                let l_curr = l_first;
+                do {
+                    faces_to_kill.add(mesh.loop_read_face(l_curr));
+                    l_curr = mesh.loop_read_radial_next(l_curr);
+                } while (l_curr !== l_first);
+            }
+
+            // Move around disk cycle
+            const v1 = mesh.edge_read_vertex1(e_curr);
+            e_curr = (v1 === vertex) ? mesh.edge_read_v1_disk_next(e_curr) : mesh.edge_read_v2_disk_next(e_curr);
+        } while (e_curr !== e_first && e_curr !== NULL_POINTER);
+    }
+
+    // Eradicate the dead faces
+    for (const f of faces_to_kill) {
+        bt_face_kill(mesh, f);
+    }
+
+    // 6. Cleanup floating vertices and edges
+    if (faces_to_kill.size > 0) {
+        bt_mesh_cleanup_faceless_references(mesh);
+    }
+}