@woosh/meep-engine 2.163.10 → 2.164.0

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

@@ -100,12 +100,47 @@ export class MeshShape3D extends AbstractShape3D {
      * @type {number}
      */
     private __surface_area;
+    /**
+     * Lazily-built surface-triangle BVH for {@link raycast} (distinct from {@link tet_bvh}, which
+     * keys the interior tets). Built on the first ray query from `positions` / `indices`; null until
+     * then. Mutating the surface invalidates it (set back to null to rebuild).
+     * @private
+     * @type {BVH|null}
+     */
+    private __raycast_blas;
     compute_bounding_box(result: any): void;
     /**
-     * Refresh the cached bounding box, volume, and surface area from the
-     * current `positions` / `indices` / `tet_mesh`. Called by
-     * {@link shape_mesh_from_geometry} at construction; call again after
-     * mutating the underlying data.
+     * Nearest surface hit of `ray` (local frame) within `ray[6]` (tMax), writing
+     * `[px,py,pz, nx,ny,nz]` into `hit`. Two intentional divergences from the
+     * analytic sphere/box/capsule shapes, both stemming from a triangle mesh
+     * having no guaranteed winding and no closed form:
+     *
+     *  - NORMAL: the face normal is flipped to face the incoming ray, so an
+     *    EXTERNAL hit yields the outward surface normal regardless of winding.
+     *    For a ray originating INSIDE a closed mesh the reported normal therefore
+     *    points back toward the ray (i.e. inward), where the analytic shapes
+     *    would report the true outward normal of the exit surface.
+     *  - tMax BOUNDARY: exclusive — a hit at exactly t == tMax is reported as a
+     *    miss (the underlying nearest-triangle query seeds best_t = tMax and only
+     *    accepts strictly nearer hits), whereas the analytic shapes are inclusive
+     *    at tMax. A single-ULP grazing edge; left as-is rather than altering the
+     *    shared `ebvh_geometry_query_nearest_triangle_ray` used across physics.
+     *
+     * Builds an internal BVH over the triangles on first use (lazy), cached on the
+     * shape; {@link recompute_cached} invalidates it after surface mutation.
+     *
+     * @param {Float32Array} hit out: [px,py,pz, nx,ny,nz]
+     * @param {Ray3} ray local-frame ray (unit direction; ray[6] = tMax)
+     * @returns {boolean} whether anything was hit
+     */
+    raycast(hit: Float32Array, ray: Ray3): boolean;
+    /**
+     * 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
+     * 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.
      */
     recompute_cached(): void;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"MeshShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/MeshShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAKQ;;;;;OAKG;IACH,WAFU,YAAY,CAEc;IAEpC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;;OAOG;IACH,UAFU,eAAe,CAEY;IAErC;;;;;;;;OAQG;IACH,eAFU,YAAY,CAEkB;IAExC;;;;;;OAMG;IACH,SAFU,GAAG,CAEW;IAExB;;;;;OAKG;IACH,eAAkD;IAElD;;;;;OAKG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,uBAAuB;IAW3B,wCAIC;IAED;;;;;OAKG;IACH,yBAmDC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,QA0BhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,OAAO,CAyCnB;IAED;;;;;;;;;OASG;IACH,iCAHW,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,EAAE,GAAC,YAAY,QA4C/B;IAED;;;;;;;;OAQG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAsClB;IAED;;;;;;;;;OASG;IACH,sCAJW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,gBACK,MAAM,QAuB3B;IAED;;;;;;OAMG;IACH,0CAJW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAiBlB;IAED;;;;;;OAMG;IACH,cAHW,WAAW,GACT,OAAO,CAanB;IAkBL;;;;OAIG;IACH,wBAFU,OAAO,CAEkB;CAPlC;gCAxe+B,sBAAsB;gCADtB,kCAAkC;oBAJ9C,2BAA2B"}
+{"version":3,"file":"MeshShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/MeshShape3D.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAKQ;;;;;OAKG;IACH,WAFU,YAAY,CAEc;IAEpC;;;;OAIG;IACH,SAFU,WAAW,CAEY;IAEjC;;;;;;;OAOG;IACH,UAFU,eAAe,CAEY;IAErC;;;;;;;;OAQG;IACH,eAFU,YAAY,CAEkB;IAExC;;;;;;OAMG;IACH,SAFU,GAAG,CAEW;IAExB;;;;;OAKG;IACH,eAAkD;IAElD;;;;;OAKG;IACH,iBAAiB;IAEjB;;;;OAIG;IACH,uBAAuB;IAEvB;;;;;;OAMG;IACH,uBAA0B;IAW9B,wCAIC;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,aAJW,YAAY,cAEV,OAAO,CA+DnB;IAED;;;;;;;OAOG;IACH,yBAyDC;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,gBANW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,QA0BhB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GACnB,OAAO,CAyCnB;IAED;;;;;;;;;OASG;IACH,iCAHW,MAAM,EAAE,GAAC,YAAY,aACrB,MAAM,EAAE,GAAC,YAAY,QA4C/B;IAED;;;;;;;;OAQG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAsClB;IAED;;;;;;;;;OASG;IACH,sCAJW,MAAM,EAAE,GAAC,YAAY,iBACrB,MAAM,gBACK,MAAM,QAuB3B;IAED;;;;;;OAMG;IACH,0CAJW,MAAM,EAAE,GAAC,YAAY,SACrB,MAAM,EAAE,GAAC,YAAY,GACnB,MAAM,CAiBlB;IAED;;;;;;OAMG;IACH,cAHW,WAAW,GACT,OAAO,CAanB;IAkBL;;;;OAIG;IACH,wBAFU,OAAO,CAEkB;CAPlC;gCAnlB+B,sBAAsB;gCADtB,kCAAkC;oBAN9C,2BAA2B"}

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

@@ -1,10 +1,15 @@
 import { BVH } from "../../../bvh2/bvh3/BVH.js";
-import { bvh_query_user_data_overlaps_aabb } from "../../../bvh2/bvh3/query/bvh_query_user_data_overlaps_aabb.js";
-import { computeTriangleClosestPointToPointBarycentric } from "../triangle/computeTriangleClosestPointToPointBarycentric.js";
-import { compute_tetrahedron_volume } from "../tetrahedra/compute_tetrahedron_volume.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 { tetrahedral_mesh_compute_tet_volume } from "../tetrahedra/tetrahedral_mesh_compute_tet_volume.js";
 import { TetrahedralMesh } from "../tetrahedra/TetrahedralMesh.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 
+// module-static scratch for the surface-raycast query [triangleIndex, u, v, t]
+const MESH_QUERY_OUT = [0, 0, 0, 0];
+
 /**
  * Arbitrary triangle-mesh collider.
  *
@@ -118,6 +123,15 @@ export class MeshShape3D extends AbstractShape3D {
          * @type {number}
          */
         this.__surface_area = 0;
+
+        /**
+         * Lazily-built surface-triangle BVH for {@link raycast} (distinct from {@link tet_bvh}, which
+         * keys the interior tets). Built on the first ray query from `positions` / `indices`; null until
+         * then. Mutating the surface invalidates it (set back to null to rebuild).
+         * @private
+         * @type {BVH|null}
+         */
+        this.__raycast_blas = null;
     }
 
     get volume() {
@@ -135,10 +149,99 @@ export class MeshShape3D extends AbstractShape3D {
     }
 
     /**
-     * Refresh the cached bounding box, volume, and surface area from the
-     * current `positions` / `indices` / `tet_mesh`. Called by
-     * {@link shape_mesh_from_geometry} at construction; call again after
-     * mutating the underlying data.
+     * Nearest surface hit of `ray` (local frame) within `ray[6]` (tMax), writing
+     * `[px,py,pz, nx,ny,nz]` into `hit`. Two intentional divergences from the
+     * analytic sphere/box/capsule shapes, both stemming from a triangle mesh
+     * having no guaranteed winding and no closed form:
+     *
+     *  - NORMAL: the face normal is flipped to face the incoming ray, so an
+     *    EXTERNAL hit yields the outward surface normal regardless of winding.
+     *    For a ray originating INSIDE a closed mesh the reported normal therefore
+     *    points back toward the ray (i.e. inward), where the analytic shapes
+     *    would report the true outward normal of the exit surface.
+     *  - tMax BOUNDARY: exclusive — a hit at exactly t == tMax is reported as a
+     *    miss (the underlying nearest-triangle query seeds best_t = tMax and only
+     *    accepts strictly nearer hits), whereas the analytic shapes are inclusive
+     *    at tMax. A single-ULP grazing edge; left as-is rather than altering the
+     *    shared `ebvh_geometry_query_nearest_triangle_ray` used across physics.
+     *
+     * Builds an internal BVH over the triangles on first use (lazy), cached on the
+     * shape; {@link recompute_cached} invalidates it after surface mutation.
+     *
+     * @param {Float32Array} hit out: [px,py,pz, nx,ny,nz]
+     * @param {Ray3} ray local-frame ray (unit direction; ray[6] = tMax)
+     * @returns {boolean} whether anything was hit
+     */
+    raycast(hit, ray) {
+        const indices = this.indices;
+
+        if (indices.length === 0) {
+            return false;
+        }
+
+        if (this.__raycast_blas === null) {
+            const blas = new BVH();
+            ebvh_build_for_geometry_morton(blas, indices, this.positions);
+            this.__raycast_blas = blas;
+        }
+
+        const blas = this.__raycast_blas;
+
+        const found = ebvh_geometry_query_nearest_triangle_ray(
+            MESH_QUERY_OUT, 0, blas, blas.root, ray, 0, ray[6], indices, this.positions
+        );
+
+        if (!found) {
+            return false;
+        }
+
+        const t = MESH_QUERY_OUT[3];
+
+        hit[0] = ray[0] + ray[3] * t;
+        hit[1] = ray[1] + ray[4] * t;
+        hit[2] = ray[2] + ray[5] * t;
+
+        // triangle face normal = (b - a) × (c - a), made unit and flipped to face the incoming ray so an
+        // external hit yields the outward surface normal regardless of winding.
+        const positions = this.positions;
+        const triangle = MESH_QUERY_OUT[0] * 3;
+        const a = indices[triangle] * 3;
+        const b = indices[triangle + 1] * 3;
+        const c = indices[triangle + 2] * 3;
+
+        const e1x = positions[b] - positions[a];
+        const e1y = positions[b + 1] - positions[a + 1];
+        const e1z = positions[b + 2] - positions[a + 2];
+        const e2x = positions[c] - positions[a];
+        const e2y = positions[c + 1] - positions[a + 1];
+        const e2z = positions[c + 2] - positions[a + 2];
+
+        let nx = e1y * e2z - e1z * e2y;
+        let ny = e1z * e2x - e1x * e2z;
+        let nz = e1x * e2y - e1y * e2x;
+
+        const len = Math.sqrt(nx * nx + ny * ny + nz * nz);
+        if (len > 0) {
+            const inv = 1 / len;
+            nx *= inv; ny *= inv; nz *= inv;
+        }
+
+        if (nx * ray[3] + ny * ray[4] + nz * ray[5] > 0) {
+            nx = -nx; ny = -ny; nz = -nz;
+        }
+
+        hit[3] = nx; hit[4] = ny; hit[5] = nz;
+
+        return true;
+    }
+
+    /**
+     * 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
+     * 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.
      */
     recompute_cached() {
         const positions = this.positions;
@@ -188,9 +291,15 @@ export class MeshShape3D extends AbstractShape3D {
         const tet_mesh = this.tet_mesh;
         const tet_count = tet_mesh.count;
         for (let t = 0; t < tet_count; t++) {
-            volume_sum += compute_tetrahedron_volume(tet_mesh, tet_positions, t);
+            volume_sum += tetrahedral_mesh_compute_tet_volume(tet_mesh, tet_positions, t);
         }
         this.__volume = Math.abs(volume_sum);
+
+        // the surface changed — drop the lazily-built raycast BVH so the next
+        // raycast rebuilds it against the new positions/indices (its node AABBs
+        // were snapshotted from the old surface and would otherwise prune valid
+        // hits). Matches the invalidation of __bbox / __volume / __surface_area.
+        this.__raycast_blas = null;
     }
 
     /**
@@ -280,7 +389,7 @@ export class MeshShape3D extends AbstractShape3D {
             scratch_candidates = new Uint32Array(this.tet_mesh.count);
         }
 
-        const n = bvh_query_user_data_overlaps_aabb(
+        const n = bvh_query_user_data_intersects_aabb(
             scratch_candidates, 0, this.tet_bvh, scratch_query_aabb
         );
 
@@ -327,7 +436,7 @@ 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];
 
-            computeTriangleClosestPointToPointBarycentric(
+            tri3_closest_point_barycentric(
                 baryc, 0,
                 px, py, pz,
                 ax, ay, az,
@@ -379,7 +488,7 @@ 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];
 
-            computeTriangleClosestPointToPointBarycentric(
+            tri3_closest_point_barycentric(
                 baryc, 0,
                 px, py, pz,
                 ax, ay, az,

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

@@ -26,6 +26,7 @@ export class SphereShape3D extends AbstractShape3D {
      */
     radius: number;
     support(result: any, result_offset: any, direction_x: any, direction_y: any, direction_z: any): void;
+    raycast(hit: any, ray: any): boolean;
     compute_bounding_box(result: any): void;
     nearest_point_on_surface(result: any, reference: any): void;
     signed_distance_gradient_at_point(result: any, point: any): number;

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

@@ -1 +1 @@
-{"version":3,"file":"SphereShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/SphereShape3D.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;GAcG;AACH;IAUI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,aAAa,CAMzB;IAhBG;;;OAGG;IACH,QAFU,MAAM,CAED;IAwBnB,qGAQC;IAED,wCAQC;IAED,4DAaC;IAED,mEAEC;IAED,6CAEC;IAED,oCAOC;IAED,kFAMC;IAED,4BAEC;IAOL;;;;;;;;OAQG;IACH,0BAFU,OAAO,CAEsB;CAXtC;gCApH+B,sBAAsB"}
+{"version":3,"file":"SphereShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/SphereShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH;IAUI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,aAAa,CAMzB;IAhBG;;;OAGG;IACH,QAFU,MAAM,CAED;IAwBnB,qGAQC;IAED,qCAYC;IAED,wCAQC;IAED,4DAaC;IAED,mEAEC;IAED,6CAEC;IAED,oCAOC;IAED,kFAMC;IAED,4BAEC;IAOL;;;;;;;;OAQG;IACH,0BAFU,OAAO,CAEsB;CAXtC;gCAlI+B,sBAAsB"}

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

@@ -1,5 +1,6 @@
 import { computeHashFloat } from "../../../primitives/numbers/computeHashFloat.js";
-import { randomPointInSphere } from "../../random/randomPointInSphere.js";
+import { random_point_in_sphere } from "../../random/random_point_in_sphere.js";
+import { sphere_raycast } from "../sphere/sphere_raycast.js";
 import { v3_length } from "../../vec3/v3_length.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 import { compute_signed_distance_gradient_by_sampling } from "./util/compute_signed_distance_gradient_by_sampling.js";
@@ -60,6 +61,20 @@ export class SphereShape3D extends AbstractShape3D {
         result[result_offset + 2] = direction_z * r;
     }
 
+    raycast(hit, ray) {
+        const t = sphere_raycast(hit, 3, ray[0], ray[1], ray[2], ray[3], ray[4], ray[5], ray[6], this.radius);
+
+        if (t === Infinity) {
+            return false;
+        }
+
+        hit[0] = ray[0] + ray[3] * t;
+        hit[1] = ray[1] + ray[4] * t;
+        hit[2] = ray[2] + ray[5] * t;
+
+        return true;
+    }
+
     compute_bounding_box(result) {
         const r = this.radius;
         result[0] = -r;
@@ -103,7 +118,7 @@ export class SphereShape3D extends AbstractShape3D {
     }
 
     sample_random_point_in_volume(result, result_offset, random) {
-        randomPointInSphere(random, result, result_offset);
+        random_point_in_sphere(random, result, result_offset);
         const r = this.radius;
         result[result_offset] *= r;
         result[result_offset + 1] *= r;

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

@@ -67,9 +67,13 @@ export class TransformedShape3D extends AbstractShape3D {
      * @returns {boolean}
      */
     equals(other: TransformedShape3D): boolean;
-}
-export namespace TransformedShape3D {
-    let isTransformedShape3D: boolean;
+    /**
+     * Brand on the PROTOTYPE (not the constructor) so instance-side dispatch
+     * (`shape.isTransformedShape3D`) works, consistent with every sibling shape.
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isTransformedShape3D: boolean;
 }
 import { AbstractShape3D } from "./AbstractShape3D.js";
 //# sourceMappingURL=TransformedShape3D.d.ts.map

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":"AAwBA;IA4CI;;;;;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;IA/FG;;;;OAIG;IACH,iBAAoC;IAEpC;;;;OAIG;IACH,yBAA4C;IAE5C;;;;OAIG;IACH,kBAAqB;IAGzB;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,4CAIC;IAED,yCAEC;IAUD,wCAKC;IAED,mEAyDC;IAED,6CAEC;IAED,oCAKC;IAED,kFAIC;IAED,qGAwCC;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;CAMJ;;8BAIS,OAAO;;gCA1Re,sBAAsB"}
+{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AAwBA;IA4CI;;;;;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;IA/FG;;;;OAIG;IACH,iBAAoC;IAEpC;;;;OAIG;IACH,yBAA4C;IAE5C;;;;OAIG;IACH,kBAAqB;IAGzB;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,4CAIC;IAED,yCAEC;IAUD,wCAKC;IAED,mEAyDC;IAED,6CAEC;IAED,oCAKC;IAED,kFAIC;IAED,qGAwCC;IAED;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;IAQL;;;;;OAKG;IACH,+BAFU,OAAO,CAEgC;CARhD;gCAtR+B,sBAAsB"}

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

@@ -289,7 +289,9 @@ export class TransformedShape3D extends AbstractShape3D {
 }
 
 /**
+ * Brand on the PROTOTYPE (not the constructor) so instance-side dispatch
+ * (`shape.isTransformedShape3D`) works, consistent with every sibling shape.
  * @readonly
  * @type {boolean}
  */
-TransformedShape3D.isTransformedShape3D = true;
+TransformedShape3D.prototype.isTransformedShape3D = true;

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 computeTriangleClosestPointToPointBarycentric}).
+     * {@link tri3_closest_point_barycentric}).
      */
     signed_distance_at_point(point: any): number;
     nearest_point_on_surface(result: any, reference: any): void;

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 { computeTriangleClosestPointToPointBarycentric } from "../triangle/computeTriangleClosestPointToPointBarycentric.js";
+import { tri3_closest_point_barycentric } from "../triangle/tri3_closest_point_barycentric.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 computeTriangleClosestPointToPointBarycentric}).
+     * {@link tri3_closest_point_barycentric}).
      */
     signed_distance_at_point(point) {
         const b = this.buffer;
@@ -157,7 +157,7 @@ export class Triangle3D extends AbstractShape3D {
 
         const px = point[0]; const py = point[1]; const pz = point[2];
 
-        computeTriangleClosestPointToPointBarycentric(
+        tri3_closest_point_barycentric(
             scratch_bary, 0,
             px, py, pz,
             ax, ay, az,
@@ -201,7 +201,7 @@ 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];
 
-        computeTriangleClosestPointToPointBarycentric(
+        tri3_closest_point_barycentric(
             scratch_bary, 0,
             reference[0], reference[1], reference[2],
             ax, ay, az,
@@ -310,7 +310,7 @@ export class Triangle3D extends AbstractShape3D {
 Triangle3D.prototype.isTriangle3D = true;
 
 /**
- * Scratch for barycentric output from {@link computeTriangleClosestPointToPointBarycentric}.
+ * Scratch for barycentric output from {@link tri3_closest_point_barycentric}.
  * Module-scoped because every triangle method that needs barycentric
  * coords does it strictly inline — no nested calls that could re-enter.
  * @type {Float64Array}

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

@@ -0,0 +1,30 @@
+/**
+ * Build a {@link MeshShape3D} from a Three-style indexed triangle buffer.
+ *
+ * Pipeline:
+ *  1. {@link bt_mesh_from_indexed_geometry} reconstructs a
+ *     {@link BinaryTopology} (vertex / edge / loop / face cycles).
+ *  2. {@link compute_tetrahedral_mesh_from_surface} tetrahedralises the
+ *     volume enclosed by the surface, carving away exterior tets.
+ *  3. The tet mesh is **compacted** — the carving pass leaves the free
+ *     list populated with low-index slots, and downstream consumers
+ *     (`tetrahedral_mesh_to_bvh` iterates by index, the shape's
+ *     `recompute_cached` does the same) expect a hole-free range.
+ *     Compaction relocates live tets so indices `[0, count)` are dense.
+ *  4. The flat positions + indices are kept verbatim on the shape for
+ *     fast support-function and triangle-distance queries.
+ *  5. A {@link BVH} is built over the tet AABBs, used by
+ *     {@link MeshShape3D#contains_point} for O(log N) point-in-mesh
+ *     queries that correctly handle disconnected meshes (which the
+ *     previous tet-walker did not).
+ *
+ * The caller's buffers are NOT cloned — they're attached to the shape
+ * directly. Don't mutate them after handing them in.
+ *
+ * @param {Float32Array} positions flat `(x, y, z)` per vertex
+ * @param {Uint32Array}  indices  three uint32 per triangle (CCW winding)
+ * @returns {MeshShape3D}
+ */
+export function shape3_mesh_from_geometry(positions: Float32Array, indices: Uint32Array): MeshShape3D;
+import { MeshShape3D } from "./MeshShape3D.js";
+//# sourceMappingURL=shape3_mesh_from_geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shape3_mesh_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/shape3_mesh_from_geometry.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,qDAJW,YAAY,WACZ,WAAW,GACT,WAAW,CAgCvB;4BA3D2B,kBAAkB"}

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

@@ -0,0 +1,64 @@
+import { tetrahedral_mesh_to_bvh } from "../tetrahedra/bvh/tetrahedral_mesh_to_bvh.js";
+import { compute_tetrahedral_mesh_from_surface } from "../tetrahedra/compute_tetrahedral_mesh_from_surface.js";
+import { BinaryTopology } from "../topology/struct/binary/BinaryTopology.js";
+import { bt_mesh_from_indexed_geometry } from "../topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
+import { MeshShape3D } from "./MeshShape3D.js";
+
+/**
+ * Build a {@link MeshShape3D} from a Three-style indexed triangle buffer.
+ *
+ * Pipeline:
+ *  1. {@link bt_mesh_from_indexed_geometry} reconstructs a
+ *     {@link BinaryTopology} (vertex / edge / loop / face cycles).
+ *  2. {@link compute_tetrahedral_mesh_from_surface} tetrahedralises the
+ *     volume enclosed by the surface, carving away exterior tets.
+ *  3. The tet mesh is **compacted** — the carving pass leaves the free
+ *     list populated with low-index slots, and downstream consumers
+ *     (`tetrahedral_mesh_to_bvh` iterates by index, the shape's
+ *     `recompute_cached` does the same) expect a hole-free range.
+ *     Compaction relocates live tets so indices `[0, count)` are dense.
+ *  4. The flat positions + indices are kept verbatim on the shape for
+ *     fast support-function and triangle-distance queries.
+ *  5. A {@link BVH} is built over the tet AABBs, used by
+ *     {@link MeshShape3D#contains_point} for O(log N) point-in-mesh
+ *     queries that correctly handle disconnected meshes (which the
+ *     previous tet-walker did not).
+ *
+ * The caller's buffers are NOT cloned — they're attached to the shape
+ * directly. Don't mutate them after handing them in.
+ *
+ * @param {Float32Array} positions flat `(x, y, z)` per vertex
+ * @param {Uint32Array}  indices  three uint32 per triangle (CCW winding)
+ * @returns {MeshShape3D}
+ */
+export function shape3_mesh_from_geometry(positions, indices) {
+    const shape = new MeshShape3D();
+    shape.positions = positions;
+    shape.indices = indices;
+
+    // 1. BinaryTopology from the indexed buffer.
+    const topology = new BinaryTopology();
+    bt_mesh_from_indexed_geometry(topology, indices, positions);
+
+    // 2. Tetrahedralise. interior_steiner_cells_per_dim = 0 — for
+    //    collision queries the inside/outside oracle only needs
+    //    surface-vertex tets; interior Steiner points add cost without
+    //    changing the contains_point result.
+    shape.tet_positions = compute_tetrahedral_mesh_from_surface(shape.tet_mesh, topology, 0);
+
+    // 3. Compact. The carve pass freed slots in the tet mesh's
+    //    allocator; compaction repacks live tets into a dense
+    //    [0, count) range. Without this, `tetrahedral_mesh_to_bvh`
+    //    iterates "tet index 0..count" and treats freed indices as if
+    //    they were live tets — produces phantom BVH leaves with stale
+    //    vertex data.
+    shape.tet_mesh.compact();
+
+    // 4. BVH over tet AABBs for the point-in-mesh query path.
+    tetrahedral_mesh_to_bvh(shape.tet_bvh, shape.tet_mesh, shape.tet_positions);
+
+    // 5. Refresh cached bbox / volume / surface area.
+    shape.recompute_cached();
+
+    return shape;
+}

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

@@ -1,30 +1,7 @@
 /**
- * Build a {@link MeshShape3D} from a Three-style indexed triangle buffer.
- *
- * Pipeline:
- *  1. {@link bt_mesh_from_indexed_geometry} reconstructs a
- *     {@link BinaryTopology} (vertex / edge / loop / face cycles).
- *  2. {@link compute_tetrahedral_mesh_from_surface} tetrahedralises the
- *     volume enclosed by the surface, carving away exterior tets.
- *  3. The tet mesh is **compacted** — the carving pass leaves the free
- *     list populated with low-index slots, and downstream consumers
- *     (`tetrahedral_mesh_to_bvh` iterates by index, the shape's
- *     `recompute_cached` does the same) expect a hole-free range.
- *     Compaction relocates live tets so indices `[0, count)` are dense.
- *  4. The flat positions + indices are kept verbatim on the shape for
- *     fast support-function and triangle-distance queries.
- *  5. A {@link BVH} is built over the tet AABBs, used by
- *     {@link MeshShape3D#contains_point} for O(log N) point-in-mesh
- *     queries that correctly handle disconnected meshes (which the
- *     previous tet-walker did not).
- *
- * The caller's buffers are NOT cloned — they're attached to the shape
- * directly. Don't mutate them after handing them in.
- *
- * @param {Float32Array} positions flat `(x, y, z)` per vertex
- * @param {Uint32Array}  indices  three uint32 per triangle (CCW winding)
- * @returns {MeshShape3D}
+ * @deprecated Renamed to {@link shape3_mesh_from_geometry}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function shape_mesh_from_geometry(positions: Float32Array, indices: Uint32Array): MeshShape3D;
-import { MeshShape3D } from "./MeshShape3D.js";
+export const shape_mesh_from_geometry: typeof shape3_mesh_from_geometry;
+import { shape3_mesh_from_geometry } from "./shape3_mesh_from_geometry.js";
 //# sourceMappingURL=shape_mesh_from_geometry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"shape_mesh_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/shape_mesh_from_geometry.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oDAJW,YAAY,WACZ,WAAW,GACT,WAAW,CAgCvB;4BA3D2B,kBAAkB"}
+{"version":3,"file":"shape_mesh_from_geometry.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/shape_mesh_from_geometry.js"],"names":[],"mappings":"AAEA;;;GAGG;AACH,wEAAkE;0CANxB,gCAAgC"}

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

@@ -1,64 +1,7 @@
-import { tetrahedral_mesh_to_bvh } from "../tetrahedra/bvh/tetrahedral_mesh_to_bvh.js";
-import { compute_tetrahedral_mesh_from_surface } from "../tetrahedra/compute_tetrahedral_mesh_from_surface.js";
-import { BinaryTopology } from "../topology/struct/binary/BinaryTopology.js";
-import { bt_mesh_from_indexed_geometry } from "../topology/struct/binary/io/bt_mesh_from_indexed_geometry.js";
-import { MeshShape3D } from "./MeshShape3D.js";
+import { shape3_mesh_from_geometry } from "./shape3_mesh_from_geometry.js";
 
 /**
- * Build a {@link MeshShape3D} from a Three-style indexed triangle buffer.
- *
- * Pipeline:
- *  1. {@link bt_mesh_from_indexed_geometry} reconstructs a
- *     {@link BinaryTopology} (vertex / edge / loop / face cycles).
- *  2. {@link compute_tetrahedral_mesh_from_surface} tetrahedralises the
- *     volume enclosed by the surface, carving away exterior tets.
- *  3. The tet mesh is **compacted** — the carving pass leaves the free
- *     list populated with low-index slots, and downstream consumers
- *     (`tetrahedral_mesh_to_bvh` iterates by index, the shape's
- *     `recompute_cached` does the same) expect a hole-free range.
- *     Compaction relocates live tets so indices `[0, count)` are dense.
- *  4. The flat positions + indices are kept verbatim on the shape for
- *     fast support-function and triangle-distance queries.
- *  5. A {@link BVH} is built over the tet AABBs, used by
- *     {@link MeshShape3D#contains_point} for O(log N) point-in-mesh
- *     queries that correctly handle disconnected meshes (which the
- *     previous tet-walker did not).
- *
- * The caller's buffers are NOT cloned — they're attached to the shape
- * directly. Don't mutate them after handing them in.
- *
- * @param {Float32Array} positions flat `(x, y, z)` per vertex
- * @param {Uint32Array}  indices  three uint32 per triangle (CCW winding)
- * @returns {MeshShape3D}
+ * @deprecated Renamed to {@link shape3_mesh_from_geometry}. This re-export is kept for backward
+ * compatibility (meep is a library; old names are public surface).
  */
-export function shape_mesh_from_geometry(positions, indices) {
-    const shape = new MeshShape3D();
-    shape.positions = positions;
-    shape.indices = indices;
-
-    // 1. BinaryTopology from the indexed buffer.
-    const topology = new BinaryTopology();
-    bt_mesh_from_indexed_geometry(topology, indices, positions);
-
-    // 2. Tetrahedralise. interior_steiner_cells_per_dim = 0 — for
-    //    collision queries the inside/outside oracle only needs
-    //    surface-vertex tets; interior Steiner points add cost without
-    //    changing the contains_point result.
-    shape.tet_positions = compute_tetrahedral_mesh_from_surface(shape.tet_mesh, topology, 0);
-
-    // 3. Compact. The carve pass freed slots in the tet mesh's
-    //    allocator; compaction repacks live tets into a dense
-    //    [0, count) range. Without this, `tetrahedral_mesh_to_bvh`
-    //    iterates "tet index 0..count" and treats freed indices as if
-    //    they were live tets — produces phantom BVH leaves with stale
-    //    vertex data.
-    shape.tet_mesh.compact();
-
-    // 4. BVH over tet AABBs for the point-in-mesh query path.
-    tetrahedral_mesh_to_bvh(shape.tet_bvh, shape.tet_mesh, shape.tet_positions);
-
-    // 5. Refresh cached bbox / volume / surface area.
-    shape.recompute_cached();
-
-    return shape;
-}
+export const shape_mesh_from_geometry = shape3_mesh_from_geometry;