@woosh/meep-engine 2.139.0 → 2.140.0

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

@@ -0,0 +1,451 @@
+import { assert } from "../../../assert.js";
+import { clamp } from "../../../math/clamp.js";
+import { v3_length } from "../../vec3/v3_length.js";
+import { Vector3 } from "../../Vector3.js";
+import { AbstractShape3D } from "./AbstractShape3D.js";
+
+/**
+ * Heightmap shape, intended primarily for terrain.
+ *
+ * The shape is a closed solid bounded below by the plane perpendicular to
+ * {@link orientation} (the "floor") and above by a height-field surface
+ * defined by a {@link Sampler2D}. Heights are sampled with Catmull-Rom
+ * filtering ({@link Sampler2D#sampleChannelCatmullRomUV}), matching what
+ * the terrain system uses for geometry construction.
+ *
+ * Local frame layout:
+ *   - The orientation vector defines the local "up" axis (unit).
+ *   - An orthonormal basis (u, v, n=orientation) is built from it.
+ *   - Footprint extends along the basis-u axis over [-size.x/2, +size.x/2]
+ *     and along the basis-v axis over [-size.z/2, +size.z/2].
+ *   - The surface height (along orientation) at heightmap-UV (u01, v01) is
+ *     `sampler.sampleChannelCatmullRomUV(u01, v01, 0)`.
+ *   - The solid volume occupies `h ∈ [0, sampledHeight(u01, v01)]` along the
+ *     orientation axis, with `0` being the floor at body-local origin.
+ *   - `size.y` is the maximum height value of the heightfield (used for the
+ *     bounding box). Sampler values are NOT clamped to it.
+ *
+ * NON-CONVEX. {@link support} throws — GJK/EPA cannot be run against a
+ * heightmap directly. The physics narrowphase must dispatch a dedicated
+ * grid-traversal path when one of the colliders is a heightmap.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class HeightMapShape3D extends AbstractShape3D {
+    constructor() {
+        super();
+
+        /**
+         * Unit vector defining the local "up" axis (the direction the
+         * heightmap's surface faces). Default is +Y.
+         * @readonly
+         * @type {Vector3}
+         */
+        this.orientation = new Vector3(0, 1, 0);
+
+        /**
+         * Bounding-box extents in the heightmap-local (u, height, v) frame.
+         *   size.x — footprint extent along basis-u (perpendicular to orientation)
+         *   size.y — maximum heightmap height (extent along orientation)
+         *   size.z — footprint extent along basis-v (perpendicular to orientation)
+         * @readonly
+         * @type {Vector3}
+         */
+        this.size = new Vector3(1, 1, 1);
+
+        /**
+         * Sampler holding height values. Float32 backing recommended so the
+         * Terrain system's height texture plugs in directly. Single-channel
+         * sampler is the common case; only channel 0 is read.
+         * @type {Sampler2D | null}
+         */
+        this.sampler = null;
+
+        /**
+         * Cached orthonormal basis [u_x,u_y,u_z, v_x,v_y,v_z, n_x,n_y,n_z]
+         * built from {@link orientation}. Updated lazily by {@link _ensure_basis}.
+         * @private
+         * @type {Float64Array}
+         */
+        this._basis = new Float64Array(9);
+
+        // last-seen orientation components, used to detect dirty basis
+        this._basis_orientation_x = NaN;
+        this._basis_orientation_y = NaN;
+        this._basis_orientation_z = NaN;
+    }
+
+    /**
+     * Convenience constructor.
+     * @param {Sampler2D} sampler
+     * @param {number} size_x footprint extent along basis-u
+     * @param {number} size_y maximum heightmap height (along orientation)
+     * @param {number} size_z footprint extent along basis-v
+     * @param {Vector3} [orientation] defaults to +Y
+     * @returns {HeightMapShape3D}
+     */
+    static from(sampler, size_x, size_y, size_z, orientation) {
+        assert.isNumber(size_x, "size_x");
+        assert.isNumber(size_y, "size_y");
+        assert.isNumber(size_z, "size_z");
+        assert.greaterThanOrEqual(size_x, 0, "size_x");
+        assert.greaterThanOrEqual(size_y, 0, "size_y");
+        assert.greaterThanOrEqual(size_z, 0, "size_z");
+
+        const r = new HeightMapShape3D();
+        r.sampler = sampler;
+        r.size.set(size_x, size_y, size_z);
+
+        if (orientation !== undefined) {
+            r.orientation.set(orientation.x, orientation.y, orientation.z);
+        }
+
+        return r;
+    }
+
+    /**
+     * Recompute the orthonormal basis (u, v, n) if {@link orientation} changed.
+     *
+     * Construction chosen so that the default orientation +Y produces the
+     * intuitive mapping `u = +X, v = +Z, n = +Y` — i.e. size.x runs along
+     * body X, size.z along body Z. We project body +X onto the plane
+     * perpendicular to n (the orientation), with a fall-back to projecting
+     * body +Z when n is too close to colinear with +X.
+     * @private
+     */
+    _ensure_basis() {
+        const nx = this.orientation[0];
+        const ny = this.orientation[1];
+        const nz = this.orientation[2];
+
+        if (
+            nx === this._basis_orientation_x
+            && ny === this._basis_orientation_y
+            && nz === this._basis_orientation_z
+        ) {
+            return;
+        }
+
+        // tangent u = normalize(project body +X onto plane perpendicular to n)
+        // fall back to body +Z if n is too colinear with +X
+        let u_x, u_y, u_z;
+
+        if (Math.abs(nx) < 0.9) {
+            // u = (+X) - (n . +X) * n  =  (1 - nx*nx, -nx*ny, -nx*nz)
+            u_x = 1 - nx * nx;
+            u_y = -nx * ny;
+            u_z = -nx * nz;
+        } else {
+            // u = (+Z) - (n . +Z) * n  =  (-nz*nx, -nz*ny, 1 - nz*nz)
+            u_x = -nz * nx;
+            u_y = -nz * ny;
+            u_z = 1 - nz * nz;
+        }
+
+        const u_inv = 1 / v3_length(u_x, u_y, u_z);
+        u_x *= u_inv;
+        u_y *= u_inv;
+        u_z *= u_inv;
+
+        // v = u × n  (for n=+Y, u=+X this gives v=+Z, the intuitive choice)
+        const v_x = u_y * nz - u_z * ny;
+        const v_y = u_z * nx - u_x * nz;
+        const v_z = u_x * ny - u_y * nx;
+
+        const b = this._basis;
+        b[0] = u_x; b[1] = u_y; b[2] = u_z;
+        b[3] = v_x; b[4] = v_y; b[5] = v_z;
+        b[6] = nx;  b[7] = ny;  b[8] = nz;
+
+        this._basis_orientation_x = nx;
+        this._basis_orientation_y = ny;
+        this._basis_orientation_z = nz;
+    }
+
+    /**
+     * Sample the surface height at heightmap UV coordinates.
+     * Uses Catmull-Rom filtering to match the terrain system's geometry construction.
+     * @param {number} u01 horizontal UV, in [0, 1]
+     * @param {number} v01 vertical UV, in [0, 1]
+     * @returns {number} height along orientation axis
+     */
+    sample_height_at_uv(u01, v01) {
+        return this.sampler.sampleChannelCatmullRomUV(u01, v01, 0);
+    }
+
+    /**
+     * Project a body-local position to the surface and sample the height there.
+     * The returned height is in the orientation-axis direction.
+     * Positions outside the footprint sample the clamped UV (sampler clamps).
+     * @param {number} px body-local x
+     * @param {number} py body-local y
+     * @param {number} pz body-local z
+     * @returns {number}
+     */
+    sample_height_at_position(px, py, pz) {
+        this._ensure_basis();
+
+        const b = this._basis;
+
+        // project onto basis u and basis v
+        const u_coord = b[0] * px + b[1] * py + b[2] * pz;
+        const v_coord = b[3] * px + b[4] * py + b[5] * pz;
+
+        const u01 = u_coord / this.size[0] + 0.5;
+        const v01 = v_coord / this.size[2] + 0.5;
+
+        return this.sample_height_at_uv(u01, v01);
+    }
+
+    compute_bounding_box(result) {
+        this._ensure_basis();
+
+        const b = this._basis;
+
+        const sx = this.size[0];
+        const sy = this.size[1];
+        const sz = this.size[2];
+
+        const half_u = sx * 0.5;
+        const half_v = sz * 0.5;
+
+        // For each body axis k (0=x, 1=y, 2=z):
+        //   body[k] = b[0+k]*u + b[3+k]*v + b[6+k]*h
+        //
+        // The (u,v) footprint contribution is symmetric (u ∈ [-half_u, +half_u], v ∈ [-half_v, +half_v])
+        // The height contribution is asymmetric (h ∈ [0, sy])
+        for (let k = 0; k < 3; k++) {
+            const cu = b[k];
+            const cv = b[3 + k];
+            const ch = b[6 + k];
+
+            const uv_extent = Math.abs(cu) * half_u + Math.abs(cv) * half_v;
+
+            const h_lo = ch < 0 ? ch * sy : 0;
+            const h_hi = ch > 0 ? ch * sy : 0;
+
+            result[k] = -uv_extent + h_lo;
+            result[k + 3] = uv_extent + h_hi;
+        }
+    }
+
+    contains_point(point) {
+        const px = point[0];
+        const py = point[1];
+        const pz = point[2];
+
+        this._ensure_basis();
+
+        const b = this._basis;
+
+        // project into heightmap-local frame (u, v, h)
+        const u_coord = b[0] * px + b[1] * py + b[2] * pz;
+        const v_coord = b[3] * px + b[4] * py + b[5] * pz;
+        const h_coord = b[6] * px + b[7] * py + b[8] * pz;
+
+        const half_u = this.size[0] * 0.5;
+        const half_v = this.size[2] * 0.5;
+
+        if (u_coord <= -half_u || u_coord >= half_u) return false;
+        if (v_coord <= -half_v || v_coord >= half_v) return false;
+        if (h_coord <= 0 || h_coord >= this.size[1]) return false;
+
+        const u01 = u_coord / this.size[0] + 0.5;
+        const v01 = v_coord / this.size[2] + 0.5;
+
+        const surface_h = this.sample_height_at_uv(u01, v01);
+
+        return h_coord < surface_h;
+    }
+
+    /**
+     * Approximate signed distance: difference between the point's height
+     * (along orientation) and the surface height sampled at the point's
+     * footprint UV. POSITIVE = above surface, NEGATIVE = below.
+     *
+     * Locally correct when the surface is flat; biased when the surface
+     * has significant slope. Sufficient for cling/raycast queries that
+     * walk down to the surface.
+     */
+    signed_distance_at_point(point) {
+        const px = point[0];
+        const py = point[1];
+        const pz = point[2];
+
+        this._ensure_basis();
+
+        const b = this._basis;
+
+        const u_coord = b[0] * px + b[1] * py + b[2] * pz;
+        const v_coord = b[3] * px + b[4] * py + b[5] * pz;
+        const h_coord = b[6] * px + b[7] * py + b[8] * pz;
+
+        const u01 = u_coord / this.size[0] + 0.5;
+        const v01 = v_coord / this.size[2] + 0.5;
+
+        const surface_h = this.sample_height_at_uv(u01, v01);
+
+        return h_coord - surface_h;
+    }
+
+    /**
+     * Project a reference point onto the surface along the orientation axis.
+     * The footprint UV is clamped, so points outside the footprint produce
+     * the nearest edge-of-footprint surface sample (approximate).
+     */
+    nearest_point_on_surface(result, reference) {
+        const rx = reference[0];
+        const ry = reference[1];
+        const rz = reference[2];
+
+        this._ensure_basis();
+
+        const b = this._basis;
+
+        const u_coord = b[0] * rx + b[1] * ry + b[2] * rz;
+        const v_coord = b[3] * rx + b[4] * ry + b[5] * rz;
+
+        const half_u = this.size[0] * 0.5;
+        const half_v = this.size[2] * 0.5;
+
+        const u_clamped = clamp(u_coord, -half_u, half_u);
+        const v_clamped = clamp(v_coord, -half_v, half_v);
+
+        const u01 = u_clamped / this.size[0] + 0.5;
+        const v01 = v_clamped / this.size[2] + 0.5;
+
+        const surface_h = this.sample_height_at_uv(u01, v01);
+
+        // compose body-local point: u_axis*u_clamped + v_axis*v_clamped + n_axis*surface_h
+        result[0] = b[0] * u_clamped + b[3] * v_clamped + b[6] * surface_h;
+        result[1] = b[1] * u_clamped + b[4] * v_clamped + b[7] * surface_h;
+        result[2] = b[2] * u_clamped + b[5] * v_clamped + b[8] * surface_h;
+    }
+
+    /**
+     * Heightmaps are non-convex; GJK/EPA cannot work against them directly.
+     * The physics narrowphase must dispatch a grid-traversal path that
+     * decomposes the heightmap into per-cell triangle pairs and tests each
+     * against the other shape (analogous to Bullet's btHeightfieldTerrainShape
+     * × btConcaveShape interface).
+     *
+     * This throws rather than returning a degenerate result so the call
+     * site is forced to handle heightmaps explicitly.
+     */
+    support(result, result_offset, direction_x, direction_y, direction_z) {
+        throw new Error("HeightMapShape3D.support: heightmaps are non-convex; the narrowphase must dispatch grid-traversal instead.");
+    }
+
+    sample_random_point_in_volume(result, result_offset, random) {
+        const u01 = random();
+        const v01 = random();
+
+        const u_coord = (u01 - 0.5) * this.size[0];
+        const v_coord = (v01 - 0.5) * this.size[2];
+
+        const surface_h = this.sample_height_at_uv(u01, v01);
+        const h_coord = random() * surface_h;
+
+        this._ensure_basis();
+
+        const b = this._basis;
+
+        result[result_offset]     = b[0] * u_coord + b[3] * v_coord + b[6] * h_coord;
+        result[result_offset + 1] = b[1] * u_coord + b[4] * v_coord + b[7] * h_coord;
+        result[result_offset + 2] = b[2] * u_coord + b[5] * v_coord + b[8] * h_coord;
+    }
+
+    /**
+     * Sum of sampler heights × per-cell footprint area. This is the
+     * piecewise-constant approximation of the integral ∫h(u,v) dA over
+     * the footprint — exact when h is constant per cell, biased when
+     * h is smooth.
+     */
+    get volume() {
+        const sampler = this.sampler;
+
+        if (sampler === null) {
+            return 0;
+        }
+
+        const w = sampler.width;
+        const h = sampler.height;
+
+        if (w === 0 || h === 0) {
+            return 0;
+        }
+
+        const cell_area = (this.size[0] / w) * (this.size[2] / h);
+
+        let total = 0;
+
+        for (let y = 0; y < h; y++) {
+            for (let x = 0; x < w; x++) {
+                total += sampler.readChannel(x, y, 0);
+            }
+        }
+
+        return total * cell_area;
+    }
+
+    /**
+     * Returns just the footprint area. A true heightmap surface area
+     * requires integrating sqrt(1 + (∂h/∂u)² + (∂h/∂v)²) over the grid;
+     * the footprint area is a lower bound and is sufficient for the
+     * physics inertia-tensor seam (heightmaps are static anyway).
+     */
+    get surface_area() {
+        return this.size[0] * this.size[2];
+    }
+
+    /**
+     * @param {HeightMapShape3D} other
+     * @returns {boolean}
+     */
+    equals(other) {
+        if (!super.equals(other)) return false;
+
+        if (!this.orientation.equals(other.orientation)) return false;
+        if (!this.size.equals(other.size)) return false;
+
+        // strict identity is enough for sampler equality in the common case;
+        // fall through to value equality so two shapes built from independent
+        // but identical sampler instances still compare equal
+        if (this.sampler === other.sampler) return true;
+
+        if (this.sampler === null || other.sampler === null) return false;
+
+        return this.sampler.equals(other.sampler);
+    }
+
+    hash() {
+        const a = this.orientation.hash();
+        const b = this.size.hash();
+        const c = this.sampler !== null ? this.sampler.hash() : 0;
+
+        let h = (a * 31 + b) | 0;
+        h = (h * 31 + c) | 0;
+
+        return h;
+    }
+}
+
+/**
+ * Fast type-check marker, matching the pattern on every other concrete
+ * AbstractShape3D subclass. The physics narrowphase reads this to dispatch
+ * the heightmap-vs-X grid-traversal path.
+ * @readonly
+ * @type {boolean}
+ */
+HeightMapShape3D.prototype.isHeightMapShape3D = true;
+
+/**
+ * Heightmaps are non-convex: the solid volume bounded by an arbitrary
+ * height-field has valleys and overhangs that break GJK's convex-Minkowski
+ * precondition. The narrowphase must use grid traversal + per-triangle
+ * GJK instead of feeding this shape's {@link support} into pair tests.
+ * @readonly
+ * @type {boolean}
+ */
+HeightMapShape3D.prototype.is_convex = false;

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

@@ -0,0 +1,210 @@
+/**
+ * Arbitrary triangle-mesh collider.
+ *
+ * The shape carries two synchronized representations:
+ *   - flat (`positions`, `indices`) surface — used by GJK's support
+ *     function and the per-triangle distance queries;
+ *   - a {@link TetrahedralMesh} of the *interior* (built from the surface
+ *     by `compute_tetrahedral_mesh_from_surface`) plus a {@link BVH}
+ *     keyed by tet AABB — used by `contains_point` and any future
+ *     volume-aware query.
+ *
+ * The tet decomposition gives us convex primitives. Two consequences:
+ *   1. `contains_point` is a point-in-AABB BVH query followed by a
+ *      per-tet `orient3d` test. Critically this works for **disconnected
+ *      meshes** (two cubes welded into one buffer; a torus and a sphere
+ *      handed to the same shape). A walking query started from one
+ *      component can't reach the others — that was the previous
+ *      implementation's silent bug.
+ *   2. Per-point queries are O(log N_tets) on average — the BVH's
+ *      traversal short-circuits cleanly when the query point is far
+ *      from the mesh.
+ *
+ * Construct via {@link shape_mesh_from_geometry} rather than `new
+ * MeshShape3D()` directly — the factory compacts the tet mesh, builds
+ * the BVH, and caches the bbox / volume / surface area.
+ *
+ * Narrowphase routing:
+ *   - GJK + EPA for the general case, using {@link support}.
+ *   - The support function currently returns the deepest tet-mesh
+ *     vertex, which gives GJK the *convex hull* of the mesh — not the
+ *     true non-convex surface. For convex authored geometry that's
+ *     fine; for highly concave shapes (a torus's hole, an L-bracket,
+ *     two disconnected components) the convex-hull approximation
+ *     overstates the collision volume. The accurate fix is a per-tet
+ *     GJK loop in the narrowphase, which would consume `tet_mesh` and
+ *     `tet_positions` directly — see PLAN.md's mesh-vs-convex
+ *     closed-form item.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class MeshShape3D extends AbstractShape3D {
+    /**
+     * Surface vertex positions, flat `(x, y, z)` per vertex. Authored
+     * by the factory; mutate at your own risk (the cached bbox /
+     * volume / surface area / BVH will go stale).
+     * @type {Float32Array}
+     */
+    positions: Float32Array;
+    /**
+     * Surface triangle indices, three uint32 per face referring to
+     * {@link positions}. Same mutate-at-your-own-risk caveat.
+     * @type {Uint32Array}
+     */
+    indices: Uint32Array;
+    /**
+     * Tetrahedral decomposition of the interior. The factory
+     * compacts the mesh before storing (low-index slots that the
+     * carve pass freed get refilled), so iteration via
+     * `tet_id in [0, tet_mesh.count)` is safe — no need for
+     * `forEach` or `exists` filtering on the hot path.
+     * @type {TetrahedralMesh}
+     */
+    tet_mesh: TetrahedralMesh;
+    /**
+     * Flat positions array for {@link tet_mesh}. Includes the
+     * surface vertices and any hole-closing centroids added during
+     * tetrahedralisation. For closed airtight meshes this equals
+     * {@link positions} element-wise; for meshes with boundary holes
+     * (rare in authored content, common in mis-exported assets) the
+     * trailing slots carry the closure centroids.
+     * @type {Float32Array}
+     */
+    tet_positions: Float32Array;
+    /**
+     * BVH over the tet mesh, keyed by tet index. Built by the
+     * factory after compacting the tet mesh, so leaf user_data
+     * values are valid tet indices that can be passed straight to
+     * `tet_mesh.getVertexIndex`.
+     * @type {BVH}
+     */
+    tet_bvh: BVH;
+    /**
+     * Cached axis-aligned bounding box, layout `[minX, minY, minZ,
+     * maxX, maxY, maxZ]`.
+     * @private
+     * @type {Float64Array}
+     */
+    private __bbox;
+    /**
+     * Cached total volume in the shape's local frame, computed from
+     * the tetrahedral decomposition at construction.
+     * @private
+     * @type {number}
+     */
+    private __volume;
+    /**
+     * Cached total surface area, sum of triangle areas.
+     * @private
+     * @type {number}
+     */
+    private __surface_area;
+    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.
+     */
+    recompute_cached(): void;
+    /**
+     * Support function: returns the deepest tet-mesh vertex along the
+     * supplied direction. This gives GJK the **convex hull** of the
+     * mesh — fine for convex authored geometry, an overestimate for
+     * concave shapes (a torus's hole or two disconnected components
+     * read as one filled blob through this function).
+     *
+     * Iterates `tet_positions` rather than the original surface
+     * `positions` so any hole-closing centroid that the
+     * tetrahedralisation added shows up. For airtight closed meshes the
+     * two arrays match element-wise.
+     *
+     * Future work: an accurate non-convex `support` would have to be
+     * per-tet (each tet is convex; the shape is the union). The
+     * narrowphase would then iterate tets via the BVH. See PLAN.md.
+     *
+     * @param {number[]|Float32Array} result
+     * @param {number} result_offset
+     * @param {number} direction_x
+     * @param {number} direction_y
+     * @param {number} direction_z
+     */
+    support(result: number[] | Float32Array, result_offset: number, direction_x: number, direction_y: number, direction_z: number): void;
+    /**
+     * Inside test via the tet mesh. Queries the tet BVH for the leaves
+     * whose AABB contains the point, then runs an `orient3d`-based
+     * point-in-tet test on each candidate. Returns `true` on the first
+     * hit.
+     *
+     * Crucially this works for **disconnected meshes** — a single
+     * `MeshShape3D` holding two cubes welded into one buffer, or a
+     * torus with a separate sphere, will correctly classify points
+     * inside either component. The previous implementation walked tet
+     * neighbours starting from a single seed, which trapped the query
+     * in the seed's connected component and produced silent false
+     * negatives in the other components.
+     *
+     * @param {number[]|Float32Array} point
+     * @returns {boolean}
+     */
+    contains_point(point: number[] | Float32Array): boolean;
+    /**
+     * Closest world-space point on the surface to `reference`. Linear
+     * scan over triangles using the barycentric closest-point helper.
+     * For mesh sizes where this becomes a bottleneck, a triangle BVH
+     * would be the next acceleration (sibling to {@link tet_bvh} but
+     * keyed on surface triangles).
+     *
+     * @param {number[]|Float32Array} result
+     * @param {number[]|Float32Array} reference
+     */
+    nearest_point_on_surface(result: number[] | Float32Array, reference: number[] | Float32Array): void;
+    /**
+     * Signed distance to the surface: positive outside the mesh,
+     * negative inside. Linear scan over triangles for nearest unsigned
+     * distance, then the BVH-backed {@link contains_point} flips the
+     * sign for interior points.
+     *
+     * @param {number[]|Float32Array} point
+     * @returns {number}
+     */
+    signed_distance_at_point(point: number[] | Float32Array): number;
+    /**
+     * Reject-sample inside the bounding box until a point lands in the
+     * mesh volume. For convex or near-convex shapes this terminates in
+     * 1–3 attempts; for thin or pinched shapes the worst-case cost can
+     * be high. Falls back to the bbox centre after 256 misses.
+     *
+     * @param {number[]|Float32Array} result
+     * @param {number} result_offset
+     * @param {function():number} random
+     */
+    sample_random_point_in_volume(result: number[] | Float32Array, result_offset: number, random: () => number): void;
+    /**
+     * Numerical-gradient SDF gradient.
+     *
+     * @param {number[]|Float32Array} result
+     * @param {number[]|Float32Array} point
+     * @returns {number}
+     */
+    signed_distance_gradient_at_point(result: number[] | Float32Array, point: number[] | Float32Array): number;
+    /**
+     * Topology equality: same vertex count, same triangle count, and
+     * positions / indices match element-by-element.
+     *
+     * @param {MeshShape3D} other
+     * @returns {boolean}
+     */
+    equals(other: MeshShape3D): boolean;
+    /**
+     * Fast type-check marker.
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isMeshShape3D: boolean;
+}
+import { AbstractShape3D } from "./AbstractShape3D.js";
+import { TetrahedralMesh } from "../tetrahedra/TetrahedralMesh.js";
+import { BVH } from "../../../bvh2/bvh3/BVH.js";
+//# sourceMappingURL=MeshShape3D.d.ts.map

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

@@ -0,0 +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,CAkCnB;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;gCAje+B,sBAAsB;gCADtB,kCAAkC;oBAJ9C,2BAA2B"}