@woosh/meep-engine 2.169.1 → 2.169.2

package/src/core/geom/3d/shape/MeshShape3D.js

@@ -1,11 +1,15 @@
+import { orient3d_fast_point } from "../plane/orient3d_fast_point.js";
+import { hash_mix2 } from "../../../math/hash/hash_mix2.js";
 import { BVH } from "../../../bvh2/bvh3/BVH.js";
 import { ebvh_build_for_geometry_morton } from "../../../bvh2/bvh3/ebvh_build_for_geometry_morton.js";
 import { ebvh_geometry_query_nearest_triangle_ray } from "../../../bvh2/bvh3/ebvh_geometry_query_nearest_triangle_ray.js";
 import { bvh_query_user_data_intersects_aabb } from "../../../bvh2/bvh3/query/bvh_query_user_data_intersects_aabb.js";
-import { tri3_closest_point_barycentric } from "../triangle/tri3_closest_point_barycentric.js";
+import { tri3_closest_point } from "../triangle/tri3_closest_point.js";
 import { tetrahedral_mesh_compute_tet_volume } from "../tetrahedra/tetrahedral_mesh_compute_tet_volume.js";
 import { TetrahedralMesh } from "../tetrahedra/TetrahedralMesh.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
+import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
+import { aabb3_from_v3_array } from "../aabb/aabb3_from_v3_array.js";
 
 // module-static scratch for the surface-raycast query [triangleIndex, u, v, t]
 const MESH_QUERY_OUT = [0, 0, 0, 0];
@@ -248,22 +252,14 @@ export class MeshShape3D extends AbstractShape3D {
         const indices = this.indices;
         const bbox = this.__bbox;
 
-        let min_x = Infinity, min_y = Infinity, min_z = Infinity;
-        let max_x = -Infinity, max_y = -Infinity, max_z = -Infinity;
         const v_count = positions.length / 3;
-        for (let i = 0; i < v_count; i++) {
-            const x = positions[i * 3];
-            const y = positions[i * 3 + 1];
-            const z = positions[i * 3 + 2];
-            if (x < min_x) min_x = x; if (x > max_x) max_x = x;
-            if (y < min_y) min_y = y; if (y > max_y) max_y = y;
-            if (z < min_z) min_z = z; if (z > max_z) max_z = z;
-        }
+
+        aabb3_from_v3_array(bbox, positions, positions.length);
+
         if (v_count === 0) {
-            min_x = min_y = min_z = max_x = max_y = max_z = 0;
+            // empty surface collapses to a degenerate box at the origin; the reduction leaves ±Infinity
+            bbox[0] = bbox[1] = bbox[2] = bbox[3] = bbox[4] = bbox[5] = 0;
         }
-        bbox[0] = min_x; bbox[1] = min_y; bbox[2] = min_z;
-        bbox[3] = max_x; bbox[4] = max_y; bbox[5] = max_z;
 
         // Surface area: ½‖e1 × e2‖ per triangle.
         let area_sum = 0;
@@ -426,7 +422,6 @@ export class MeshShape3D extends AbstractShape3D {
 
         let best_d2 = Infinity;
         let best_x = 0, best_y = 0, best_z = 0;
-        const baryc = scratch_barycentric;
 
         for (let i = 0; i < tri_count; i++) {
             const ia = indices[i * 3] * 3;
@@ -436,24 +431,16 @@ export class MeshShape3D extends AbstractShape3D {
             const bx = positions[ib], by = positions[ib + 1], bz = positions[ib + 2];
             const cx = positions[ic], cy = positions[ic + 1], cz = positions[ic + 2];
 
-            tri3_closest_point_barycentric(
-                baryc, 0,
+            const d2 = tri3_closest_point(
+                scratch_closest, 0,
                 px, py, pz,
                 ax, ay, az,
                 bx, by, bz,
                 cx, cy, cz
             );
-            const u = baryc[0], v = baryc[1];
-            const w = 1 - u - v;
-            const qx = u * ax + v * bx + w * cx;
-            const qy = u * ay + v * by + w * cy;
-            const qz = u * az + v * bz + w * cz;
-
-            const dx = qx - px, dy = qy - py, dz = qz - pz;
-            const d2 = dx * dx + dy * dy + dz * dz;
             if (d2 < best_d2) {
                 best_d2 = d2;
-                best_x = qx; best_y = qy; best_z = qz;
+                best_x = scratch_closest[0]; best_y = scratch_closest[1]; best_z = scratch_closest[2];
             }
         }
 
@@ -478,7 +465,6 @@ export class MeshShape3D extends AbstractShape3D {
         const px = point[0], py = point[1], pz = point[2];
 
         let best_d2 = Infinity;
-        const baryc = scratch_barycentric;
 
         for (let i = 0; i < tri_count; i++) {
             const ia = indices[i * 3] * 3;
@@ -488,20 +474,13 @@ export class MeshShape3D extends AbstractShape3D {
             const bx = positions[ib], by = positions[ib + 1], bz = positions[ib + 2];
             const cx = positions[ic], cy = positions[ic + 1], cz = positions[ic + 2];
 
-            tri3_closest_point_barycentric(
-                baryc, 0,
+            const d2 = tri3_closest_point(
+                scratch_closest, 0,
                 px, py, pz,
                 ax, ay, az,
                 bx, by, bz,
                 cx, cy, cz
             );
-            const u = baryc[0], v = baryc[1];
-            const w = 1 - u - v;
-            const qx = u * ax + v * bx + w * cx;
-            const qy = u * ay + v * by + w * cy;
-            const qz = u * az + v * bz + w * cz;
-            const dx = qx - px, dy = qy - py, dz = qz - pz;
-            const d2 = dx * dx + dy * dy + dz * dz;
             if (d2 < best_d2) best_d2 = d2;
         }
 
@@ -509,38 +488,6 @@ export class MeshShape3D extends AbstractShape3D {
         return this.contains_point(point) ? -dist : dist;
     }
 
-    /**
-     * Reject-sample inside the bounding box until a point lands in the
-     * mesh volume. For convex or near-convex shapes this terminates in
-     * 1–3 attempts; for thin or pinched shapes the worst-case cost can
-     * be high. Falls back to the bbox centre after 256 misses.
-     *
-     * @param {number[]|Float32Array} result
-     * @param {number} result_offset
-     * @param {function():number} random
-     */
-    sample_random_point_in_volume(result, result_offset, random) {
-        const b = this.__bbox;
-        const lx = b[0], ly = b[1], lz = b[2];
-        const sx = b[3] - b[0];
-        const sy = b[4] - b[1];
-        const sz = b[5] - b[2];
-        const probe = scratch_point;
-        for (let attempt = 0; attempt < 256; attempt++) {
-            probe[0] = lx + random() * sx;
-            probe[1] = ly + random() * sy;
-            probe[2] = lz + random() * sz;
-            if (this.contains_point(probe)) {
-                result[result_offset]     = probe[0];
-                result[result_offset + 1] = probe[1];
-                result[result_offset + 2] = probe[2];
-                return;
-            }
-        }
-        result[result_offset]     = lx + sx * 0.5;
-        result[result_offset + 1] = ly + sy * 0.5;
-        result[result_offset + 2] = lz + sz * 0.5;
-    }
 
     /**
      * Numerical-gradient SDF gradient.
@@ -550,20 +497,7 @@ export class MeshShape3D extends AbstractShape3D {
      * @returns {number}
      */
     signed_distance_gradient_at_point(result, point) {
-        const h = 1e-4;
-        const d_center = this.signed_distance_at_point(point);
-        const sample = scratch_point;
-        sample[0] = point[0] + h; sample[1] = point[1]; sample[2] = point[2];
-        const d_x = this.signed_distance_at_point(sample);
-        sample[0] = point[0]; sample[1] = point[1] + h;
-        const d_y = this.signed_distance_at_point(sample);
-        sample[1] = point[1]; sample[2] = point[2] + h;
-        const d_z = this.signed_distance_at_point(sample);
-        const inv_h = 1 / h;
-        result[0] = (d_x - d_center) * inv_h;
-        result[1] = (d_y - d_center) * inv_h;
-        result[2] = (d_z - d_center) * inv_h;
-        return d_center;
+        return compute_signed_distance_gradient_by_sampling(result, this, point);
     }
 
     /**
@@ -593,12 +527,12 @@ export class MeshShape3D extends AbstractShape3D {
     hash() {
         const v_count = this.positions.length / 3 | 0;
         const t_count = this.indices.length / 3 | 0;
-        let h = (v_count * 31 + t_count) | 0;
+        let h = hash_mix2(v_count, t_count);
         if (this.positions.length >= 3) {
-            h = (h * 31 + Math.fround(this.positions[0]) * 1e6 | 0) | 0;
-            h = (h * 31 + Math.fround(this.positions[this.positions.length - 1]) * 1e6 | 0) | 0;
+            h = hash_mix2(h, Math.fround(this.positions[0]) * 1e6 | 0);
+            h = hash_mix2(h, Math.fround(this.positions[this.positions.length - 1]) * 1e6 | 0);
         }
-        return h | 0;
+        return h;
     }
 }
 
@@ -643,21 +577,7 @@ MeshShape3D.prototype.is_convex = false;
  * @param {number} ez
  * @returns {number}   positive iff E lies below the plane (CCW from above)
  */
-function orient3d_with_point(positions, ai, bi, ci, ex, ey, ez) {
-    const a3 = ai * 3, b3 = bi * 3, c3 = ci * 3;
-    const adx = positions[a3]     - ex;
-    const ady = positions[a3 + 1] - ey;
-    const adz = positions[a3 + 2] - ez;
-    const bdx = positions[b3]     - ex;
-    const bdy = positions[b3 + 1] - ey;
-    const bdz = positions[b3 + 2] - ez;
-    const cdx = positions[c3]     - ex;
-    const cdy = positions[c3 + 1] - ey;
-    const cdz = positions[c3 + 2] - ez;
-    return adx * (bdy * cdz - bdz * cdy)
-        + bdx * (cdy * adz - cdz * ady)
-        + cdx * (ady * bdz - adz * bdy);
-}
+
 
 /**
  * Point-in-tet test using four orient3d evaluations on the tet's four
@@ -684,10 +604,10 @@ function orient3d_with_point(positions, ai, bi, ci, ex, ey, ez) {
  * @returns {boolean}
  */
 function tet_contains_point_coords(positions, a, b, c, d, ex, ey, ez) {
-    const v_a = orient3d_with_point(positions, b, d, c, ex, ey, ez);
-    const v_b = orient3d_with_point(positions, c, d, a, ex, ey, ez);
-    const v_c = orient3d_with_point(positions, d, b, a, ex, ey, ez);
-    const v_d = orient3d_with_point(positions, a, b, c, ex, ey, ez);
+    const v_a = orient3d_fast_point(positions, b, d, c, ex, ey, ez);
+    const v_b = orient3d_fast_point(positions, c, d, a, ex, ey, ez);
+    const v_c = orient3d_fast_point(positions, d, b, a, ex, ey, ez);
+    const v_d = orient3d_fast_point(positions, a, b, c, ex, ey, ez);
 
     // Boundary points (any value == 0) count as inside — the >= / <=
     // bounds accept them under either winding.
@@ -696,7 +616,8 @@ function tet_contains_point_coords(positions, a, b, c, d, ex, ey, ez) {
     return all_nonneg || all_nonpos;
 }
 
-const scratch_barycentric = new Float64Array(2);
+// closest-point-on-triangle output for the surface-scan query helpers
+const scratch_closest = new Float64Array(3);
 const scratch_point = new Float64Array(3);
 const scratch_query_aabb = new Float64Array(6);
 

package/src/core/geom/3d/shape/Triangle3D.d.ts

@@ -70,7 +70,7 @@ export class Triangle3D extends AbstractShape3D {
      *
      * Magnitude is the true point-to-triangle distance (handles vertex,
      * edge, and face Voronoi regions correctly via
-     * {@link tri3_closest_point_barycentric}).
+     * {@link tri3_closest_point}).
      */
     signed_distance_at_point(point: any): number;
     nearest_point_on_surface(result: any, reference: any): void;

package/src/core/geom/3d/shape/Triangle3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Triangle3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/Triangle3D.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAmCI;;;;;;;;;;;;;;;OAeG;IACH,gBAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAWtB;IAxDG;;;OAGG;IACH,QAFU,YAAY,GAAG,IAAI,CAEX;IAElB;;;;OAIG;IACH,QAFU,MAAM,CAED;IAGnB;;;;;;;OAOG;IACH,aAJW,YAAY,UACZ,MAAM,GACJ,UAAU,CAStB;IA6BD,qGAyBC;IAED,wCAeC;IAED;;OAEG;IACH,qCAEC;IAED;;;;;;;;OAQG;IACH,6CA4CC;IAED,4DAwBC;IAED;;;OAGG;IACH,kFAsBC;IAwBD;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAenB;IAgBL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC;gCA1S+B,sBAAsB"}
+{"version":3,"file":"Triangle3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/Triangle3D.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAmCI;;;;;;;;;;;;;;;OAeG;IACH,gBAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAWtB;IAxDG;;;OAGG;IACH,QAFU,YAAY,GAAG,IAAI,CAEX;IAElB;;;;OAIG;IACH,QAFU,MAAM,CAED;IAGnB;;;;;;;OAOG;IACH,aAJW,YAAY,UACZ,MAAM,GACJ,UAAU,CAStB;IA6BD,qGAyBC;IAED,wCAeC;IAED;;OAEG;IACH,qCAEC;IAED;;;;;;;;OAQG;IACH,6CA+BC;IAED,4DAeC;IAED;;;OAGG;IACH,kFAsBC;IAwBD;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAenB;IAgBL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC;gCApR+B,sBAAsB"}

package/src/core/geom/3d/shape/Triangle3D.js

@@ -1,7 +1,7 @@
 import { assert } from "../../../assert.js";
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
 import { v3_length } from "../../vec3/v3_length.js";
-import { tri3_closest_point_barycentric } from "../triangle/tri3_closest_point_barycentric.js";
+import { tri3_closest_point } from "../triangle/tri3_closest_point.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 
 /**
@@ -145,7 +145,7 @@ export class Triangle3D extends AbstractShape3D {
      *
      * Magnitude is the true point-to-triangle distance (handles vertex,
      * edge, and face Voronoi regions correctly via
-     * {@link tri3_closest_point_barycentric}).
+     * {@link tri3_closest_point}).
      */
     signed_distance_at_point(point) {
         const b = this.buffer;
@@ -157,28 +157,15 @@ export class Triangle3D extends AbstractShape3D {
 
         const px = point[0]; const py = point[1]; const pz = point[2];
 
-        tri3_closest_point_barycentric(
-            scratch_bary, 0,
+        const distance_sqr = tri3_closest_point(
+            scratch_closest, 0,
             px, py, pz,
             ax, ay, az,
             bx, by, bz,
             cx, cy, cz
         );
 
-        // result format: [alpha_A, alpha_B]; alpha_C = 1 - alpha_A - alpha_B
-        const alpha_a = scratch_bary[0];
-        const alpha_b = scratch_bary[1];
-        const alpha_c = 1 - alpha_a - alpha_b;
-
-        const closest_x = alpha_a * ax + alpha_b * bx + alpha_c * cx;
-        const closest_y = alpha_a * ay + alpha_b * by + alpha_c * cy;
-        const closest_z = alpha_a * az + alpha_b * bz + alpha_c * cz;
-
-        const dx = px - closest_x;
-        const dy = py - closest_y;
-        const dz = pz - closest_z;
-
-        const distance = v3_length(dx, dy, dz);
+        const distance = Math.sqrt(distance_sqr);
 
         // face normal = (B - A) × (C - A)  — CCW convention
         const e1x = bx - ax; const e1y = by - ay; const e1z = bz - az;
@@ -201,22 +188,13 @@ export class Triangle3D extends AbstractShape3D {
         const bx = b[o + 3]; const by = b[o + 4]; const bz = b[o + 5];
         const cx = b[o + 6]; const cy = b[o + 7]; const cz = b[o + 8];
 
-        tri3_closest_point_barycentric(
-            scratch_bary, 0,
+        tri3_closest_point(
+            result, 0,
             reference[0], reference[1], reference[2],
             ax, ay, az,
             bx, by, bz,
             cx, cy, cz
         );
-
-        // result format: [alpha_A, alpha_B]; alpha_C = 1 - alpha_A - alpha_B
-        const alpha_a = scratch_bary[0];
-        const alpha_b = scratch_bary[1];
-        const alpha_c = 1 - alpha_a - alpha_b;
-
-        result[0] = alpha_a * ax + alpha_b * bx + alpha_c * cx;
-        result[1] = alpha_a * ay + alpha_b * by + alpha_c * cy;
-        result[2] = alpha_a * az + alpha_b * bz + alpha_c * cz;
     }
 
     /**
@@ -310,9 +288,10 @@ export class Triangle3D extends AbstractShape3D {
 Triangle3D.prototype.isTriangle3D = true;
 
 /**
- * Scratch for barycentric output from {@link tri3_closest_point_barycentric}.
+ * Scratch for the closest-point output of {@link tri3_closest_point}.
  * Module-scoped because every triangle method that needs barycentric
  * coords does it strictly inline — no nested calls that could re-enter.
  * @type {Float64Array}
  */
-const scratch_bary = new Float64Array(2);
+// closest-point-on-triangle output
+const scratch_closest = new Float64Array(3);

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tetrahedral_mesh_carve_outside_surface.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.js"],"names":[],"mappings":"AAoJA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6FAJW,UAAU,MAAM,CAAC,GAAC,YAAY;aAElB,MAAM;UAAQ,MAAM;EAsD1C"}
+{"version":3,"file":"tetrahedral_mesh_carve_outside_surface.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.js"],"names":[],"mappings":"AAmGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6FAJW,UAAU,MAAM,CAAC,GAAC,YAAY;aAElB,MAAM;UAAQ,MAAM;EAsD1C"}

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_carve_outside_surface.js

@@ -1,3 +1,4 @@
+import { bt_mesh_build_surface_triangle_bvh, SURFACE_PARITY_RAY_COUNT, SURFACE_PARITY_RAY_DIRECTIONS } from "../topology/struct/binary/query/bt_mesh_surface_ray_parity.js";
 import { assert } from "../../../assert.js";
 import { BVH, NULL_NODE } from "../../../bvh2/bvh3/BVH.js";
 import { bvh_query_user_data_ray } from "../../../bvh2/bvh3/query/bvh_query_user_data_ray.js";
@@ -16,57 +17,7 @@ import { tri3_ray_intersection } from "../triangle/tri3_ray_intersection.js";
 // Each row must be roughly unit-length so the AABB-vs-ray slab test in the
 // BVH query doesn't degenerate. Hand-picked rather than randomised so the
 // algorithm is fully deterministic.
-const RAY_DIRECTIONS = [
-    0.97123,  0.18927,  0.14431,
-    0.34219,  0.91283, -0.22971,
-   -0.51237,  0.27894,  0.81235,
-];
-const RAY_COUNT = RAY_DIRECTIONS.length / 3;
 
-/**
- * Build a BVH over the surface triangles. Each leaf's user_data is the
- * source face ID.
- *
- * @param {BVH} bvh
- * @param {BinaryTopology} surface
- */
-function build_surface_bvh(bvh, surface) {
-    bvh.release_all();
-
-    const face_count = surface.faces.size;
-    const v = [0, 0, 0];
-
-    for (let f = 0; f < face_count; f++) {
-        if (!surface.faces.is_allocated(f)) continue;
-
-        const l0 = surface.face_read_loop(f);
-        const l1 = surface.loop_read_next(l0);
-        const l2 = surface.loop_read_next(l1);
-
-        const v0 = surface.loop_read_vertex(l0);
-        const v1 = surface.loop_read_vertex(l1);
-        const v2 = surface.loop_read_vertex(l2);
-
-        surface.vertex_read_coordinate(v, 0, v0);
-        let minx = v[0], miny = v[1], minz = v[2];
-        let maxx = v[0], maxy = v[1], maxz = v[2];
-
-        surface.vertex_read_coordinate(v, 0, v1);
-        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
-        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
-        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
-
-        surface.vertex_read_coordinate(v, 0, v2);
-        if (v[0] < minx) minx = v[0]; else if (v[0] > maxx) maxx = v[0];
-        if (v[1] < miny) miny = v[1]; else if (v[1] > maxy) maxy = v[1];
-        if (v[2] < minz) minz = v[2]; else if (v[2] > maxz) maxz = v[2];
-
-        const node = bvh.allocate_node();
-        bvh.node_set_user_data(node, f);
-        bvh.node_set_aabb_primitive(node, minx, miny, minz, maxx, maxy, maxz);
-        bvh.insert_leaf(node);
-    }
-}
 
 const ray_hit = new SurfacePoint3();
 const ray_candidates = [];
@@ -114,7 +65,7 @@ function single_ray_parity_inside(bvh, root, surface, ox, oy, oz, dx, dy, dz) {
 
 /**
  * Classify a point as inside or outside the surface using a majority vote
- * across `RAY_COUNT` independent parity ray-casts. Robust against the
+ * across `SURFACE_PARITY_RAY_COUNT` independent parity ray-casts. Robust against the
  * edge/vertex grazing pathologies that defeat single-ray parity.
  *
  * @param {BVH} bvh
@@ -132,10 +83,10 @@ function point_is_inside_surface(bvh, surface, ox, oy, oz) {
 
     let inside_votes = 0;
 
-    for (let r = 0; r < RAY_COUNT; r++) {
-        const dx = RAY_DIRECTIONS[r * 3];
-        const dy = RAY_DIRECTIONS[r * 3 + 1];
-        const dz = RAY_DIRECTIONS[r * 3 + 2];
+    for (let r = 0; r < SURFACE_PARITY_RAY_COUNT; r++) {
+        const dx = SURFACE_PARITY_RAY_DIRECTIONS[r * 3];
+        const dy = SURFACE_PARITY_RAY_DIRECTIONS[r * 3 + 1];
+        const dz = SURFACE_PARITY_RAY_DIRECTIONS[r * 3 + 2];
 
         if (single_ray_parity_inside(bvh, root, surface, ox, oy, oz, dx, dy, dz)) {
             inside_votes++;
@@ -143,7 +94,7 @@ function point_is_inside_surface(bvh, surface, ox, oy, oz) {
     }
 
     // Strict majority (more than half).
-    return inside_votes * 2 > RAY_COUNT;
+    return inside_votes * 2 > SURFACE_PARITY_RAY_COUNT;
 }
 
 /**
@@ -174,7 +125,7 @@ export function tetrahedral_mesh_carve_outside_surface(tet_mesh, positions, surf
     assert.equal(surface.isBinaryTopology, true, 'surface.isBinaryTopology !== true');
 
     const surface_bvh = new BVH();
-    build_surface_bvh(surface_bvh, surface);
+    bt_mesh_build_surface_triangle_bvh(surface_bvh, surface);
 
     const live_tets = tet_mesh.getLive();
     const live_count = live_tets.length;

package/src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.d.ts

@@ -17,7 +17,7 @@ export function edge_collapse_pick_target_vertex(edge: TopoEdge, restricted_vert
  * @param {Map<number,Quadric3>} quadratics
  * @param {Set<number>} restricted_vertices
  */
-export function compute_edge_collapse_cost(edge: TopoEdge, quadratics: Map<number, Quadric3>, restricted_vertices: Set<number>): number;
+export function edge_collapse_cost_with_topology_fallback(edge: TopoEdge, quadratics: Map<number, Quadric3>, restricted_vertices: Set<number>): number;
 /**
  *
  * @param {TopoMesh} mesh
@@ -29,4 +29,11 @@ export function compute_edge_collapse_cost(edge: TopoEdge, quadratics: Map<numbe
  * @returns {boolean}
  */
 export function decimate_edge_collapse_snap(mesh: TopoMesh, edge: TopoEdge, target: TopoVertex, quadratics: Map<number, Quadric3>, heap: Uint32Heap, restricted_vertices: Set<number>): boolean;
+/**
+ *
+ * @param {TopoEdge} edge
+ * @param {Map<number,Quadric3>} quadratics
+ * @param {Set<number>} restricted_vertices
+ */
+export function compute_edge_collapse_cost(edge: TopoEdge, quadratics: Map<number, Quadric3>, restricted_vertices: Set<number>): number;
 //# sourceMappingURL=decimate_edge_collapse_snap.d.ts.map

package/src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"decimate_edge_collapse_snap.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH,kFASC;AAED;;;;;GAKG;AACH,sFAHW,IAAI,MAAM,CAAC,GACT,aAAW,SAAS,CA0ChC;AAqBD;;;;;GAKG;AACH,uEAHW,IAAI,MAAM,WAAU,uBACpB,IAAI,MAAM,CAAC,UAsBrB;AAsBD;;;;;;;;;GASG;AACH,4GALW,IAAI,MAAM,WAAU,yCAEpB,IAAI,MAAM,CAAC,GACT,OAAO,CAmFnB"}
+{"version":3,"file":"decimate_edge_collapse_snap.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/topology/simplify/decimate_edge_collapse_snap.js"],"names":[],"mappings":"AAiDA;;;;GAIG;AACH,kFASC;AAED;;;;;GAKG;AACH,sFAHW,IAAI,MAAM,CAAC,GACT,aAAW,SAAS,CA0ChC;AAqBD;;;;;GAKG;AACH,sFAHW,IAAI,MAAM,WAAU,uBACpB,IAAI,MAAM,CAAC,UAsBrB;AAsBD;;;;;;;;;GASG;AACH,4GALW,IAAI,MAAM,WAAU,yCAEpB,IAAI,MAAM,CAAC,GACT,OAAO,CAmFnB;AA3ID;;;;;GAKG;AACH,uEAHW,IAAI,MAAM,WAAU,uBACpB,IAAI,MAAM,CAAC,UAsBrB"}