@woosh/meep-engine 3.21.0 → 3.23.0

package/src/core/geom/3d/hash-grid/PointHashGrid3.d.ts

@@ -0,0 +1,118 @@
+/**
+ * # A uniform hash grid over points, rebuilt whole
+ *
+ * Bucket every point by the cell of a uniform grid it falls in, so that "what is
+ * near this point" is a walk over a handful of buckets instead of a scan over
+ * everything. The classic particle broadphase, and the structure a cloth's
+ * self-collision needs (§9, §14.2).
+ *
+ * ## What it takes from `SpatialHashGrid`, and where it deliberately differs
+ *
+ * §14.2 asks for this "modelled on `core/geom/2d/hash-grid/SpatialHashGrid.js`",
+ * and it takes the idea — uniform cells, hashed into a fixed bucket table — and
+ * not the structure, because the two answer different questions.
+ *
+ * `SpatialHashGrid` is a **persistent index of boxes**: an element carries an
+ * AABB, spans several cells, is allocated and freed individually, and lives in a
+ * singly-linked list per cell so that moving one element touches only that
+ * element. That is right for a world index whose contents change a few at a time
+ * and wrong for this: a cloth's particles *all* move every step, so every link
+ * would be relinked, and the pointer chase through a linked list is the worst
+ * possible access pattern for a loop that is going to visit every bucket anyway.
+ *
+ * This is instead a **counting sort, rebuilt whole**: two passes over the points
+ * to count and scatter, and a bucket is then a contiguous run of point indices.
+ * Rebuilding is O(n) with no allocation after the first sizing, and the walk is
+ * sequential. A point is a point rather than a box, so it lands in exactly one
+ * cell and nothing is emitted twice.
+ *
+ * ## Hash collisions are the caller's problem, and that is the trade
+ *
+ * The bucket table is a power of two and cell coordinates are hashed into it, so
+ * two distant cells can share a bucket and a query can hand back a point that is
+ * nowhere near. **Every caller has to check the actual distance**, which is not a
+ * cost because every caller was going to: a broadphase answers "maybe", and the
+ * narrow phase is a subtraction and a dot product.
+ *
+ * What the hash buys is that the grid needs no extent. A dense grid over a
+ * garment's bounds would have to be resized whenever the garment moved or grew,
+ * and a garment that teleports a kilometre would size it into the gigabytes.
+ *
+ * What a caller does **not** have to handle is a point arriving twice.
+ * `SpatialHashGrid` documents duplicate emission as the caller's problem because
+ * its elements are boxes and a box genuinely occupies several cells; here a point
+ * occupies one, and the only way it could be emitted twice is the 27-cell walk
+ * visiting one bucket more than once because two of those cells collided into it.
+ * {@link forEachNear} skips a bucket it has already visited, which is a scan over
+ * at most 27 numbers and removes the whole class.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PointHashGrid3 {
+    /**
+     * Side of one cell. Points closer than this are in the same cell or an
+     * adjacent one, which is what makes {@link forEachNear}'s 27-cell walk the
+     * whole of the broadphase.
+     * @type {number}
+     */
+    cell_size: number;
+    /**
+     * Points in the grid.
+     * @type {number}
+     */
+    count: number;
+    /**
+     * Start of each bucket in {@link point}, `bucket_count + 1` entries. Bucket
+     * `b` is `point[offset[b] .. offset[b + 1])`.
+     *
+     * Public because the inner loop that motivated this class walks buckets
+     * directly rather than through {@link forEachNear}, and a private field with
+     * an accessor in front of it would put a call in that loop.
+     * @type {Int32Array}
+     */
+    offset: Int32Array;
+    /**
+     * Point indices, bucket-major.
+     * @type {Int32Array}
+     */
+    point: Int32Array;
+    /**
+     * How many buckets the table has. A power of two, so hashing is a mask.
+     * @returns {number}
+     */
+    get bucketCount(): number;
+    /**
+     * Rebuild the grid from a flat position array.
+     *
+     * @param {Float32Array|Float64Array} position 3 per point
+     * @param {number} count points
+     * @param {number} cell_size metres
+     * @returns {void}
+     */
+    build(position: Float32Array | Float64Array, count: number, cell_size: number): void;
+    /**
+     * Call `visit(index)` for every point in the 27 cells around `(x, y, z)`.
+     *
+     * Points from other cells may be handed back — see the class docblock on
+     * hash collisions — and the visitor is expected to check the distance.
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {function(number): void} visit
+     * @returns {void}
+     */
+    forEachNear(x: number, y: number, z: number, visit: (arg0: number) => void): void;
+    /**
+     * The bucket a cell falls in. For a caller walking buckets itself.
+     *
+     * @param {number} cx cell coordinate
+     * @param {number} cy
+     * @param {number} cz
+     * @returns {number}
+     */
+    bucketOf(cx: number, cy: number, cz: number): number;
+    #private;
+}
+//# sourceMappingURL=PointHashGrid3.d.ts.map

package/src/core/geom/3d/hash-grid/PointHashGrid3.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"PointHashGrid3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/hash-grid/PointHashGrid3.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AACH;IAEI;;;;;OAKG;IACH,WAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;;;OAQG;IACH,QAFU,UAAU,CAEO;IAE3B;;;OAGG;IACH,OAFU,UAAU,CAEM;IAQ1B;;;OAGG;IACH,0BAEC;IAED;;;;;;;OAOG;IACH,gBALW,YAAY,GAAC,YAAY,SACzB,MAAM,aACN,MAAM,GACJ,IAAI,CA0EhB;IAED;;;;;;;;;;;OAWG;IACH,eANW,MAAM,KACN,MAAM,KACN,MAAM,gBACG,MAAM,KAAG,IAAI,GACpB,IAAI,CAiDhB;IAED;;;;;;;OAOG;IACH,aALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAIlB;;CACJ"}

package/src/core/geom/3d/hash-grid/PointHashGrid3.js

@@ -0,0 +1,283 @@
+import { assert } from "../../../assert.js";
+
+/**
+ * # A uniform hash grid over points, rebuilt whole
+ *
+ * Bucket every point by the cell of a uniform grid it falls in, so that "what is
+ * near this point" is a walk over a handful of buckets instead of a scan over
+ * everything. The classic particle broadphase, and the structure a cloth's
+ * self-collision needs (§9, §14.2).
+ *
+ * ## What it takes from `SpatialHashGrid`, and where it deliberately differs
+ *
+ * §14.2 asks for this "modelled on `core/geom/2d/hash-grid/SpatialHashGrid.js`",
+ * and it takes the idea — uniform cells, hashed into a fixed bucket table — and
+ * not the structure, because the two answer different questions.
+ *
+ * `SpatialHashGrid` is a **persistent index of boxes**: an element carries an
+ * AABB, spans several cells, is allocated and freed individually, and lives in a
+ * singly-linked list per cell so that moving one element touches only that
+ * element. That is right for a world index whose contents change a few at a time
+ * and wrong for this: a cloth's particles *all* move every step, so every link
+ * would be relinked, and the pointer chase through a linked list is the worst
+ * possible access pattern for a loop that is going to visit every bucket anyway.
+ *
+ * This is instead a **counting sort, rebuilt whole**: two passes over the points
+ * to count and scatter, and a bucket is then a contiguous run of point indices.
+ * Rebuilding is O(n) with no allocation after the first sizing, and the walk is
+ * sequential. A point is a point rather than a box, so it lands in exactly one
+ * cell and nothing is emitted twice.
+ *
+ * ## Hash collisions are the caller's problem, and that is the trade
+ *
+ * The bucket table is a power of two and cell coordinates are hashed into it, so
+ * two distant cells can share a bucket and a query can hand back a point that is
+ * nowhere near. **Every caller has to check the actual distance**, which is not a
+ * cost because every caller was going to: a broadphase answers "maybe", and the
+ * narrow phase is a subtraction and a dot product.
+ *
+ * What the hash buys is that the grid needs no extent. A dense grid over a
+ * garment's bounds would have to be resized whenever the garment moved or grew,
+ * and a garment that teleports a kilometre would size it into the gigabytes.
+ *
+ * What a caller does **not** have to handle is a point arriving twice.
+ * `SpatialHashGrid` documents duplicate emission as the caller's problem because
+ * its elements are boxes and a box genuinely occupies several cells; here a point
+ * occupies one, and the only way it could be emitted twice is the 27-cell walk
+ * visiting one bucket more than once because two of those cells collided into it.
+ * {@link forEachNear} skips a bucket it has already visited, which is a scan over
+ * at most 27 numbers and removes the whole class.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class PointHashGrid3 {
+
+    /**
+     * Side of one cell. Points closer than this are in the same cell or an
+     * adjacent one, which is what makes {@link forEachNear}'s 27-cell walk the
+     * whole of the broadphase.
+     * @type {number}
+     */
+    cell_size = 1;
+
+    /**
+     * Points in the grid.
+     * @type {number}
+     */
+    count = 0;
+
+    /**
+     * Start of each bucket in {@link point}, `bucket_count + 1` entries. Bucket
+     * `b` is `point[offset[b] .. offset[b + 1])`.
+     *
+     * Public because the inner loop that motivated this class walks buckets
+     * directly rather than through {@link forEachNear}, and a private field with
+     * an accessor in front of it would put a call in that loop.
+     * @type {Int32Array}
+     */
+    offset = new Int32Array(1);
+
+    /**
+     * Point indices, bucket-major.
+     * @type {Int32Array}
+     */
+    point = new Int32Array(0);
+
+    /**
+     * @type {number}
+     * @private
+     */
+    #bucket_count = 0;
+
+    /**
+     * How many buckets the table has. A power of two, so hashing is a mask.
+     * @returns {number}
+     */
+    get bucketCount() {
+        return this.#bucket_count;
+    }
+
+    /**
+     * Rebuild the grid from a flat position array.
+     *
+     * @param {Float32Array|Float64Array} position 3 per point
+     * @param {number} count points
+     * @param {number} cell_size metres
+     * @returns {void}
+     */
+    build(position, count, cell_size) {
+        assert.isFinite(cell_size, 'cell_size');
+        assert.greaterThan(cell_size, 0, 'cell_size');
+
+        this.cell_size = cell_size;
+        this.count = count;
+
+        // One bucket per point, rounded up to a power of two, so the mean
+        // occupancy is about one and the table is never a rounding error next to
+        // the points it indexes.
+        let buckets = 16;
+
+        while (buckets < count) {
+            buckets *= 2;
+        }
+
+        if (buckets !== this.#bucket_count) {
+            this.#bucket_count = buckets;
+            this.offset = new Int32Array(buckets + 1);
+        } else {
+            this.offset.fill(0);
+        }
+
+        if (this.point.length < count) {
+            this.point = new Int32Array(count);
+        }
+
+        const offset = this.offset;
+        const mask = buckets - 1;
+
+        const inverse = 1 / cell_size;
+
+        for (let i = 0; i < count; i++) {
+            const p = i * 3;
+
+            const bucket = hash(
+                Math.floor(position[p] * inverse),
+                Math.floor(position[p + 1] * inverse),
+                Math.floor(position[p + 2] * inverse)
+            ) & mask;
+
+            offset[bucket + 1]++;
+        }
+
+        for (let b = 0; b < buckets; b++) {
+            offset[b + 1] += offset[b];
+        }
+
+        // The scatter needs a moving cursor per bucket, and the offsets are the
+        // starting cursors — so the pass below consumes them and the loop after
+        // it puts them back rather than keeping a second array of the same size.
+        const point = this.point;
+
+        for (let i = 0; i < count; i++) {
+            const p = i * 3;
+
+            const bucket = hash(
+                Math.floor(position[p] * inverse),
+                Math.floor(position[p + 1] * inverse),
+                Math.floor(position[p + 2] * inverse)
+            ) & mask;
+
+            point[offset[bucket]++] = i;
+        }
+
+        // Undo the cursor advance: `offset[b]` ran up to `offset[b + 1]`, so
+        // shifting the array back down by one restores the starts.
+        for (let b = buckets; b > 0; b--) {
+            offset[b] = offset[b - 1];
+        }
+
+        offset[0] = 0;
+    }
+
+    /**
+     * Call `visit(index)` for every point in the 27 cells around `(x, y, z)`.
+     *
+     * Points from other cells may be handed back — see the class docblock on
+     * hash collisions — and the visitor is expected to check the distance.
+     *
+     * @param {number} x
+     * @param {number} y
+     * @param {number} z
+     * @param {function(number): void} visit
+     * @returns {void}
+     */
+    forEachNear(x, y, z, visit) {
+        const inverse = 1 / this.cell_size;
+
+        const cx = Math.floor(x * inverse);
+        const cy = Math.floor(y * inverse);
+        const cz = Math.floor(z * inverse);
+
+        const mask = this.#bucket_count - 1;
+
+        const offset = this.offset;
+        const point = this.point;
+
+        let visited = 0;
+
+        for (let dz = -1; dz <= 1; dz++) {
+            for (let dy = -1; dy <= 1; dy++) {
+                for (let dx = -1; dx <= 1; dx++) {
+                    const bucket = hash(cx + dx, cy + dy, cz + dz) & mask;
+
+                    // Two of the 27 cells can hash to one bucket — most easily on
+                    // a small table, where there are fewer buckets than cells in
+                    // the neighbourhood — and visiting it twice would hand every
+                    // point in it back twice.
+                    let seen = false;
+
+                    for (let i = 0; i < visited; i++) {
+                        if (VISITED[i] === bucket) {
+                            seen = true;
+
+                            break;
+                        }
+                    }
+
+                    if (seen) {
+                        continue;
+                    }
+
+                    VISITED[visited++] = bucket;
+
+                    const end = offset[bucket + 1];
+
+                    for (let at = offset[bucket]; at < end; at++) {
+                        visit(point[at]);
+                    }
+                }
+            }
+        }
+    }
+
+    /**
+     * The bucket a cell falls in. For a caller walking buckets itself.
+     *
+     * @param {number} cx cell coordinate
+     * @param {number} cy
+     * @param {number} cz
+     * @returns {number}
+     */
+    bucketOf(cx, cy, cz) {
+        return hash(cx, cy, cz) & (this.#bucket_count - 1);
+    }
+}
+
+/**
+ * The buckets one {@link PointHashGrid3#forEachNear} has already visited — at
+ * most 27, so a linear scan is the whole of the de-duplication. Module scratch
+ * because a query allocates nothing, and safe because a query does not nest: the
+ * visitor is called with a point index and has no reason to start another walk.
+ * @type {Int32Array}
+ * @private
+ */
+const VISITED = new Int32Array(27);
+
+/**
+ * Teschner's spatial hash — three large primes, one exclusive-or, which is the
+ * one every particle system in the literature uses because it is cheap and its
+ * collisions are uncorrelated with the lattice.
+ *
+ * `Math.imul` rather than `*` because the products overflow 32 bits and JavaScript
+ * would carry them into doubles, losing the low bits that are the hash.
+ *
+ * @param {number} x cell coordinate, integer
+ * @param {number} y
+ * @param {number} z
+ * @returns {number} a non-negative int32
+ * @private
+ */
+function hash(x, y, z) {
+    return (Math.imul(x, 73856093) ^ Math.imul(y, 19349663) ^ Math.imul(z, 83492791)) >>> 0;
+}

package/src/core/geom/3d/quaternion/quat3_shortest_arc.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Shortest rotation taking one unit vector onto another: `out · a == b`.
+ *
+ * The construction is the standard half-way-vector one. `(a × b, 1 + a·b)` is
+ * the quaternion of *twice* the required angle's axis-angle form before
+ * normalisation; normalising halves it, and the result is the unique rotation
+ * with no twist about `b` — which is what "shortest" means here and what makes
+ * it the right primitive for orienting a bone from the direction it points in.
+ *
+ * **The antipodal case is real and has to be answered.** When `a` and `b` point
+ * in opposite directions the cross product vanishes and `1 + a·b` is zero, so
+ * the formula gives the zero quaternion — every axis perpendicular to `a` is an
+ * equally valid 180° rotation and the expression cannot pick between them. This
+ * picks one, by rotating about whichever coordinate axis `a` is least aligned
+ * with. That is a discontinuity in `out` as `b` sweeps through `−a`, and it is
+ * unavoidable: no continuous choice of axis exists on the whole sphere. It is
+ * documented rather than hidden so a caller seeing a bone flip at exactly 180°
+ * knows what it is looking at.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and
+ * the rest of the `core/geom/3d/quaternion/` family.
+ *
+ * **Precondition: `a` and `b` are unit length.** The half-way construction uses
+ * `a·b` as a cosine and `|a × b|` as a sine; a non-unit input scales those two
+ * differently and the normalisation cannot undo it, so the result is a rotation
+ * of the wrong angle rather than a rotation of the wrong length.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} ax unit vector, from
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx unit vector, to
+ * @param {number} by
+ * @param {number} bz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quat3_shortest_arc(out: number[] | Float32Array | Float64Array, out_offset: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number): void;
+//# sourceMappingURL=quat3_shortest_arc.d.ts.map

package/src/core/geom/3d/quaternion/quat3_shortest_arc.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quat3_shortest_arc.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/quaternion/quat3_shortest_arc.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH,wCAZW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QA2DhB"}

package/src/core/geom/3d/quaternion/quat3_shortest_arc.js

@@ -0,0 +1,94 @@
+/**
+ * Shortest rotation taking one unit vector onto another: `out · a == b`.
+ *
+ * The construction is the standard half-way-vector one. `(a × b, 1 + a·b)` is
+ * the quaternion of *twice* the required angle's axis-angle form before
+ * normalisation; normalising halves it, and the result is the unique rotation
+ * with no twist about `b` — which is what "shortest" means here and what makes
+ * it the right primitive for orienting a bone from the direction it points in.
+ *
+ * **The antipodal case is real and has to be answered.** When `a` and `b` point
+ * in opposite directions the cross product vanishes and `1 + a·b` is zero, so
+ * the formula gives the zero quaternion — every axis perpendicular to `a` is an
+ * equally valid 180° rotation and the expression cannot pick between them. This
+ * picks one, by rotating about whichever coordinate axis `a` is least aligned
+ * with. That is a discontinuity in `out` as `b` sweeps through `−a`, and it is
+ * unavoidable: no continuous choice of axis exists on the whole sphere. It is
+ * documented rather than hidden so a caller seeing a bone flip at exactly 180°
+ * knows what it is looking at.
+ *
+ * Sign convention: `(x, y, z, w)` — `w` last, matching {@link Quaternion} and
+ * the rest of the `core/geom/3d/quaternion/` family.
+ *
+ * **Precondition: `a` and `b` are unit length.** The half-way construction uses
+ * `a·b` as a cosine and `|a × b|` as a sine; a non-unit input scales those two
+ * differently and the normalisation cannot undo it, so the result is a rotation
+ * of the wrong angle rather than a rotation of the wrong length.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 4 floats (x, y, z, w)
+ * @param {number} ax unit vector, from
+ * @param {number} ay
+ * @param {number} az
+ * @param {number} bx unit vector, to
+ * @param {number} by
+ * @param {number} bz
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function quat3_shortest_arc(out, out_offset, ax, ay, az, bx, by, bz) {
+    const dot = ax * bx + ay * by + az * bz;
+
+    // The closed form survives far closer to opposition than it looks like it
+    // should. `w = 1 + a·b` shrinks as `δ` while `|a × b|` shrinks only as
+    // `√(2δ)`, so after normalisation `w` reads `cos(θ/2) = √(δ/2)` and stays
+    // accurate until `δ` itself stops resolving — which is at the `Float64`
+    // spacing near −1, around 2e-16. The threshold sits two orders above that,
+    // where the two vectors are 1.4e-7 radians apart and the arbitrary
+    // perpendicular chosen below is wrong by that much and no more.
+    //
+    // An earlier draft put it at 1e-6 in the *dot product*, which is 1.4e-3
+    // radians of angle — a tenth of a degree of silent error, and a spec here
+    // caught it.
+    if (dot < -1 + 1e-14) {
+        // The axis least aligned with `a` gives the cross product below the
+        // most magnitude to work with, which is the whole of the choice.
+        const abs_x = ax < 0 ? -ax : ax;
+        const abs_y = ay < 0 ? -ay : ay;
+        const abs_z = az < 0 ? -az : az;
+
+        let px, py, pz;
+
+        if (abs_x <= abs_y && abs_x <= abs_z) {
+            px = 0; py = -az; pz = ay;
+        } else if (abs_y <= abs_z) {
+            px = az; py = 0; pz = -ax;
+        } else {
+            px = -ay; py = ax; pz = 0;
+        }
+
+        const length = Math.sqrt(px * px + py * py + pz * pz);
+
+        // A 180° rotation is `(axis, 0)`.
+        out[out_offset] = px / length;
+        out[out_offset + 1] = py / length;
+        out[out_offset + 2] = pz / length;
+        out[out_offset + 3] = 0;
+
+        return;
+    }
+
+    const cx = ay * bz - az * by;
+    const cy = az * bx - ax * bz;
+    const cz = ax * by - ay * bx;
+
+    const w = 1 + dot;
+
+    const inverse = 1 / Math.sqrt(cx * cx + cy * cy + cz * cz + w * w);
+
+    out[out_offset] = cx * inverse;
+    out[out_offset + 1] = cy * inverse;
+    out[out_offset + 2] = cz * inverse;
+    out[out_offset + 3] = w * inverse;
+}

package/src/core/geom/3d/ray/Ray3.d.ts

@@ -63,10 +63,10 @@ export class Ray3 extends Float32Array {
      * @param {number} x normalized coordinates in -1,1 range
      * @param {number} y normalized coordinates in -1,1 range
      * @param {number} z normalized coordinates in -1,1 range, typically 0.5
-     * @param {number[]|Float32Array|mat4} transform
-     * @param {number[]|Float32Array|mat4} projection_inverse
+     * @param {number[]|Float32Array|Float64Array} transform
+     * @param {number[]|Float32Array|Float64Array} projection_inverse
      */
-    projectFromPerspectiveCamera(x: number, y: number, z: number, transform: number[] | Float32Array | mat4, projection_inverse: number[] | Float32Array | mat4): void;
+    projectFromPerspectiveCamera(x: number, y: number, z: number, transform: number[] | Float32Array | Float64Array, projection_inverse: number[] | Float32Array | Float64Array): void;
     /**
      *
      * @param {number} distance
@@ -74,9 +74,9 @@ export class Ray3 extends Float32Array {
     shiftForward(distance: number): void;
     /**
      *
-     * @param {number[]|mat4|Float32Array} m4
+     * @param {number[]|Float32Array|Float64Array} m4
      */
-    applyMatrix4(m4: number[] | mat4 | Float32Array): void;
+    applyMatrix4(m4: number[] | Float32Array | Float64Array): void;
     /**
      *
      * @returns {Ray3}

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

@@ -1 +1 @@
-{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/Ray3.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAsOI;;;;;;;;;;OAUG;IACH,sBATW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,UACN,MAAM,GACL,IAAI,CAqBf;IAnQD,cAKC;IAMD,iBAEC;IAND,gBAEC;IAGG,OAAW;IAOf;;;OAGG;IACH,uCAEC;IAVD,sCAEC;IAUD,uBAEC;IAED,uBAEC;IAED,uBAEC;IAGD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAQf;;;OAGG;IACH,0CAEC;IAVD,yCAEC;IAWD,0BAEC;IAED,0BAEC;IAED,0BAEC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAGf,2BAEC;IAED;;;;;;;OAOG;IACH,gCANW,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,OAAK,sBAC1B,MAAM,EAAE,GAAC,YAAY,OAAK,QA6BpC;IAED;;;OAGG;IACH,uBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,UAAM,YAAY,QAmBpC;IAED;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,yBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB;IAmCL;;;;OAIG;IACH,iBAFU,OAAO,CAEI;CAPpB"}
+{"version":3,"file":"Ray3.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/ray/Ray3.js"],"names":[],"mappings":"AAUA;;;GAGG;AACH;IAsOI;;;;;;;;;;OAUG;IACH,sBATW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,UACN,MAAM,GACL,IAAI,CAqBf;IAnQD,cAKC;IAMD,iBAEC;IAND,gBAEC;IAGG,OAAW;IAOf;;;OAGG;IACH,uCAEC;IAVD,sCAEC;IAUD,uBAEC;IAED,uBAEC;IAED,uBAEC;IAGD;;;;;OAKG;IACH,aAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAQf;;;OAGG;IACH,0CAEC;IAVD,yCAEC;IAWD,0BAEC;IAED,0BAEC;IAED,0BAEC;IAED;;;;;OAKG;IACH,gBAJW,MAAM,KACN,MAAM,KACN,MAAM,QAUhB;IAHG,UAAW;IACX,UAAW;IACX,UAAW;IAGf,2BAEC;IAED;;;;;;;OAOG;IACH,gCANW,MAAM,KACN,MAAM,KACN,MAAM,aACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QA6B5C;IAED;;;OAGG;IACH,uBAFW,MAAM,QAMhB;IAED;;;OAGG;IACH,iBAFW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,QAmB5C;IAED;;;OAGG;IACH,SAFa,IAAI,CAQhB;IAED;;;OAGG;IACH,YAFW,IAAI,QAId;IAED,eAEC;IAED;;;;OAIG;IACH,cAHW,IAAI,GACF,OAAO,CAInB;IAED;;;;;;;;;OASG;IACH,yBALW,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB;IAmCL;;;;OAIG;IACH,iBAFU,OAAO,CAEI;CAPpB"}

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

@@ -120,8 +120,8 @@ export class Ray3 extends Float32Array {
      * @param {number} x normalized coordinates in -1,1 range
      * @param {number} y normalized coordinates in -1,1 range
      * @param {number} z normalized coordinates in -1,1 range, typically 0.5
-     * @param {number[]|Float32Array|mat4} transform
-     * @param {number[]|Float32Array|mat4} projection_inverse
+     * @param {number[]|Float32Array|Float64Array} transform
+     * @param {number[]|Float32Array|Float64Array} projection_inverse
      */
     projectFromPerspectiveCamera(
         x, y, z,
@@ -164,7 +164,7 @@ export class Ray3 extends Float32Array {
 
     /**
      *
-     * @param {number[]|mat4|Float32Array} m4
+     * @param {number[]|Float32Array|Float64Array} m4
      */
     applyMatrix4(m4) {
 

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

@@ -122,4 +122,5 @@ export class AbstractShape3D {
      */
     readonly is_convex: boolean;
 }
+export type Ray3 = import("../ray/Ray3.js").Ray3;
 //# sourceMappingURL=AbstractShape3D.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"AbstractShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/AbstractShape3D.js"],"names":[],"mappings":"AASA;IACI;;;;OAIG;IACH,gCAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAJW,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,IAAI,CAIhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,sCALW,MAAM,EAAE,iBACR,MAAM,qBAEJ,IAAI,CA6BhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAInB;IAED;;;OAGG;IACH,qBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAClD,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,gBAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;;;;;OAWG;IACH,aAJW,YAAY,GAAC,MAAM,EAAE,cAEnB,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAGL;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oBAFU,OAAO,CAEkB;CAvBlC"}
+{"version":3,"file":"AbstractShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/AbstractShape3D.js"],"names":[],"mappings":"AAaA;IACI;;;;OAIG;IACH,gCAHW,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,0CAJW,MAAM,EAAE,SACR,MAAM,EAAE,GACN,MAAM,CAIlB;IAED;;;;;OAKG;IACH,iCAJW,MAAM,EAAE,aACR,MAAM,EAAE,GACN,IAAI,CAIhB;IAED;;;;;;;;;;;;;;;OAeG;IACH,sCALW,MAAM,EAAE,iBACR,MAAM,qBAEJ,IAAI,CA6BhB;IAED;;;;OAIG;IACH,sBAHW,MAAM,EAAE,GACN,OAAO,CAInB;IAED;;;OAGG;IACH,qBAEC;IAED;;OAEG;IACH,2BAEC;IAED;;;;OAIG;IACH,6BAHW,MAAM,EAAE,GAAC,UAAU,MAAM,CAAC,GAAC,YAAY,GAAC,YAAY,GAClD,IAAI,CAIhB;IAED;;;;;;;;;OASG;IACH,gBAPW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,GACJ,IAAI,CAIhB;IAED;;;;;;;;;;;OAWG;IACH,aAJW,YAAY,GAAC,MAAM,EAAE,OACrB,IAAI,GACF,OAAO,CAInB;IAED;;;;;;;;;;;OAWG;IACH,cAHW,eAAe,GACb,OAAO,CAInB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAGL;;;;;;;;;;;;;;;;;;;;OAoBG;IACH,oBAFU,OAAO,CAEkB;CAvBlC;mBA7KY,OAAO,gBAAgB,EAAE,IAAI"}

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

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("../ray/Ray3.js").Ray3} Ray3
+ */
+
 /**
  * Rejection-sampling budget for the generic {@link AbstractShape3D#sample_random_point_in_volume}.
  * @type {number}

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

@@ -1 +1 @@
-{"version":3,"file":"BoxShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/BoxShape3D.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;GAYG;AACH;IAQI;;;;;;OAMG;IACH,gBALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAMtB;IAED;;;;;;;OAOG;IACH,wBALW,MAAM,UACN,MAAM,SACN,MAAM,GACJ,UAAU,CAItB;IA9BD;;;;OAIG;IACH,uBAFU,OAAO,CAEyB;IAqC1C,wCAIC;IAED,4DAQC;IAED,qGAKC;IAED,qCAaC;IAED,mEAEC;IAED,6CAaC;IAED,oCAQC;IAED,kFAOC;IAED;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAInB;IAWL;;;;;;OAMG;IACH,uBAFU,OAAO,CAEgB;CAThC;gCAtJ+B,sBAAsB;oBAVlC,kBAAkB"}
+{"version":3,"file":"BoxShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/BoxShape3D.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;GAYG;AACH;IAQI;;;;;;OAMG;IACH,gBALW,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAMtB;IAED;;;;;;;OAOG;IACH,wBALW,MAAM,UACN,MAAM,SACN,MAAM,GACJ,UAAU,CAItB;IA9BD;;;;OAIG;IACH,uBAFU,OAAO,CAEyB;IAqC1C,wCAIC;IAED,4DAQC;IAED,qGAKC;IAED,qCAaC;IAED,mEAIC;IAED,6CAIC;IAED,oCAQC;IAED,kFAOC;IAED;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAInB;IAWL;;;;;;OAMG;IACH,uBAFU,OAAO,CAEgB;CAThC;gCA/I+B,sBAAsB;oBANlC,kBAAkB"}