@woosh/meep-engine 3.56.0 → 3.57.0

package/src/core/geom/3d/plane/plane3_slerp.js

@@ -1,102 +1,87 @@
-import { lerp } from "../../../math/lerp.js";
-import Vector3 from "../../Vector3.js";
-import { v3_dot } from "../../vec3/v3_dot.js";
-import { v3_length_sqr } from "../../vec3/v3_length_sqr.js";
-import { v3_slerp } from "../../vec3/v3_slerp.js";
-import { EPSILON } from "../../../math/EPSILON.js";
-
-const e = new Vector3();
-
-const point = new Vector3();
-
-const v0 = new Vector3();
-const v1 = new Vector3();
-
-/**
- * @see https://stackoverflow.com/a/57824137
- * @param {number[]} destination
- * @param {number} destination_offset
- * @param {number} a_normal_x
- * @param {number} a_normal_y
- * @param {number} a_normal_z
- * @param {number} a_constant
- * @param {number} b_normal_x
- * @param {number} b_normal_y
- * @param {number} b_normal_z
- * @param {number} b_constant
- * @param {number} t
- */
-export function plane3_slerp(
-    destination, destination_offset,
-    a_normal_x, a_normal_y, a_normal_z, a_constant,
-    b_normal_x, b_normal_y, b_normal_z, b_constant,
-    t
-) {
-
-    // The common line of the two planes is along the (non-unit) direction
-    e._crossVectors(
-        a_normal_x, a_normal_y, a_normal_z,
-        b_normal_x, b_normal_y, b_normal_z
-    );
-
-    const determinant = v3_length_sqr(e.x, e.y, e.z);
-
-    if (determinant < EPSILON) {
-        // no intersection, planes are parallel
-
-        // determine if planes are facing the same direction or not
-        const d = v3_dot(
-            a_normal_x, a_normal_y, a_normal_z,
-            b_normal_x, b_normal_y, b_normal_z
-        );
-
-        // if planes are parallel, we assume normal of one of the planes
-        destination[destination_offset] = a_normal_x;
-        destination[destination_offset + 1] = a_normal_y;
-        destination[destination_offset + 2] = a_normal_z;
-
-        destination[destination_offset + 3] = lerp(a_constant, b_constant * d, t);
-
-        return;
-    }
-
-    v0._crossVectors(
-        a_normal_x, a_normal_y, a_normal_z,
-        e.x, e.y, e.z
-    );
-    v0.multiplyScalar(b_constant);
-
-    v1._crossVectors(
-        b_normal_x, b_normal_y, b_normal_z,
-        e.x, e.y, e.z
-    );
-    v1.multiplyScalar(a_constant);
-
-    // The point on this line closest to the origin
-    // point = (d_1*cross(n_2,e)-d_2*cross(n_1,e))/dot(e.e)
-    point.subVectors(v0, v1);
-
-
-    const inv_determinant = 1 / determinant;
-
-    point.multiplyScalar(inv_determinant);
-
-    // compute normal
-    v3_slerp(
-        v0,
-        a_normal_x, a_normal_y, a_normal_z,
-        b_normal_x, b_normal_y, b_normal_z,
-        t
-    );
-
-    // compute distance (constant)
-    const d = v3_dot(
-        v0.x, v0.y, v0.z,
-        point.x, point.y, point.z
-    );
-
-    destination[destination_offset] = v0.x;
-    destination[destination_offset + 1] = v0.y;
-    destination[destination_offset + 2] = v0.z;
-    destination[destination_offset + 3] = -d;
-}
+import { EPSILON } from "../../../math/EPSILON.js";
+import { lerp } from "../../../math/lerp.js";
+import Vector3 from "../../Vector3.js";
+import { v3_dot } from "../../vec3/v3_dot.js";
+import { v3_length_sqr } from "../../vec3/v3_length_sqr.js";
+import { v3_slerp } from "../../vec3/v3_slerp.js";
+import { plane3_compute_intersection } from "./plane3_compute_intersection.js";
+
+const e = new Vector3();
+
+const point = new Vector3();
+
+const v0 = new Vector3();
+
+/**
+ * @see https://stackoverflow.com/a/57824137
+ * @param {number[]} destination
+ * @param {number} destination_offset
+ * @param {number} a_normal_x
+ * @param {number} a_normal_y
+ * @param {number} a_normal_z
+ * @param {number} a_constant
+ * @param {number} b_normal_x
+ * @param {number} b_normal_y
+ * @param {number} b_normal_z
+ * @param {number} b_constant
+ * @param {number} t
+ */
+export function plane3_slerp(
+    destination, destination_offset,
+    a_normal_x, a_normal_y, a_normal_z, a_constant,
+    b_normal_x, b_normal_y, b_normal_z, b_constant,
+    t
+) {
+
+    // The common line of the two planes is along the (non-unit) direction
+    e._crossVectors(
+        a_normal_x, a_normal_y, a_normal_z,
+        b_normal_x, b_normal_y, b_normal_z
+    );
+
+    const determinant = v3_length_sqr(e.x, e.y, e.z);
+
+    if (determinant < EPSILON) {
+        // no intersection, planes are parallel
+
+        // determine if planes are facing the same direction or not
+        const d = v3_dot(
+            a_normal_x, a_normal_y, a_normal_z,
+            b_normal_x, b_normal_y, b_normal_z
+        );
+
+        // if planes are parallel, we assume normal of one of the planes
+        destination[destination_offset] = a_normal_x;
+        destination[destination_offset + 1] = a_normal_y;
+        destination[destination_offset + 2] = a_normal_z;
+
+        destination[destination_offset + 3] = lerp(a_constant, b_constant * d, t);
+
+        return;
+    }
+
+    plane3_compute_intersection(
+        point, e,
+        a_normal_x, a_normal_y, a_normal_z, a_constant,
+        b_normal_x, b_normal_y, b_normal_z, b_constant
+    );
+
+    // compute normal
+    v3_slerp(
+        v0,
+        a_normal_x, a_normal_y, a_normal_z,
+        b_normal_x, b_normal_y, b_normal_z,
+        t
+    );
+
+    // compute distance (constant)
+    const d = v3_dot(
+        v0.x, v0.y, v0.z,
+        point.x, point.y, point.z
+    );
+
+    destination[destination_offset] = v0.x;
+    destination[destination_offset + 1] = v0.y;
+    destination[destination_offset + 2] = v0.z;
+    destination[destination_offset + 3] = -d;
+}

package/src/core/geom/3d/polygon/polygon3_compute_normal.d.ts

@@ -24,4 +24,16 @@
  * @copyright Company Named Limited (c) 2026
  */
 export function polygon3_compute_normal(result: ArrayLike<number>, result_offset: number, points: ArrayLike<number>, from: number, count: number): void;
+/**
+ * Newell's method on an indexed 3D polygon contour `indices[from .. from + count - 1]`,
+ * written to `result` at `result_offset` as a unit vector (or `(0, 0, 0)` when degenerate).
+ *
+ * @param {ArrayLike<number>} result
+ * @param {number} result_offset
+ * @param {ArrayLike<number>} points flat (x, y, z) triples, stride 3
+ * @param {ArrayLike<number>} indices vertex indices into `points`
+ * @param {number} from first index into `indices`
+ * @param {number} count number of vertices in the contour
+ */
+export function polygon3_compute_normal_indexed(result: ArrayLike<number>, result_offset: number, points: ArrayLike<number>, indices: ArrayLike<number>, from: number, count: number): void;
 //# sourceMappingURL=polygon3_compute_normal.d.ts.map

package/src/core/geom/3d/polygon/polygon3_compute_normal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"polygon3_compute_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/polygon/polygon3_compute_normal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,gDATW,UAAU,MAAM,CAAC,iBACjB,MAAM,UACN,UAAU,MAAM,CAAC,QACjB,MAAM,SACN,MAAM,QAuChB"}
+{"version":3,"file":"polygon3_compute_normal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/polygon/polygon3_compute_normal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH,gDATW,UAAU,MAAM,CAAC,iBACjB,MAAM,UACN,UAAU,MAAM,CAAC,QACjB,MAAM,SACN,MAAM,QAuChB;AAED;;;;;;;;;;GAUG;AACH,wDAPW,UAAU,MAAM,CAAC,iBACjB,MAAM,UACN,UAAU,MAAM,CAAC,WACjB,UAAU,MAAM,CAAC,QACjB,MAAM,SACN,MAAM,QAoChB"}

package/src/core/geom/3d/polygon/polygon3_compute_normal.js

@@ -1,60 +1,107 @@
-/**
- * Newell's method: the area-weighted normal of an arbitrary 3D polygon, written
- * to `result` at `result_offset` as a unit vector.
- *
- * Unlike taking the cross product of the first three vertices
- * (what {@link bt_mesh_compute_face_normals} does, correctly, for triangles),
- * this is defined for any vertex count, is immune to a collinear or coincident
- * leading triple, and for a non-planar polygon returns the normal of its
- * best-fit plane rather than of one arbitrary corner. That is exactly what
- * projecting an n-gon down to 2D needs.
- *
- * A polygon with no area -- fewer than three vertices, all collinear, or all
- * coincident -- has no normal; `result` is then written as `(0, 0, 0)`, which
- * callers can test with a length check. That is a real outcome of real data, not
- * an error.
- *
- * @param {ArrayLike<number>} result
- * @param {number} result_offset
- * @param {ArrayLike<number>} points flat (x, y, z) triples, stride 3
- * @param {number} from first vertex index of the contour
- * @param {number} count number of vertices in the contour
- *
- * @author Alex Goldring
- * @copyright Company Named Limited (c) 2026
- */
-export function polygon3_compute_normal(result, result_offset, points, from, count) {
-    let nx = 0;
-    let ny = 0;
-    let nz = 0;
-
-    const to = from + count;
-
-    for (let i = from; i < to; i++) {
-        const j = (i + 1 === to) ? from : i + 1;
-
-        const i3 = i * 3;
-        const j3 = j * 3;
-
-        const ax = points[i3], ay = points[i3 + 1], az = points[i3 + 2];
-        const bx = points[j3], by = points[j3 + 1], bz = points[j3 + 2];
-
-        nx += (ay - by) * (az + bz);
-        ny += (az - bz) * (ax + bx);
-        nz += (ax - bx) * (ay + by);
-    }
-
-    const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
-
-    if (length === 0) {
-        result[result_offset] = 0;
-        result[result_offset + 1] = 0;
-        result[result_offset + 2] = 0;
-
-        return;
-    }
-
-    result[result_offset] = nx / length;
-    result[result_offset + 1] = ny / length;
-    result[result_offset + 2] = nz / length;
-}
+/**
+ * Newell's method: the area-weighted normal of an arbitrary 3D polygon, written
+ * to `result` at `result_offset` as a unit vector.
+ *
+ * Unlike taking the cross product of the first three vertices
+ * (what {@link bt_mesh_compute_face_normals} does, correctly, for triangles),
+ * this is defined for any vertex count, is immune to a collinear or coincident
+ * leading triple, and for a non-planar polygon returns the normal of its
+ * best-fit plane rather than of one arbitrary corner. That is exactly what
+ * projecting an n-gon down to 2D needs.
+ *
+ * A polygon with no area -- fewer than three vertices, all collinear, or all
+ * coincident -- has no normal; `result` is then written as `(0, 0, 0)`, which
+ * callers can test with a length check. That is a real outcome of real data, not
+ * an error.
+ *
+ * @param {ArrayLike<number>} result
+ * @param {number} result_offset
+ * @param {ArrayLike<number>} points flat (x, y, z) triples, stride 3
+ * @param {number} from first vertex index of the contour
+ * @param {number} count number of vertices in the contour
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function polygon3_compute_normal(result, result_offset, points, from, count) {
+    let nx = 0;
+    let ny = 0;
+    let nz = 0;
+
+    const to = from + count;
+
+    for (let i = from; i < to; i++) {
+        const j = (i + 1 === to) ? from : i + 1;
+
+        const i3 = i * 3;
+        const j3 = j * 3;
+
+        const ax = points[i3], ay = points[i3 + 1], az = points[i3 + 2];
+        const bx = points[j3], by = points[j3 + 1], bz = points[j3 + 2];
+
+        nx += (ay - by) * (az + bz);
+        ny += (az - bz) * (ax + bx);
+        nz += (ax - bx) * (ay + by);
+    }
+
+    const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+
+    if (!(length > 0)) {
+        result[result_offset] = 0;
+        result[result_offset + 1] = 0;
+        result[result_offset + 2] = 0;
+
+        return;
+    }
+
+    result[result_offset] = nx / length;
+    result[result_offset + 1] = ny / length;
+    result[result_offset + 2] = nz / length;
+}
+
+/**
+ * Newell's method on an indexed 3D polygon contour `indices[from .. from + count - 1]`,
+ * written to `result` at `result_offset` as a unit vector (or `(0, 0, 0)` when degenerate).
+ *
+ * @param {ArrayLike<number>} result
+ * @param {number} result_offset
+ * @param {ArrayLike<number>} points flat (x, y, z) triples, stride 3
+ * @param {ArrayLike<number>} indices vertex indices into `points`
+ * @param {number} from first index into `indices`
+ * @param {number} count number of vertices in the contour
+ */
+export function polygon3_compute_normal_indexed(result, result_offset, points, indices, from, count) {
+    let nx = 0;
+    let ny = 0;
+    let nz = 0;
+
+    const to = from + count;
+
+    for (let i = from; i < to; i++) {
+        const j = (i + 1 === to) ? from : i + 1;
+
+        const i3 = indices[i] * 3;
+        const j3 = indices[j] * 3;
+
+        const ax = points[i3], ay = points[i3 + 1], az = points[i3 + 2];
+        const bx = points[j3], by = points[j3 + 1], bz = points[j3 + 2];
+
+        nx += (ay - by) * (az + bz);
+        ny += (az - bz) * (ax + bx);
+        nz += (ax - bx) * (ay + by);
+    }
+
+    const length = Math.sqrt(nx * nx + ny * ny + nz * nz);
+
+    if (!(length > 0)) {
+        result[result_offset] = 0;
+        result[result_offset + 1] = 0;
+        result[result_offset + 2] = 0;
+
+        return;
+    }
+
+    result[result_offset] = nx / length;
+    result[result_offset + 1] = ny / length;
+    result[result_offset + 2] = nz / length;
+}

package/src/core/geom/3d/ray/ray3_compute_closest_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ray3_compute_closest_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_compute_closest_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,sEAXW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CA4BlB"}
+{"version":3,"file":"ray3_compute_closest_point.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/ray3_compute_closest_point.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH,sEAXW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAsBlB"}

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/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";
@@ -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/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"}