@woosh/meep-engine 3.22.0 → 3.23.0

package/src/engine/physics/cloth/collider/ClothColliderRecord.d.ts

@@ -0,0 +1,120 @@
+/**
+ * # One packed collider — the layout, and nothing else
+ *
+ * §8.1 asks for "a flat array of packed records, each holding the shape kind
+ * and its parameters, the world matrix, its cached inverse, the previous step's
+ * matrix, the world AABB, friction and inflation". This is that record, as slot
+ * offsets into a strided typed array rather than as a class, because the same
+ * layout is written twice into two different frames and two different
+ * precisions:
+ *
+ * - {@link ClothColliderIndex} holds every live collider in **world**
+ *   coordinates, in a `Float64Array`, because a world coordinate can be
+ *   kilometres from the origin and `Float32` gives up a millimetre there.
+ * - each {@link ClothInstance} holds the subset overlapping *it*, in the
+ *   **cloth's own local frame**, in a `Float32Array`, because that is what the
+ *   step reads and §12 puts the step's state in `Float32` for the bandwidth.
+ *
+ * One layout, so the conversion between them is a loop over slots rather than
+ * two structures that have to be kept in agreement.
+ *
+ * ## The pose is a translation and a quaternion, not a matrix
+ *
+ * §8.2 says swept collision comes from "interpolating the collider's pose
+ * between the previous and current **matrices** at the substep's fraction",
+ * and that is the one part of it that does not work. A component-wise lerp of
+ * two rotation matrices is not a rotation matrix: halfway through a 90° turn it
+ * is a matrix whose columns are neither unit length nor orthogonal, so the
+ * shape it poses is *shrunk and sheared* — and a collider that shrinks halfway
+ * through every step lets cloth through. `MEASUREMENTS.md` §16 measures the
+ * size of it. A rigid pose interpolates as a translation and a quaternion, and
+ * that is what these slots hold.
+ *
+ * The interpolated pose is written back into slots {@link CCR_INTERP_TX}
+ * onwards once per substep per collider, so the per-particle inner loop reads a
+ * pose rather than computing one.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/** Shape kind — a {@link ClothColliderKind}. */
+export const CCR_KIND: 0;
+/** Shape parameter 0: radius, or half-extent x, or plane normal x. */
+export const CCR_PARAM_0: 1;
+/** Shape parameter 1: height, or half-extent y, or plane normal y. */
+export const CCR_PARAM_1: 2;
+/** Shape parameter 2: half-extent z, or plane normal z. */
+export const CCR_PARAM_2: 3;
+/** Shape parameter 3: the plane's offset. Unused by every other kind. */
+export const CCR_PARAM_3: 4;
+/**
+ * The shape's smallest curvature radius, metres — `Infinity` for a plane.
+ *
+ * The vertex update's trust region (§5.3) caps a step at the distance over
+ * which the model it was built from still resembles the energy, and for a
+ * contact row the model's gradient is a surface normal. A normal is a good
+ * description of a surface over the surface's own curvature radius and a poor
+ * one beyond it, so this is that distance, measured from the shape rather than
+ * tuned.
+ */
+export const CCR_FEATURE: 5;
+/** Combined Coulomb friction coefficient for this collider against cloth. */
+export const CCR_FRICTION: 6;
+/** Extra thickness in metres, on top of `ClothDynamics#thickness`. */
+export const CCR_INFLATION: 7;
+/** Current pose, translation. */
+export const CCR_TX: 8;
+export const CCR_TY: 9;
+export const CCR_TZ: 10;
+/** Current pose, rotation (x, y, z, w). */
+export const CCR_QX: 11;
+export const CCR_QY: 12;
+export const CCR_QZ: 13;
+export const CCR_QW: 14;
+/** Previous step's pose, translation. */
+export const CCR_PREV_TX: 15;
+export const CCR_PREV_TY: 16;
+export const CCR_PREV_TZ: 17;
+/** Previous step's pose, rotation (x, y, z, w). */
+export const CCR_PREV_QX: 18;
+export const CCR_PREV_QY: 19;
+export const CCR_PREV_QZ: 20;
+export const CCR_PREV_QW: 21;
+/**
+ * Axis-aligned bounds of the swept shape — the union of its bounds under both
+ * poses — in whichever frame this table is expressed in. The broadphase, and
+ * the reason a cloth only converts the colliders that could touch it.
+ */
+export const CCR_AABB_MIN_X: 22;
+export const CCR_AABB_MIN_Y: 23;
+export const CCR_AABB_MIN_Z: 24;
+export const CCR_AABB_MAX_X: 25;
+export const CCR_AABB_MAX_Y: 26;
+export const CCR_AABB_MAX_Z: 27;
+/**
+ * The pose interpolated to the substep in progress, translation. Written once
+ * per substep per collider by `cloth_collider_pose_at`; read per particle per
+ * iteration.
+ */
+export const CCR_INTERP_TX: 28;
+export const CCR_INTERP_TY: 29;
+export const CCR_INTERP_TZ: 30;
+/** The pose interpolated to the substep in progress, rotation (x, y, z, w). */
+export const CCR_INTERP_QX: 31;
+export const CCR_INTERP_QY: 32;
+export const CCR_INTERP_QZ: 33;
+export const CCR_INTERP_QW: 34;
+/** Floats in one record. */
+export const CCR_STRIDE: 35;
+/**
+ * Slots in the parallel `Int32Array` the index keeps beside the float table:
+ * the layer bit, the mask, and the entity. None of them is a float — a mask of
+ * `0xFFFFFFFF` needs 32 bits of mantissa and `Float32` has 24, so packing them
+ * in beside the geometry would silently round the highest layers together.
+ */
+export const CCR_META_LAYER: 0;
+export const CCR_META_MASK: 1;
+export const CCR_META_ENTITY: 2;
+/** Ints in one record's metadata. */
+export const CCR_META_STRIDE: 3;
+//# sourceMappingURL=ClothColliderRecord.d.ts.map

package/src/engine/physics/cloth/collider/ClothColliderRecord.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ClothColliderRecord.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderRecord.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AAEH,gDAAgD;AAChD,yBAA0B;AAE1B,sEAAsE;AACtE,4BAA6B;AAE7B,sEAAsE;AACtE,4BAA6B;AAE7B,2DAA2D;AAC3D,4BAA6B;AAE7B,yEAAyE;AACzE,4BAA6B;AAE7B;;;;;;;;;GASG;AACH,4BAA6B;AAE7B,6EAA6E;AAC7E,6BAA8B;AAE9B,sEAAsE;AACtE,8BAA+B;AAE/B,iCAAiC;AACjC,uBAAwB;AACxB,uBAAwB;AACxB,wBAAyB;AAEzB,2CAA2C;AAC3C,wBAAyB;AACzB,wBAAyB;AACzB,wBAAyB;AACzB,wBAAyB;AAEzB,yCAAyC;AACzC,6BAA8B;AAC9B,6BAA8B;AAC9B,6BAA8B;AAE9B,mDAAmD;AACnD,6BAA8B;AAC9B,6BAA8B;AAC9B,6BAA8B;AAC9B,6BAA8B;AAE9B;;;;GAIG;AACH,gCAAiC;AACjC,gCAAiC;AACjC,gCAAiC;AACjC,gCAAiC;AACjC,gCAAiC;AACjC,gCAAiC;AAEjC;;;;GAIG;AACH,+BAAgC;AAChC,+BAAgC;AAChC,+BAAgC;AAEhC,+EAA+E;AAC/E,+BAAgC;AAChC,+BAAgC;AAChC,+BAAgC;AAChC,+BAAgC;AAEhC,4BAA4B;AAC5B,4BAA6B;AAE7B;;;;;GAKG;AACH,+BAAgC;AAChC,8BAA+B;AAC/B,gCAAiC;AAEjC,qCAAqC;AACrC,gCAAiC"}

package/src/engine/physics/cloth/collider/ClothColliderRecord.js

@@ -0,0 +1,137 @@
+/**
+ * # One packed collider — the layout, and nothing else
+ *
+ * §8.1 asks for "a flat array of packed records, each holding the shape kind
+ * and its parameters, the world matrix, its cached inverse, the previous step's
+ * matrix, the world AABB, friction and inflation". This is that record, as slot
+ * offsets into a strided typed array rather than as a class, because the same
+ * layout is written twice into two different frames and two different
+ * precisions:
+ *
+ * - {@link ClothColliderIndex} holds every live collider in **world**
+ *   coordinates, in a `Float64Array`, because a world coordinate can be
+ *   kilometres from the origin and `Float32` gives up a millimetre there.
+ * - each {@link ClothInstance} holds the subset overlapping *it*, in the
+ *   **cloth's own local frame**, in a `Float32Array`, because that is what the
+ *   step reads and §12 puts the step's state in `Float32` for the bandwidth.
+ *
+ * One layout, so the conversion between them is a loop over slots rather than
+ * two structures that have to be kept in agreement.
+ *
+ * ## The pose is a translation and a quaternion, not a matrix
+ *
+ * §8.2 says swept collision comes from "interpolating the collider's pose
+ * between the previous and current **matrices** at the substep's fraction",
+ * and that is the one part of it that does not work. A component-wise lerp of
+ * two rotation matrices is not a rotation matrix: halfway through a 90° turn it
+ * is a matrix whose columns are neither unit length nor orthogonal, so the
+ * shape it poses is *shrunk and sheared* — and a collider that shrinks halfway
+ * through every step lets cloth through. `MEASUREMENTS.md` §16 measures the
+ * size of it. A rigid pose interpolates as a translation and a quaternion, and
+ * that is what these slots hold.
+ *
+ * The interpolated pose is written back into slots {@link CCR_INTERP_TX}
+ * onwards once per substep per collider, so the per-particle inner loop reads a
+ * pose rather than computing one.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/** Shape kind — a {@link ClothColliderKind}. */
+export const CCR_KIND = 0;
+
+/** Shape parameter 0: radius, or half-extent x, or plane normal x. */
+export const CCR_PARAM_0 = 1;
+
+/** Shape parameter 1: height, or half-extent y, or plane normal y. */
+export const CCR_PARAM_1 = 2;
+
+/** Shape parameter 2: half-extent z, or plane normal z. */
+export const CCR_PARAM_2 = 3;
+
+/** Shape parameter 3: the plane's offset. Unused by every other kind. */
+export const CCR_PARAM_3 = 4;
+
+/**
+ * The shape's smallest curvature radius, metres — `Infinity` for a plane.
+ *
+ * The vertex update's trust region (§5.3) caps a step at the distance over
+ * which the model it was built from still resembles the energy, and for a
+ * contact row the model's gradient is a surface normal. A normal is a good
+ * description of a surface over the surface's own curvature radius and a poor
+ * one beyond it, so this is that distance, measured from the shape rather than
+ * tuned.
+ */
+export const CCR_FEATURE = 5;
+
+/** Combined Coulomb friction coefficient for this collider against cloth. */
+export const CCR_FRICTION = 6;
+
+/** Extra thickness in metres, on top of `ClothDynamics#thickness`. */
+export const CCR_INFLATION = 7;
+
+/** Current pose, translation. */
+export const CCR_TX = 8;
+export const CCR_TY = 9;
+export const CCR_TZ = 10;
+
+/** Current pose, rotation (x, y, z, w). */
+export const CCR_QX = 11;
+export const CCR_QY = 12;
+export const CCR_QZ = 13;
+export const CCR_QW = 14;
+
+/** Previous step's pose, translation. */
+export const CCR_PREV_TX = 15;
+export const CCR_PREV_TY = 16;
+export const CCR_PREV_TZ = 17;
+
+/** Previous step's pose, rotation (x, y, z, w). */
+export const CCR_PREV_QX = 18;
+export const CCR_PREV_QY = 19;
+export const CCR_PREV_QZ = 20;
+export const CCR_PREV_QW = 21;
+
+/**
+ * Axis-aligned bounds of the swept shape — the union of its bounds under both
+ * poses — in whichever frame this table is expressed in. The broadphase, and
+ * the reason a cloth only converts the colliders that could touch it.
+ */
+export const CCR_AABB_MIN_X = 22;
+export const CCR_AABB_MIN_Y = 23;
+export const CCR_AABB_MIN_Z = 24;
+export const CCR_AABB_MAX_X = 25;
+export const CCR_AABB_MAX_Y = 26;
+export const CCR_AABB_MAX_Z = 27;
+
+/**
+ * The pose interpolated to the substep in progress, translation. Written once
+ * per substep per collider by `cloth_collider_pose_at`; read per particle per
+ * iteration.
+ */
+export const CCR_INTERP_TX = 28;
+export const CCR_INTERP_TY = 29;
+export const CCR_INTERP_TZ = 30;
+
+/** The pose interpolated to the substep in progress, rotation (x, y, z, w). */
+export const CCR_INTERP_QX = 31;
+export const CCR_INTERP_QY = 32;
+export const CCR_INTERP_QZ = 33;
+export const CCR_INTERP_QW = 34;
+
+/** Floats in one record. */
+export const CCR_STRIDE = 35;
+
+/**
+ * Slots in the parallel `Int32Array` the index keeps beside the float table:
+ * the layer bit, the mask, and the entity. None of them is a float — a mask of
+ * `0xFFFFFFFF` needs 32 bits of mantissa and `Float32` has 24, so packing them
+ * in beside the geometry would silently round the highest layers together.
+ */
+export const CCR_META_LAYER = 0;
+export const CCR_META_MASK = 1;
+export const CCR_META_ENTITY = 2;
+
+/** Ints in one record's metadata. */
+export const CCR_META_STRIDE = 3;

package/src/engine/physics/cloth/collider/cloth_collider_bounds.d.ts

@@ -0,0 +1,25 @@
+/**
+ * # The swept bounds of a packed collider
+ *
+ * The union of the shape's bounds under the previous pose and the current one —
+ * the volume the collider moved through this step, which is the set a particle
+ * has to be in for the sweep to be able to catch it.
+ *
+ * A free function rather than a method on {@link ClothColliderIndex} because
+ * two tables need it and they are in different frames: the index's, in world
+ * coordinates, and each cloth's, in its own. Both are the same layout, so both
+ * are the same arithmetic.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Refit one record's bounds from its two poses.
+ *
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {number} stride
+ * @returns {void}
+ */
+export function cloth_collider_refit_bounds(table: Float32Array | Float64Array, record: number, stride: number): void;
+//# sourceMappingURL=cloth_collider_bounds.d.ts.map

package/src/engine/physics/cloth/collider/cloth_collider_bounds.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_collider_bounds.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_bounds.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;GAOG;AACH,mDALW,YAAY,GAAC,YAAY,UACzB,MAAM,UACN,MAAM,GACJ,IAAI,CAoBhB"}

package/src/engine/physics/cloth/collider/cloth_collider_bounds.js

@@ -0,0 +1,190 @@
+import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
+import {
+    m4_from_rotation_translation_scale_scalar
+} from "../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale_scalar.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
+import { ClothColliderKind } from "./ClothColliderKind.js";
+import {
+    CCR_AABB_MAX_X,
+    CCR_AABB_MIN_X,
+    CCR_KIND,
+    CCR_PARAM_0,
+    CCR_PARAM_1,
+    CCR_PARAM_2,
+    CCR_PARAM_3,
+    CCR_PREV_QX,
+    CCR_PREV_TX,
+    CCR_QX,
+    CCR_TX
+} from "./ClothColliderRecord.js";
+import { cloth_collider_local_bounds } from "./cloth_collider_pack.js";
+
+/**
+ * # The swept bounds of a packed collider
+ *
+ * The union of the shape's bounds under the previous pose and the current one —
+ * the volume the collider moved through this step, which is the set a particle
+ * has to be in for the sweep to be able to catch it.
+ *
+ * A free function rather than a method on {@link ClothColliderIndex} because
+ * two tables need it and they are in different frames: the index's, in world
+ * coordinates, and each cloth's, in its own. Both are the same layout, so both
+ * are the same arithmetic.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+
+/**
+ * Refit one record's bounds from its two poses.
+ *
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {number} stride
+ * @returns {void}
+ */
+export function cloth_collider_refit_bounds(table, record, stride) {
+    const r = record * stride;
+
+    if (table[r + CCR_KIND] === ClothColliderKind.Plane) {
+        refit_plane(table, r);
+
+        return;
+    }
+
+    cloth_collider_local_bounds(LOCAL_BOUNDS, table, record, stride);
+
+    project(CURRENT_BOUNDS, table, r + CCR_QX, r + CCR_TX);
+    project(PREVIOUS_BOUNDS, table, r + CCR_PREV_QX, r + CCR_PREV_TX);
+
+    for (let axis = 0; axis < 3; axis++) {
+        table[r + CCR_AABB_MIN_X + axis] = Math.min(CURRENT_BOUNDS[axis], PREVIOUS_BOUNDS[axis]);
+        table[r + CCR_AABB_MAX_X + axis] = Math.max(CURRENT_BOUNDS[axis + 3], PREVIOUS_BOUNDS[axis + 3]);
+    }
+}
+
+/**
+ * @param {Float64Array} out
+ * @param {Float32Array|Float64Array} table
+ * @param {number} rotation slot of the pose's rotation
+ * @param {number} translation slot of the pose's translation
+ * @private
+ */
+function project(out, table, rotation, translation) {
+    m4_from_rotation_translation_scale_scalar(
+        POSE,
+        table[rotation], table[rotation + 1], table[rotation + 2], table[rotation + 3],
+        table[translation], table[translation + 1], table[translation + 2],
+        1, 1, 1
+    );
+
+    aabb3_matrix4_project(out, LOCAL_BOUNDS, POSE);
+}
+
+/**
+ * A half-space's bounds, which cannot go through {@link aabb3_matrix4_project}
+ * — an infinite extent multiplied by a zero matrix element is `NaN`. The
+ * plane's world normal is its local normal rotated by the pose, and the bound
+ * exists on an axis exactly when that normal is aligned with it.
+ *
+ * @param {Float32Array|Float64Array} table
+ * @param {number} r the record's slot offset
+ * @private
+ */
+function refit_plane(table, r) {
+    for (let axis = 0; axis < 3; axis++) {
+        table[r + CCR_AABB_MIN_X + axis] = Infinity;
+        table[r + CCR_AABB_MAX_X + axis] = -Infinity;
+    }
+
+    for (const pose of PLANE_POSES) {
+        const rotation = r + pose[0];
+        const translation = r + pose[1];
+
+        v3_quaternion_apply(
+            PLANE_NORMAL, 0,
+            table[r + CCR_PARAM_0], table[r + CCR_PARAM_1], table[r + CCR_PARAM_2],
+            table[rotation], table[rotation + 1], table[rotation + 2], table[rotation + 3]
+        );
+
+        // The boundary plane passes through `R·(offset·n_local) + t`, so its
+        // offset along the *world* normal is `offset + n_world·t`.
+        const offset = table[r + CCR_PARAM_3]
+            + PLANE_NORMAL[0] * table[translation]
+            + PLANE_NORMAL[1] * table[translation + 1]
+            + PLANE_NORMAL[2] * table[translation + 2];
+
+        for (let axis = 0; axis < 3; axis++) {
+            const n = PLANE_NORMAL[axis];
+
+            // Only an exactly axis-aligned normal bounds an axis, and the two
+            // poses have to agree — the union of two half-spaces facing
+            // different ways is not a half-space, so the looser of the two wins
+            // and a rotating plane simply stops bounding anything.
+            if (n > PLANE_AXIS_TOLERANCE) {
+                table[r + CCR_AABB_MAX_X + axis] = Math.max(table[r + CCR_AABB_MAX_X + axis], offset);
+            } else if (n < -PLANE_AXIS_TOLERANCE) {
+                table[r + CCR_AABB_MIN_X + axis] = Math.min(table[r + CCR_AABB_MIN_X + axis], -offset);
+            }
+        }
+    }
+
+    // An axis neither pose bounded is unbounded, which is the correct answer for
+    // a tilted plane and makes every query find it.
+    for (let axis = 0; axis < 3; axis++) {
+        if (table[r + CCR_AABB_MAX_X + axis] === -Infinity) {
+            table[r + CCR_AABB_MAX_X + axis] = Infinity;
+        }
+
+        if (table[r + CCR_AABB_MIN_X + axis] === Infinity) {
+            table[r + CCR_AABB_MIN_X + axis] = -Infinity;
+        }
+    }
+}
+
+/**
+ * How close to an axis a plane's normal has to be for the half-space to bound
+ * that axis. A hundred-thousandth of a radian off, which no authored ground
+ * plane is and no accumulated rotation error reaches.
+ * @type {number}
+ * @private
+ */
+const PLANE_AXIS_TOLERANCE = 0.999999;
+
+/**
+ * The two pose slot pairs a plane's bounds are computed from — current, then
+ * previous — as `[rotation, translation]` offsets within a record.
+ * @type {number[][]}
+ * @private
+ */
+const PLANE_POSES = [[CCR_QX, CCR_TX], [CCR_PREV_QX, CCR_PREV_TX]];
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const PLANE_NORMAL = new Float64Array(3);
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const LOCAL_BOUNDS = new Float64Array(6);
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const CURRENT_BOUNDS = new Float64Array(6);
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const PREVIOUS_BOUNDS = new Float64Array(6);
+
+/**
+ * @type {Float64Array}
+ * @private
+ */
+const POSE = new Float64Array(16);

package/src/engine/physics/cloth/collider/cloth_collider_pack.d.ts

@@ -0,0 +1,44 @@
+/**
+ * # `AbstractShape3D` → a packed record's geometry
+ *
+ * The one place a cloth collider is a shape object rather than a row of floats.
+ * It runs when a `ClothCollider` is linked or its shape changes, never per step
+ * and never per particle.
+ *
+ * `instanceof` rather than the prototype markers the physics narrowphase uses,
+ * because this needs to distinguish *five* kinds rather than short-circuit one,
+ * and because a marker per kind would be five new fields on `core` shapes for
+ * one consumer's benefit. The ordering matters in one place and is commented
+ * where it does.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+/**
+ * Write a shape's kind, parameters and feature size into a record.
+ *
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record record index, not a slot offset
+ * @param {AbstractShape3D} shape in its canonical local frame
+ * @param {number} stride
+ * @returns {boolean} `false` if the shape is not one cloth can collide against,
+ *   in which case nothing was written
+ */
+export function cloth_collider_pack(table: Float32Array | Float64Array, record: number, shape: AbstractShape3D, stride: number): boolean;
+/**
+ * The AABB of a packed shape in its own local frame, ignoring pose.
+ *
+ * Written here rather than taken from `AbstractShape3D#compute_bounding_box`
+ * because a plane's box is `±Infinity` on its unbounded axes and the caller
+ * transforms this one — `0 · Infinity` is `NaN`, so an unbounded local box
+ * cannot go through a pose. {@link cloth_collider_local_bounds} therefore
+ * refuses a plane and the index bounds one directly from its world normal.
+ *
+ * @param {Float64Array|number[]} out `[x0, y0, z0, x1, y1, z1]`
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {number} stride
+ * @returns {boolean} `false` for an unbounded kind, in which case `out` is untouched
+ */
+export function cloth_collider_local_bounds(out: Float64Array | number[], table: Float32Array | Float64Array, record: number, stride: number): boolean;
+//# sourceMappingURL=cloth_collider_pack.d.ts.map

package/src/engine/physics/cloth/collider/cloth_collider_pack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"cloth_collider_pack.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_pack.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;;GASG;AACH,2CAPW,YAAY,GAAC,YAAY,UACzB,MAAM,kCAEN,MAAM,GACJ,OAAO,CAiFnB;AAED;;;;;;;;;;;;;;GAcG;AACH,iDANW,YAAY,GAAC,MAAM,EAAE,SACrB,YAAY,GAAC,YAAY,UACzB,MAAM,UACN,MAAM,GACJ,OAAO,CAqCnB"}