@woosh/meep-engine 3.56.0 → 3.58.0

package/src/core/geom/3d/ray/ray3_compute_closest_point.js

@@ -1,43 +1,37 @@
-import { v3_dot } from "../../vec3/v3_dot.js";
-
-/**
- *
- * @param {Vector3} result
- * @param {number} origin_x
- * @param {number} origin_y
- * @param {number} origin_z
- * @param {number} direction_x
- * @param {number} direction_y
- * @param {number} direction_z
- * @param {number} px
- * @param {number} py
- * @param {number} pz
- * @returns {number} distance from origin, negative means that the point lies behind the origin in the direction opposite to the ray's own
- */
-export function ray3_compute_closest_point(
-    result,
-    origin_x, origin_y, origin_z,
-    direction_x, direction_y, direction_z,
-    px, py, pz
-) {
-
-    // find the closest point
-    const sp0_x = px - origin_x;
-    const sp0_y = py - origin_y;
-    const sp0_z = pz - origin_z;
-
-    //
-    const d2 = v3_dot(direction_x, direction_y, direction_z, direction_x, direction_y, direction_z);
-    const d3 = v3_dot(direction_x, direction_y, direction_z, sp0_x, sp0_y, sp0_z);
-
-    const t = d3 / d2;
-
-    // compute point on the ray
-    const lp_x = direction_x * t + origin_x;
-    const lp_y = direction_y * t + origin_y;
-    const lp_z = direction_z * t + origin_z;
-
-    result.set(lp_x, lp_y, lp_z);
-
-    return t;
-}
+import { ray3_compute_point_projection_t } from "./ray3_compute_point_projection_t.js";
+
+/**
+ *
+ * @param {Vector3} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {number} px
+ * @param {number} py
+ * @param {number} pz
+ * @returns {number} distance from origin, negative means that the point lies behind the origin in the direction opposite to the ray's own
+ */
+export function ray3_compute_closest_point(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    px, py, pz
+) {
+    const t = ray3_compute_point_projection_t(
+        origin_x, origin_y, origin_z,
+        direction_x, direction_y, direction_z,
+        px, py, pz
+    );
+
+    // compute point on the ray
+    const lp_x = direction_x * t + origin_x;
+    const lp_y = direction_y * t + origin_y;
+    const lp_z = direction_z * t + origin_z;
+
+    result.set(lp_x, lp_y, lp_z);
+
+    return t;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"ConvexHullShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/ConvexHullShape3D.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAyDI;;;;;;;OAOG;IACH,sBAJW,YAAY,WACZ,WAAW,GACT,iBAAiB,CAQ7B;IArED;;;;OAIG;IACH,UAFU,YAAY,CAES;IAE/B;;;;OAIG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;;;;;;OAQG;IACH,cAFU,WAAW,CAEa;IAElC,0BAA0B;IAC1B,YADW,WAAW,CACU;IAEhC;;;;;;OAMG;IACH,kBAFU,YAAY,CAEiB;IAEvC;;;;;;OAMG;IACH,iBAA+B;IAE/B,oCAAoC;IACpC,eAA6B;IAE7B,8BAA8B;IAC9B,iBAAa;IAEb,8BAA8B;IAC9B,uBAAmB;IAkBnB;;;OAGG;IACH,kBA8EC;IAUD,wCAQC;IAED;;;;;OAKG;IACH,sFAsCC;IAED;;;;;;;OAOG;IACH,gCAEC;IAED;;;OAGG;IACH,+BAEC;IAED,qCAkBC;IAED;;;OAGG;IACH,oCAgBC;IAED;;;OAGG;IACH,6CAiBC;IAED,mEAEC;IAED,4DAwBC;IAGD;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAanB;IAcL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;CAP9C;gCA7Y+B,sBAAsB"}
+{"version":3,"file":"ConvexHullShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/ConvexHullShape3D.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAyDI;;;;;;;OAOG;IACH,sBAJW,YAAY,WACZ,WAAW,GACT,iBAAiB,CAQ7B;IArED;;;;OAIG;IACH,UAFU,YAAY,CAES;IAE/B;;;;OAIG;IACH,SAFU,WAAW,CAEQ;IAE7B;;;;;;;;OAQG;IACH,cAFU,WAAW,CAEa;IAElC,0BAA0B;IAC1B,YADW,WAAW,CACU;IAEhC;;;;;;OAMG;IACH,kBAFU,YAAY,CAEiB;IAEvC;;;;;;OAMG;IACH,iBAA+B;IAE/B,oCAAoC;IACpC,eAA6B;IAE7B,8BAA8B;IAC9B,iBAAa;IAEb,8BAA8B;IAC9B,uBAAmB;IAkBnB;;;OAGG;IACH,kBA8EC;IAUD,wCAQC;IAED;;;;;OAKG;IACH,sFAsCC;IAED;;;;;;;OAOG;IACH,gCAEC;IAED;;;OAGG;IACH,+BAEC;IAED,qCAkBC;IAED;;;OAGG;IACH,oCAgBC;IAED;;;OAGG;IACH,6CAiBC;IAED,mEAEC;IAED,4DAwBC;IAGD;;;OAGG;IACH,cAHW,iBAAiB,GACf,OAAO,CAanB;IAcL;;;;OAIG;IACH,8BAFU,OAAO,CAE8B;CAP9C;gCA7Y+B,sBAAsB"}

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

@@ -1,6 +1,7 @@
 import { hash_mix2 } from "../../../math/hash/hash_mix2.js";
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
 import { aabb3_from_v3_array } from "../aabb/aabb3_from_v3_array.js";
+import { polygon3_compute_normal_indexed } from "../polygon/polygon3_compute_normal.js";
 import { convex_polyhedron3_raycast } from "../polyhedron/convex_polyhedron3_raycast.js";
 import { tri3_closest_point } from "../triangle/tri3_closest_point.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
@@ -602,25 +603,13 @@ function loop_planes(v, fo, fl) {
 
     for (let f = 0; f < face_count; f++) {
         const s = fo[f], e = fo[f + 1];
-        let nx = 0, ny = 0, nz = 0;
-
-        for (let i = s; i < e; i++) {
-            const a = fl[i] * 3, b = fl[i + 1 < e ? i + 1 : s] * 3;
-            nx += (v[a + 1] - v[b + 1]) * (v[a + 2] + v[b + 2]);
-            ny += (v[a + 2] - v[b + 2]) * (v[a] + v[b]);
-            nz += (v[a] - v[b]) * (v[a + 1] + v[b + 1]);
-        }
-
-        const l = Math.sqrt(nx * nx + ny * ny + nz * nz);
-        if (!(l > 0)) continue;
+        const o = f * 4;
+        polygon3_compute_normal_indexed(planes, o, v, fl, s, e - s);
 
-        nx /= l; ny /= l; nz /= l;
+        const nx = planes[o], ny = planes[o + 1], nz = planes[o + 2];
+        if (nx === 0 && ny === 0 && nz === 0) continue;
 
         const a = fl[s] * 3;
-        const o = f * 4;
-        planes[o] = nx;
-        planes[o + 1] = ny;
-        planes[o + 2] = nz;
         planes[o + 3] = nx * v[a] + ny * v[a + 1] + nz * v[a + 2];
     }
 

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

@@ -3,7 +3,7 @@ import { hash_mix2 } from "../../../math/hash/hash_mix2.js";
 import { assert } from "../../../assert.js";
 import { clamp } from "../../../math/clamp.js";
 import { clamp_index } from "../../../math/clamp_index.js";
-import { optional_equality } from "../../../model/object/optional_equality.js";
+import { objectsEqual } from "../../../function/objectsEqual.js";
 import { optional_hash } from "../../../model/object/optional_hash.js";
 import { tri3_raycast } from "../triangle/tri3_raycast.js";
 import { v3_cross } from "../../vec3/v3_cross.js";
@@ -984,7 +984,7 @@ export class HeightMapShape3D extends AbstractShape3D {
         if (!this.size.equals(other.size)) return false;
         if (this.tessellation !== other.tessellation) return false;
 
-        return optional_equality(this.sampler, other.sampler);
+        return objectsEqual(this.sampler, other.sampler);
     }
 
     hash() {

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

@@ -20,7 +20,7 @@
  *      traversal short-circuits cleanly when the query point is far
  *      from the mesh.
  *
- * Construct via {@link shape_mesh_from_geometry} rather than `new
+ * Construct via {@link shape3_mesh_from_geometry} rather than `new
  * MeshShape3D()` directly — the factory compacts the tet mesh, builds
  * the BVH, and caches the bbox / volume / surface area.
  *
@@ -192,7 +192,7 @@ export class MeshShape3D extends AbstractShape3D {
     /**
      * Refresh the cached bounding box, volume, surface area, and the lazy
      * raycast BLAS from the current `positions` / `indices` / `tet_mesh`.
-     * Called by {@link shape_mesh_from_geometry} at construction; call again
+     * Called by {@link shape3_mesh_from_geometry} at construction; call again
      * after mutating the underlying data so every cached derivative — the
      * raycast acceleration structure included — is rebuilt against the new
      * surface rather than silently serving stale results.

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

@@ -1,4 +1,4 @@
-import { orient3d_fast_point } from "../plane/orient3d_fast_point.js";
+import { tetrahedron_contains_point_coords } from "../tetrahedra/tetrahedron_contains_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";
@@ -36,7 +36,7 @@ const MESH_QUERY_OUT = [0, 0, 0, 0];
  *      traversal short-circuits cleanly when the query point is far
  *      from the mesh.
  *
- * Construct via {@link shape_mesh_from_geometry} rather than `new
+ * Construct via {@link shape3_mesh_from_geometry} rather than `new
  * MeshShape3D()` directly — the factory compacts the tet mesh, builds
  * the BVH, and caches the bbox / volume / surface area.
  *
@@ -309,7 +309,7 @@ export class MeshShape3D extends AbstractShape3D {
     /**
      * Refresh the cached bounding box, volume, surface area, and the lazy
      * raycast BLAS from the current `positions` / `indices` / `tet_mesh`.
-     * Called by {@link shape_mesh_from_geometry} at construction; call again
+     * Called by {@link shape3_mesh_from_geometry} at construction; call again
      * after mutating the underlying data so every cached derivative — the
      * raycast acceleration structure included — is rebuilt against the new
      * surface rather than silently serving stale results.
@@ -484,7 +484,7 @@ export class MeshShape3D extends AbstractShape3D {
             const b = tet_mesh.getVertexIndex(tet_id, 1);
             const c = tet_mesh.getVertexIndex(tet_id, 2);
             const d = tet_mesh.getVertexIndex(tet_id, 3);
-            if (tet_contains_point_coords(positions, a, b, c, d, px, py, pz)) {
+            if (tetrahedron_contains_point_coords(positions, a, b, c, d, px, py, pz)) {
                 return true;
             }
         }
@@ -649,60 +649,6 @@ MeshShape3D.prototype.is_convex = false;
 
 // ── Module-local helpers ────────────────────────────────────────────────────
 
-/**
- * Signed-volume-style orient3d test with the test point passed as raw
- * coordinates rather than an index into the positions array. Equivalent
- * to {@link orient3d_fast} but specialised so the caller doesn't have to
- * splice the query point into the positions buffer per call.
- *
- * @param {Float32Array|number[]} positions  flat (x, y, z) per vertex
- * @param {number} ai  index of plane vertex A
- * @param {number} bi  index of plane vertex B
- * @param {number} ci  index of plane vertex C
- * @param {number} ex  test point x
- * @param {number} ey
- * @param {number} ez
- * @returns {number}   positive iff E lies below the plane (CCW from above)
- */
-
-
-/**
- * Point-in-tet test using four orient3d evaluations on the tet's four
- * faces. Winding-agnostic: rather than assume a specific tet winding
- * (Delaunay's output is CCW with positive signed volume; the existing
- * {@link tetrahedron_contains_point} helper, by contrast, was authored
- * against a CW convention), we accept the point as interior whenever
- * all four face-orient3d evaluations share a sign — i.e. the test
- * point is on the same side of every face. The function thus returns
- * true for both winding conventions; the caller doesn't need to know
- * which one its mesh uses.
- *
- * Takes the test point as raw coordinates so it can be called from a
- * hot loop without scratch-buffer plumbing into `positions`.
- *
- * @param {Float32Array|number[]} positions
- * @param {number} a   tet vertex index 0
- * @param {number} b   tet vertex index 1
- * @param {number} c   tet vertex index 2
- * @param {number} d   tet vertex index 3
- * @param {number} ex  test point x
- * @param {number} ey
- * @param {number} ez
- * @returns {boolean}
- */
-function tet_contains_point_coords(positions, a, b, c, d, 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.
-    const all_nonneg = v_a >= 0 && v_b >= 0 && v_c >= 0 && v_d >= 0;
-    const all_nonpos = v_a <= 0 && v_b <= 0 && v_c <= 0 && v_d <= 0;
-    return all_nonneg || all_nonpos;
-}
-
 // closest-point-on-triangle output for the surface-scan query helpers
 const scratch_closest = new Float64Array(3);
 const scratch_point = new Float64Array(3);

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

@@ -153,9 +153,9 @@ export class PosedShape3D extends AbstractShape3D {
         // Inline q·v·q* math: PosedShape3D.support is the hottest GJK call
         // (twice per iteration of the body-level fallback, once per
         // triangle for concave dispatch). V8 declines to inline
-        // v3_quat3_apply at 9-arg call sites, so the math is repeated
+        // v3_quaternion_apply at 9-arg call sites, so the math is repeated
         // inline here at the cost of ~7 extra lines per direction.
-        // See core/geom/vec3/v3_quat3_apply.js for the canonical form
+        // See core/geom/vec3/v3_quaternion_apply.js for the canonical form
         // — this is a literal expansion of it.
         const dx = direction[direction_offset];
         const dy = direction[direction_offset + 1];

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

@@ -1 +1 @@
-{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH;IAwEI;;;;;OAKG;IACH,wBAHW,eAAe,MADf,MAAM,EAAE,GAAC,YAAY,OAAK,GAExB,kBAAkB,CAS9B;IAED;;;;;OAKG;IACH,uCAJW,eAAe,eACf,MAAM,EAAE,SACR,MAAM,EAAE,sBAiBlB;IAED;;;;OAIG;IACH,iCAHW,eAAe,eACf,MAAM,EAAE,sBAIlB;IAED;;;;;OAKG;IACH,2BAHW,eAAe,SACf,MAAM,EAAE,GAAC,YAAY,OAAK,GAFxB,kBAAkB,CAM9B;IA9HD;;;;OAIG;IACH,iBAAgC;IAEhC;;;OAGG;IACH,yBAAwC;IAExC;;;;OAIG;IACH,kBAAiB;IAEjB;;;;;;;;OAQG;IACH,wBAAsC;IAEtC;;;;OAIG;IACH,4BAA0C;IAE1C;;;;;OAKG;IACH,sBAAoC;IAEpC;;;;OAIG;IACH,sBAA2B;IAE3B;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,+BAIC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;;;OAOG;IACH,sCAEC;IAYD,wCASC;IAED,mEA2DC;IAED,6CAGC;IAED,oCAOC;IAED,kFAMC;IAED,sFAmDC;IAqGD;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;IAQL;;;;;OAKG;IACH,+BAFU,OAAO,CAEgC;CARhD;gCA7b+B,sBAAsB"}
+{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH;IAwEI;;;;;OAKG;IACH,wBAHW,eAAe,MADf,MAAM,EAAE,GAAC,YAAY,OAAK,GAExB,kBAAkB,CAS9B;IAED;;;;;OAKG;IACH,uCAJW,eAAe,eACf,MAAM,EAAE,SACR,MAAM,EAAE,sBAiBlB;IAED;;;;OAIG;IACH,iCAHW,eAAe,eACf,MAAM,EAAE,sBAIlB;IAED;;;;;OAKG;IACH,2BAHW,eAAe,SACf,MAAM,EAAE,GAAC,YAAY,OAAK,GAFxB,kBAAkB,CAM9B;IA9HD;;;;OAIG;IACH,iBAAgC;IAEhC;;;OAGG;IACH,yBAAwC;IAExC;;;;OAIG;IACH,kBAAiB;IAEjB;;;;;;;;OAQG;IACH,wBAAsC;IAEtC;;;;OAIG;IACH,4BAA0C;IAE1C;;;;;OAKG;IACH,sBAAoC;IAEpC;;;;OAIG;IACH,sBAA2B;IAE3B;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,+BAIC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;;;OAOG;IACH,sCAEC;IAYD,wCASC;IAED,mEA8DC;IAED,6CAGC;IAED,oCAOC;IAED,kFAMC;IAED,sFAmDC;IAqGD;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;IAQL;;;;;OAKG;IACH,+BAFU,OAAO,CAEgC;CARhD;gCAhc+B,sBAAsB"}

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

@@ -228,16 +228,19 @@ export class TransformedShape3D extends AbstractShape3D {
         const m32 = m[9];
         const m33 = m[10];
 
-        const scale_x = v3_length(m11, m12, m13);
-        const scale_y = v3_length(m21, m22, m23);
-        const scale_z = v3_length(m31, m32, m33);
+        const gx = subject_point[0];
+        const gy = subject_point[1];
+        const gz = subject_point[2];
 
-        const scaled_gx = subject_point[0] * scale_x;
-        const scaled_gy = subject_point[1] * scale_y;
-        const scaled_gz = subject_point[2] * scale_z;
+
+
+        const scaled_gx = m11 * gx + m21 * gy + m31 * gz;
+        const scaled_gy = m12 * gx + m22 * gy + m32 * gz;
+        const scaled_gz = m13 * gx + m23 * gy + m33 * gz;
 
         // normalize gradient
-        const gd = distance / v3_length(subject_point[0], subject_point[1], subject_point[2]);
+        const g_len = v3_length(gx, gy, gz);
+        const gd = g_len > 0 ? distance / g_len : 0;
 
         const scaled_dx = scaled_gx * gd;
         const scaled_dy = scaled_gy * gd;

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

@@ -1 +1 @@
-{"version":3,"file":"UnionShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/UnionShape3D.js"],"names":[],"mappings":"AAkCA;IAiJI;;;;OAIG;IACH,sBAHW,eAAe,EAAE,GACf,YAAY,CAYxB;IA/JD;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,kCAA+B;IAE/B,qBAAkB;IAClB,qBAAmB;IACnB,uBAAqB;IAErB;;;;;;OAMG;IACH,oBAAkC;IAElC;;;OAGG;IACH,oBAAyB;IAEzB,wCAgCC;IAED;;;OAGG;IACH,mCAkBC;IAED;;;OAGG;IACH,2CA+CC;IA2DD,mEAEC;IAED,6CAaC;IAED,oCAYC;IAED,kFAoDC;IAED,sFAqDC;IA+DD;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;IA6BL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;CApBpC;gCAnc+B,sBAAsB"}
+{"version":3,"file":"UnionShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/UnionShape3D.js"],"names":[],"mappings":"AAkCA;IAiJI;;;;OAIG;IACH,sBAHW,eAAe,EAAE,GACf,YAAY,CAYxB;IA/JD;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,kCAA+B;IAE/B,qBAAkB;IAClB,qBAAmB;IACnB,uBAAqB;IAErB;;;;;;OAMG;IACH,oBAAkC;IAElC;;;OAGG;IACH,oBAAyB;IAEzB,wCAgCC;IAED;;;OAGG;IACH,mCAkBC;IAED;;;OAGG;IACH,2CA+CC;IA2DD,mEAEC;IAED,6CAaC;IAED,oCAYC;IAED,kFA0DC;IAED,sFAqDC;IA+DD;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;IA6BL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;CApBpC;gCAzc+B,sBAAsB"}

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

@@ -267,7 +267,10 @@ export class UnionShape3D extends AbstractShape3D {
         return false;
     }
 
-    sample_random_point_in_volume(result, result_offset, random) {
+    sample_random_point_in_volume(result, result_offset, random) {
+        if (this.__volume_sum === -1) {
+            this.__compute_volume_variables();
+        }
         const children = this.children;
         const child_count = children.length;
 
@@ -284,7 +287,10 @@ export class UnionShape3D extends AbstractShape3D {
         for (i = 0; i < SAMPLE_REJECTION_ATTEMPT_MAX; i++) {
 
             // sample shape
-            child.sample_random_point_in_volume(result, result_offset, random);
+            child.sample_random_point_in_volume(result, result_offset, random);
+            scratch_direction[0] = result[result_offset];
+            scratch_direction[1] = result[result_offset + 1];
+            scratch_direction[2] = result[result_offset + 2];
 
             /*
             because underlying shapes can overlap and we wish to offer a union, just returning the sample would result in over-sampling in areas where shapes overlap
@@ -300,7 +306,7 @@ export class UnionShape3D extends AbstractShape3D {
                     continue;
                 }
 
-                if (child_1.contains_point(result)) {
+                if (child_1.contains_point(scratch_direction)) {
                     collision_count++;
                 }
             }

package/src/core/geom/3d/shape/json/shape_to_type.js

@@ -4,7 +4,7 @@ import { PlaneShape3D } from "../PlaneShape3D.js";
 import { SphereShape3D } from "../SphereShape3D.js";
 import { TransformedShape3D } from "../TransformedShape3D.js";
 import { UnionShape3D } from "../UnionShape3D.js";
-import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
+import { BoxShape3D } from "../BoxShape3D.js";
 
 /**
  *
@@ -14,7 +14,7 @@ import { UnitCubeShape3D } from "../UnitCubeShape3D.js";
 export function shape_to_type(shape) {
     if (shape instanceof UnionShape3D) {
         return 'union';
-    } else if (shape instanceof UnitCubeShape3D) {
+    } else if (shape instanceof BoxShape3D) {
         return 'cube';
     } else if (shape instanceof SphereShape3D) {
         // Covers UnitSphereShape3D (radius 1) and SphereShape3D (arbitrary);

package/src/core/geom/3d/sphere/harmonics/SH3_COEFFICIENTS.js

@@ -1,17 +1,17 @@
-/**
- * @readonly
- * @type {Float32Array}
- */
-export const SH3_COEFFICIENTS = new Float32Array([
-    0.28209479177387814,    // 0: 0  0
-
-    -0.4886025119029199,    // 1: 1 -1
-    0.4886025119029199,     // 2: 1  0
-    -0.4886025119029199,    // 3: 1  1
-
-    1.0925484305920792,     // 4: 2 -2
-    -1.0925484305920792,    // 5: 2 -1
-    0.31539156525252005,    // 6: 2  0
-    -1.0925484305920792,    // 7: 2  1
-    0.5462742152960396      // 8: 2  2
-]);
+/**
+ * @readonly
+ * @type {Float32Array}
+ */
+export const SH3_COEFFICIENTS = new Float32Array([
+    0.28209479177387814,    // 0: 0  0
+
+    0.4886025119029199,     // 1: 1 -1
+    0.4886025119029199,     // 2: 1  0
+    0.4886025119029199,     // 3: 1  1
+
+    1.0925484305920792,     // 4: 2 -2
+    1.0925484305920792,     // 5: 2 -1
+    0.31539156525252005,    // 6: 2  0
+    1.0925484305920792,     // 7: 2  1
+    0.5462742152960396      // 8: 2  2
+]);

package/src/core/geom/3d/sphere/sphere_matrix4_transform.d.ts

@@ -5,11 +5,4 @@
  * @param {number[]|Float32Array} mat4
  */
 export function sphere_matrix4_transform(result: number[] | Float32Array, sphere: number[] | Float32Array, mat4: number[] | Float32Array): void;
-/**
- *
- * @param {number[]|Float32Array} result
- * @param {number[]|Float32Array} sphere
- * @param {number[]|Float32Array} mat4
- */
-export function sphere_matrix4_project(result: number[] | Float32Array, sphere: number[] | Float32Array, mat4: number[] | Float32Array): void;
 //# sourceMappingURL=sphere_matrix4_transform.d.ts.map

package/src/core/geom/3d/sphere/sphere_matrix4_transform.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sphere_matrix4_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/sphere_matrix4_transform.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,iDAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,EAAE,GAAC,YAAY,QAqB/B;AAzBD;;;;;GAKG;AACH,+CAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,EAAE,GAAC,YAAY,QAqB/B"}
+{"version":3,"file":"sphere_matrix4_transform.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/sphere/sphere_matrix4_transform.js"],"names":[],"mappings":"AAEA;;;;;GAKG;AACH,iDAJW,MAAM,EAAE,GAAC,YAAY,UACrB,MAAM,EAAE,GAAC,YAAY,QACrB,MAAM,EAAE,GAAC,YAAY,QAqB/B"}

package/src/core/geom/3d/sphere/sphere_matrix4_transform.js

@@ -26,7 +26,3 @@ export function sphere_matrix4_transform(
     result[3] = sphere[3] * max_scale;
 
 }
-/**
- * @deprecated Renamed to {@link sphere_matrix4_transform} ("project" was a misnomer; it transforms centre + radius).
- */
-export const sphere_matrix4_project = sphere_matrix4_transform;

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

@@ -1 +1 @@
-{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAsBI;;;OAGG;IACH,2BAFW,MAAM,EAgChB;IAvDD;;;;OAIG;IACH,mBAAe;IAEf;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IASf;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAIlC;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,QAAM,uBAavD;IAED;;;;OAIG;IACH,WAFY,MAAM,EAAE,CAYnB;IAED;;;OAGG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,QAFY,MAAM,CAMjB;IAED;;;;OAIG;IACH,oBAEC;IAGD;;;;OAIG;IACH,qBAYC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CA4BjB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAkElB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAYjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAUhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BA7xB4B,iCAAiC"}
+{"version":3,"file":"TetrahedralMesh.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/TetrahedralMesh.js"],"names":[],"mappings":"AAiBA;;;;GAIG;AACH,qCAFU,MAAM,CAEkD;AAElE;;;GAGG;AACH,gCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH,4BAFU,MAAM,CAEwB;AAoBxC;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH;IAsBI;;;OAGG;IACH,2BAFW,MAAM,EAgChB;IAvDD;;;;OAIG;IACH,mBAAe;IAEf;;;;OAIG;IACH,eAAY;IAEZ;;;;OAIG;IACH,uBAAmB;IASf;;;;OAIG;IACH,iBAAsE;IAEtE;;;;OAIG;IACH,sBAAmD;IAEnD;;;;OAIG;IACH,eAAyC;IAEzC;;;;OAIG;IACH,mBAA8B;IAIlC;;;;;OAKG;IACH,+BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;OAIG;IACH,iBAHY,CAAC,MAAM,EAAE,MAAM,EAAE,IAAI,EAAE,eAAe,QAAM,uBAavD;IAED;;;;OAIG;IACH,WAFY,MAAM,EAAE,CAYnB;IAED;;;OAGG;IACH,cAWC;IAED;;;OAGG;IACH,sBAFW,MAAM,QA8BhB;IAED;;;OAGG;IACH,eAFY,MAAM,CAIjB;IAED;;;;OAIG;IACH,QAFY,MAAM,CAMjB;IAED;;;;OAIG;IACH,oBAEC;IAGD;;;;OAIG;IACH,qBAYC;IAED;;;OAGG;IACH,yBAFW,MAAM,QAWhB;IAED;;;;OAIG;IACH,YAHW,MAAM,GACL,OAAO,CAiBlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,mBACN,MAAM,aACN,MAAM,QAchB;IAGD;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,GACJ,MAAM,CAYlB;IAED;;;;;OAKG;IACH,0BAJW,MAAM,eACN,MAAM,UACN,MAAM,QAiBhB;IAED;;;;;OAKG;IACH,uBAJW,MAAM,UACN,MAAM,GACL,OAAO,CAUlB;IAGD;;;;OAIG;IACH,YAFY,MAAM,CAgCjB;IAED;;;;;;;OAOG;IACH,UANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAqBlB;IAED;;;;OAIG;IACH,wBAFW,MAAM,QAmBhB;IAED;;;;OAIG;IACH,oBAFW,MAAM,QAmBhB;IAED;;;;;OAKG;IACH,2CAHW,MAAM,aACN,MAAM,QAwBhB;IAED;;;;;;;;OAQG;IACH,8BAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,EAAE,sBACR,MAAM,GACJ,MAAM,CAkElB;IAGD;;;;;OAKG;IACH,uBAHW,MAAM,qBACN,MAAM,QA0ChB;IAED;;;;OAIG;IACH,WAFa,MAAM,CA2ClB;IAED;;;OAGG;IACH,kBAFW,YAAY,QAUtB;IAED;;;OAGG;IACH,oBAFW,YAAY,QAiBtB;IAED;;;OAGG;IACH,oBAFY,MAAM,CAYjB;IAED;;;OAGG;IACH,wBAFW,MAAM,QAUhB;IAGL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;6BAjyB4B,iCAAiC"}

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

@@ -196,7 +196,7 @@ export class TetrahedralMesh {
     clear() {
 
         // clear data
-        this.__data_uint32.fill(0, 0, this.__used_end);
+        this.__data_uint32.fill(0, 0, this.__used_end * LAYOUT_TETRA_WORD_COUNT);
 
         // reset metadata
         this.__used_end = 0;
@@ -430,7 +430,11 @@ export class TetrahedralMesh {
     allocate() {
         if (this.__free_pointer > 0) {
             this.__free_pointer--;
-            return this.__free[this.__free_pointer];
+            const tetra_index = this.__free[this.__free_pointer];
+            for (let i = 0; i < 4; i++) {
+                this.setNeighbour(tetra_index, i, INVALID_NEIGHBOUR);
+            }
+            return tetra_index;
         }
 
         const tetra_index = this.__used_end;

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":"AAmGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6FAJW,UAAU,MAAM,CAAC,GAAC,YAAY,4BAE5B;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAsD3C"}
+{"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":"AAoGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,6FAJW,UAAU,MAAM,CAAC,GAAC,YAAY,4BAE5B;IAAC,OAAO,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAsD3C"}

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

@@ -1,4 +1,5 @@
-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 { bt_mesh_build_face_bvh } from "../topology/struct/binary/query/bt_mesh_build_face_bvh.js";
+import { 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";
@@ -125,7 +126,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();
-    bt_mesh_build_surface_triangle_bvh(surface_bvh, surface);
+    bt_mesh_build_face_bvh(surface_bvh, surface);
 
     const live_tets = tet_mesh.getLive();
     const live_count = live_tets.length;

package/src/core/geom/3d/tetrahedra/tetrahedral_mesh_compute_tet_quality.d.ts

@@ -2,7 +2,7 @@
  * Mesh-form wrapper for {@link tetrahedron_compute_quality}: fetches the 4
  * vertex IDs of `tet` and forwards to the indexed primitive.
  *
- * Sibling of {@link compute_tetrahedron_volume}; same convention (the
+ * Sibling of {@link tetrahedral_mesh_compute_tet_volume}; same convention (the
  * `compute_*` prefix marks the mesh-bound form, the `tetrahedron_compute_*`
  * prefix marks the indexed primitive).
  *

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

@@ -4,7 +4,7 @@ import { tetrahedron_compute_quality } from "./tetrahedron_compute_quality.js";
  * Mesh-form wrapper for {@link tetrahedron_compute_quality}: fetches the 4
  * vertex IDs of `tet` and forwards to the indexed primitive.
  *
- * Sibling of {@link compute_tetrahedron_volume}; same convention (the
+ * Sibling of {@link tetrahedral_mesh_compute_tet_volume}; same convention (the
  * `compute_*` prefix marks the mesh-bound form, the `tetrahedron_compute_*`
  * prefix marks the indexed primitive).
  *

package/src/core/geom/3d/tetrahedra/tetrahedron_compute_quality.d.ts

@@ -18,7 +18,7 @@
  *
  * Indexed form (not mesh-bound) so callers can score hypothetical tets
  * during a flip-candidate search without committing the flip first. The
- * existing mesh-form wrapper {@link compute_tetrahedron_quality} fetches
+ * existing mesh-form wrapper {@link tetrahedral_mesh_compute_tet_quality} fetches
  * the four vertex IDs and forwards here.
  *
  * @param {ArrayLike<number>} points flat (x,y,z) positions

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

@@ -24,7 +24,7 @@ const circ_scratch = new Float64Array(4);
  *
  * Indexed form (not mesh-bound) so callers can score hypothetical tets
  * during a flip-candidate search without committing the flip first. The
- * existing mesh-form wrapper {@link compute_tetrahedron_quality} fetches
+ * existing mesh-form wrapper {@link tetrahedral_mesh_compute_tet_quality} fetches
  * the four vertex IDs and forwards here.
  *
  * @param {ArrayLike<number>} points flat (x,y,z) positions

package/src/core/geom/3d/tetrahedra/tetrahedron_contains_point.d.ts

@@ -1,3 +1,21 @@
+/**
+ * Containment test, whether tetrahedron defined by vertex indices A,B,C,D contains point (ex, ey, ez) or not.
+ * Implemented using planar tests on each side of the tetrahedron.
+ *
+ * Winding-agnostic: the point is interior when it lies on the same side of all four faces,
+ * whatever sign that side carries. A zero counts as inside under either sign, so a point on a face is contained.
+ *
+ * @param {number[]|Float32Array|Float64Array} points
+ * @param {number} a
+ * @param {number} b
+ * @param {number} c
+ * @param {number} d
+ * @param {number} ex
+ * @param {number} ey
+ * @param {number} ez
+ * @returns {boolean}
+ */
+export function tetrahedron_contains_point_coords(points: number[] | Float32Array | Float64Array, a: number, b: number, c: number, d: number, ex: number, ey: number, ez: number): boolean;
 /**
  * Containment test, whether tetrahedron defined by A,B,C,D contains point E or not
  * Implemented using planar tests on each of side of the tetrahedron
@@ -6,7 +24,7 @@
  *          We skip identity checks and bounding box checks. Identity is a waste of time when building tetrahedral mesh,
  *          since each inserted point will be new to the mesh, box checks are not relevant as we don't track those
  *
- * @param {number[]} points
+ * @param {number[]|Float32Array|Float64Array} points
  * @param {number} a
  * @param {number} b
  * @param {number} c
@@ -14,5 +32,5 @@
  * @param {number} e
  * @returns {boolean}
  */
-export function tetrahedron_contains_point(points: number[], a: number, b: number, c: number, d: number, e: number): boolean;
+export function tetrahedron_contains_point(points: number[] | Float32Array | Float64Array, a: number, b: number, c: number, d: number, e: number): boolean;
 //# sourceMappingURL=tetrahedron_contains_point.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"tetrahedron_contains_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_contains_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH,mDARW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAoBnB"}
+{"version":3,"file":"tetrahedron_contains_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/tetrahedra/tetrahedron_contains_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;GAgBG;AACH,0DAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAYnB;AAED;;;;;;;;;;;;;;;GAeG;AACH,mDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAMnB"}