@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -237,6 +237,19 @@ export class ClothColliderIndex {
      * @returns {number} how many handles were written
      */
     query(out: number[], min_x: number, min_y: number, min_z: number, max_x: number, max_y: number, max_z: number, layer: number, mask: number, contact?: boolean): number;
+    /**
+     * {@link query} with the box read from an array. For a caller that queries every step: six
+     * numbers handed to a call are each boxed into a heap object wherever V8 does not inline it.
+     *
+     * @param {number[]} out grown as needed; only `[0, returned)` is valid
+     * @param {number[]|Float32Array|Float64Array} box `[min_x, min_y, min_z, max_x, max_y, max_z]`
+     * @param {number} box_offset
+     * @param {number} layer the querier's layer
+     * @param {number} mask the querier's mask
+     * @param {boolean} contact as {@link query}'s
+     * @returns {number} how many handles were written
+     */
+    queryArray(out: number[], box: number[] | Float32Array | Float64Array, box_offset: number, layer: number, mask: number, contact: boolean): number;
     #private;
 }
 //# sourceMappingURL=ClothColliderIndex.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"ClothColliderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderIndex.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;IAEI;;;;;;OAMG;IACH,OAFU,YAAY,CAEM;IAE5B;;;;;OAKG;IACH,MAFU,UAAU,CAEK;IAEzB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;OAMG;IACH,qBAFU,MAAM,CAEQ;IAoFxB;;;;;;;;;;;OAWG;IACH,sCAPW,MAAM,aACN,MAAM,SACN,MAAM,QACN,MAAM,UACN,MAAM,GACJ,MAAM,CA8DlB;IAED;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,IAAI,CAoChB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAuDhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CA2BhB;IAwID;;;;;;;;;;;;;;;OAeG;IACH,kBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAiBhB;IAED;;;;;;;;OAQG;IACH,mBALW,MAAM,YACN,MAAM,aACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,IAAI,CAWhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAdW,MAAM,EAAE,SACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QACN,MAAM,YACN,OAAO,GAGL,MAAM,CA6DlB;;CA6GJ"}
+{"version":3,"file":"ClothColliderIndex.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/ClothColliderIndex.js"],"names":[],"mappings":"AA2CA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgFG;AACH;IAEI;;;;;;OAMG;IACH,OAFU,YAAY,CAEM;IAE5B;;;;;OAKG;IACH,MAFU,UAAU,CAEK;IAEzB;;;;OAIG;IACH,OAFU,MAAM,CAEN;IAEV;;;;;;OAMG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;OAMG;IACH,qBAFU,MAAM,CAEQ;IAoFxB;;;;;;;;;;;OAWG;IACH,sCAPW,MAAM,aACN,MAAM,SACN,MAAM,QACN,MAAM,UACN,MAAM,GACJ,MAAM,CA8DlB;IAED;;;;;;;OAOG;IACH,eAHW,MAAM,GACJ,IAAI,CAoChB;IAED;;;;OAIG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;OAGG;IACH,mBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;OAIG;IACH,WAFa,IAAI,CAuDhB;IAED;;;;;;;;;;;;;;;;;OAiBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CA8BhB;IAwID;;;;;;;;;;;;;;;OAeG;IACH,kBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,IAAI,CAmBhB;IAED;;;;;;;;OAQG;IACH,mBALW,MAAM,YACN,MAAM,aACN,MAAM,GACJ,IAAI,CAoBhB;IAED;;;;;OAKG;IACH,kBALW,MAAM,SACN,MAAM,QACN,MAAM,GACJ,IAAI,CAWhB;IAED;;;OAGG;IACH,iBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,WAdW,MAAM,EAAE,SACR,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,SACN,MAAM,QACN,MAAM,YACN,OAAO,GAGL,MAAM,CAWlB;IAED;;;;;;;;;;;OAWG;IACH,gBARW,MAAM,EAAE,OACR,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,SACN,MAAM,QACN,MAAM,WACN,OAAO,GACL,MAAM,CA6DlB;;CAyGJ"}

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

@@ -462,7 +462,10 @@ export class ClothColliderIndex {
      * @returns {void}
      */
     setPose(handle, tx, ty, tz, qx, qy, qz, qw) {
-        assert.ok(this.isLive(handle), `cloth collider handle ${handle} is not live`);
+        // the message is built only when the check fails: as an argument it was a string per call
+        if (!this.isLive(handle)) {
+            assert.ok(false, `cloth collider handle ${handle} is not live`);
+        }
 
         const table = this.table;
 
@@ -639,7 +642,9 @@ export class ClothColliderIndex {
      * @returns {void}
      */
     placePose(handle, tx, ty, tz, qx, qy, qz, qw) {
-        assert.ok(this.isLive(handle), `cloth collider handle ${handle} is not live`);
+        if (!this.isLive(handle)) {
+            assert.ok(false, `cloth collider handle ${handle} is not live`);
+        }
 
         const r = handle * CCR_STRIDE;
 
@@ -732,12 +737,35 @@ export class ClothColliderIndex {
      * @returns {number} how many handles were written
      */
     query(out, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask, contact = false) {
-        QUERY_AABB[0] = min_x;
-        QUERY_AABB[1] = min_y;
-        QUERY_AABB[2] = min_z;
-        QUERY_AABB[3] = max_x;
-        QUERY_AABB[4] = max_y;
-        QUERY_AABB[5] = max_z;
+        SCALAR_BOX[0] = min_x;
+        SCALAR_BOX[1] = min_y;
+        SCALAR_BOX[2] = min_z;
+        SCALAR_BOX[3] = max_x;
+        SCALAR_BOX[4] = max_y;
+        SCALAR_BOX[5] = max_z;
+
+        return this.queryArray(out, SCALAR_BOX, 0, layer, mask, contact);
+    }
+
+    /**
+     * {@link query} with the box read from an array. For a caller that queries every step: six
+     * numbers handed to a call are each boxed into a heap object wherever V8 does not inline it.
+     *
+     * @param {number[]} out grown as needed; only `[0, returned)` is valid
+     * @param {number[]|Float32Array|Float64Array} box `[min_x, min_y, min_z, max_x, max_y, max_z]`
+     * @param {number} box_offset
+     * @param {number} layer the querier's layer
+     * @param {number} mask the querier's mask
+     * @param {boolean} contact as {@link query}'s
+     * @returns {number} how many handles were written
+     */
+    queryArray(out, box, box_offset, layer, mask, contact) {
+        QUERY_AABB[0] = box[box_offset];
+        QUERY_AABB[1] = box[box_offset + 1];
+        QUERY_AABB[2] = box[box_offset + 2];
+        QUERY_AABB[3] = box[box_offset + 3];
+        QUERY_AABB[4] = box[box_offset + 4];
+        QUERY_AABB[5] = box[box_offset + 5];
 
         // Grow and retry: the traversal returns the TRUE overlap count and
         // drops writes past the end, so a short buffer is a resize rather than
@@ -765,7 +793,7 @@ export class ClothColliderIndex {
 
             // Raw queries use the exact record. Contact queries retain the
             // conversion allowance needed by the solver's Float32 table.
-            if (this.#overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask, contact)) {
+            if (this.#overlaps(handle, layer, mask, contact)) {
                 answer.push(handle);
             }
         }
@@ -775,7 +803,7 @@ export class ClothColliderIndex {
         for (let i = 0; i < planes.length; i++) {
             const handle = planes[i];
 
-            if (this.#overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask, contact)) {
+            if (this.#overlaps(handle, layer, mask, contact)) {
                 answer.push(handle);
             }
         }
@@ -783,7 +811,7 @@ export class ClothColliderIndex {
         // Ascending handle order — see the class docblock. The wake test
         // compares element by element and the gather's overflow keeps a prefix,
         // so both read this order as meaning.
-        answer.sort(ASCENDING);
+        sort_handles(answer);
 
         for (let i = 0; i < answer.length; i++) {
             out[i] = answer[i];
@@ -794,22 +822,16 @@ export class ClothColliderIndex {
 
     /**
      * Whether a live record passes the filter and its exact swept bounds meet
-     * the box.
+     * the box being queried, {@link QUERY_AABB}.
      *
      * @param {number} handle
-     * @param {number} min_x
-     * @param {number} min_y
-     * @param {number} min_z
-     * @param {number} max_x
-     * @param {number} max_y
-     * @param {number} max_z
      * @param {number} layer
      * @param {number} mask
      * @param {boolean} contact
      * @returns {boolean}
      * @private
      */
-    #overlaps(handle, min_x, min_y, min_z, max_x, max_y, max_z, layer, mask, contact) {
+    #overlaps(handle, layer, mask, contact) {
         if (this.#live[handle] === 0) {
             return false;
         }
@@ -837,15 +859,17 @@ export class ClothColliderIndex {
 
         const reach = contact ? this.#reach[handle] : 0;
 
-        if (table[r + CCR_AABB_MIN_X] - reach > max_x || table[r + CCR_AABB_MAX_X] + reach < min_x) {
+        const box = QUERY_AABB;
+
+        if (table[r + CCR_AABB_MIN_X] - reach > box[3] || table[r + CCR_AABB_MAX_X] + reach < box[0]) {
             return false;
         }
 
-        if (table[r + CCR_AABB_MIN_Y] - reach > max_y || table[r + CCR_AABB_MAX_Y] + reach < min_y) {
+        if (table[r + CCR_AABB_MIN_Y] - reach > box[4] || table[r + CCR_AABB_MAX_Y] + reach < box[1]) {
             return false;
         }
 
-        if (table[r + CCR_AABB_MIN_Z] - reach > max_z || table[r + CCR_AABB_MAX_Z] + reach < min_z) {
+        if (table[r + CCR_AABB_MIN_Z] - reach > box[5] || table[r + CCR_AABB_MAX_Z] + reach < box[2]) {
             return false;
         }
 
@@ -919,10 +943,54 @@ const BVH_LEAF_SLACK = 0.05;
 const FLOAT32_ROUNDING = 2 ** -22;
 
 /**
+ * The box being queried, `[min_x, min_y, min_z, max_x, max_y, max_z]`: what the tree is walked with
+ * and what {@link ClothColliderIndex#overlaps} tests each candidate against.
  * @type {Float64Array}
  */
 const QUERY_AABB = new Float64Array(6);
 
+/**
+ * {@link ClothColliderIndex#query}'s box, packed for {@link ClothColliderIndex#queryArray}.
+ * @type {Float64Array}
+ */
+const SCALAR_BOX = new Float64Array(6);
+
+/**
+ * Above this many handles {@link sort_handles} hands the work to `Array.prototype.sort`.
+ * @type {number}
+ */
+const INSERTION_SORT_LIMIT = 32;
+
+/**
+ * Sort handles ascending, in place. A query finds a handful, and for those an insertion sort is as
+ * fast as `Array.prototype.sort` and allocates nothing, where the built-in copies the elements into
+ * a work array of its own on every call. Both are stable, and handles are integers, so the order is
+ * the same either way.
+ * @param {number[]} handles
+ */
+function sort_handles(handles) {
+    const n = handles.length;
+
+    if (n > INSERTION_SORT_LIMIT) {
+        handles.sort(ASCENDING);
+
+        return;
+    }
+
+    for (let i = 1; i < n; i++) {
+        const handle = handles[i];
+
+        let j = i - 1;
+
+        while (j >= 0 && handles[j] > handle) {
+            handles[j + 1] = handles[j];
+            j--;
+        }
+
+        handles[j + 1] = handle;
+    }
+}
+
 /**
  * The box on its way into a leaf.
  * @type {Float64Array}

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

@@ -1,8 +1,8 @@
 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";
+    m4_from_rotation_translation_scale_array
+} from "../../../../core/geom/3d/mat4/m4_from_rotation_translation_scale_array.js";
+import { v3_quaternion_apply_array } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import { ClothColliderKind } from "./ClothColliderKind.js";
 import {
     CCR_AABB_MAX_X,
@@ -91,11 +91,68 @@ export function cloth_collider_refit_bounds(table, record, stride) {
     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]);
+        table[r + CCR_AABB_MIN_X + axis] = min_exact(CURRENT_BOUNDS[axis], PREVIOUS_BOUNDS[axis]);
+        table[r + CCR_AABB_MAX_X + axis] = max_exact(CURRENT_BOUNDS[axis + 3], PREVIOUS_BOUNDS[axis + 3]);
     }
 }
 
+/**
+ * `Math.min(a, b)` without the call: the smaller, NaN if either is, and `-0` below `+0`. The refit
+ * runs a few times a cloth a step, so V8 is slow to optimise it, and until it does `Math.min` is a
+ * call into a builtin that hands its answer back boxed into a heap object.
+ *
+ * The same as `Math.min` under `Object.is` for every pair of numbers. A NaN answer is the canonical
+ * NaN; which NaN `Math.min` answers is the platform's (on x64, the one with the sign bit set).
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ * @private
+ */
+function min_exact(a, b) {
+    if (a < b) {
+        return a;
+    }
+
+    if (b < a) {
+        return b;
+    }
+
+    if (a === b) {
+        // equal, and of two zeros the negative one if either is
+        return a === 0 && 1 / a > 0 ? b : a;
+    }
+
+    // one of them is NaN
+    return NaN;
+}
+
+/**
+ * `Math.max(a, b)` without the call, as {@link min_exact}: the larger, NaN if either is, and `+0`
+ * above `-0`.
+ *
+ * @param {number} a
+ * @param {number} b
+ * @returns {number}
+ * @private
+ */
+function max_exact(a, b) {
+    if (a > b) {
+        return a;
+    }
+
+    if (b > a) {
+        return b;
+    }
+
+    if (a === b) {
+        // equal, and of two zeros the positive one if either is
+        return a === 0 && 1 / a < 0 ? b : a;
+    }
+
+    return NaN;
+}
+
 /**
  * @param {Float64Array} out
  * @param {Float32Array|Float64Array} table
@@ -104,12 +161,10 @@ export function cloth_collider_refit_bounds(table, record, stride) {
  * @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
-    );
+    // The pose is read where it sits in the table. Handed to the compose as ten numbers, the seven
+    // that are not small integers were each boxed into a heap object wherever the call was not
+    // inlined.
+    m4_from_rotation_translation_scale_array(POSE, table, rotation, table, translation, UNIT_SCALE, 0);
 
     aabb3_matrix4_project(out, LOCAL_BOUNDS, POSE);
 }
@@ -130,15 +185,13 @@ function refit_plane(table, r) {
         table[r + CCR_AABB_MAX_X + axis] = -Infinity;
     }
 
-    for (const pose of PLANE_POSES) {
-        const rotation = r + pose[0];
-        const translation = r + pose[1];
+    // indexed rather than `for...of`, which until V8 optimises this allocates an iterator result per pose
+    for (let p = 0; p < PLANE_POSES.length; p += 2) {
+        const rotation = r + PLANE_POSES[p];
+        const translation = r + PLANE_POSES[p + 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 local normal and the rotation straight from the table, as in `project`
+        v3_quaternion_apply_array(PLANE_NORMAL, 0, table, r + CCR_PARAM_0, table, rotation);
 
         // The boundary plane passes through `R·(offset·n_local) + t`, so its
         // offset along the *world* normal is `offset + n_world·t`.
@@ -155,9 +208,9 @@ function refit_plane(table, r) {
             // 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);
+                table[r + CCR_AABB_MAX_X + axis] = max_exact(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);
+                table[r + CCR_AABB_MIN_X + axis] = min_exact(table[r + CCR_AABB_MIN_X + axis], -offset);
             }
         }
     }
@@ -186,11 +239,11 @@ 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[][]}
+ * previous — as `rotation, translation` offsets within a record, flat.
+ * @type {number[]}
  * @private
  */
-const PLANE_POSES = [[CCR_QX, CCR_TX], [CCR_PREV_QX, CCR_PREV_TX]];
+const PLANE_POSES = [CCR_QX, CCR_TX, CCR_PREV_QX, CCR_PREV_TX];
 
 /**
  * @type {Float64Array}
@@ -221,3 +274,10 @@ const PREVIOUS_BOUNDS = new Float64Array(6);
  * @private
  */
 const POSE = new Float64Array(16);
+
+/**
+ * The scale {@link project} composes with: a collider's pose is rigid.
+ * @type {Float64Array}
+ * @private
+ */
+const UNIT_SCALE = new Float64Array([1, 1, 1]);

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

@@ -11,9 +11,10 @@
  * inverts by conjugating its quaternion and subtracting its translation, which
  * costs less than storing an inverse and is exact rather than cached.
  *
- * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions
- * over scalars, so this dispatch and {@link SphereShape3D} and the rest are
- * calling one implementation (§14.1). Before M2 those shapes fell back to
+ * The fields themselves live in `core/geom/3d/shape/sdf/` as free functions,
+ * so this dispatch, through their array forms, and {@link SphereShape3D} and
+ * the rest, through their scalar forms, are calling one implementation
+ * (§14.1). Before M2 those shapes fell back to
  * `compute_signed_distance_gradient_by_sampling` — four field evaluations and a
  * normalise, for shapes whose gradients are two lines of algebra.
  *
@@ -59,6 +60,22 @@ export function cloth_collider_pose_at(table: Float32Array | Float64Array, count
  * @returns {number} the signed distance
  */
 export function cloth_collider_signed_distance(gradient: Float32Array | Float64Array | number[], gradient_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): number;
+/**
+ * {@link cloth_collider_signed_distance} with the point read from an array and the distance written
+ * beside the gradient rather than returned. For the solver's per-particle, per-iteration loops: a
+ * point handed over as three numbers, or a distance handed back as one, is boxed into a heap object
+ * wherever V8 does not inline the call.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record record index, not a slot offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, in the frame `table` is expressed in
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_signed_distance_array(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, point: Float32Array | Float64Array | number[], point_offset: number): void;
 /**
  * Bring a point expressed in a collider's own local frame out into the frame
  * the table is expressed in, using the interpolated pose. This is the inverse
@@ -76,6 +93,19 @@ export function cloth_collider_signed_distance(gradient: Float32Array | Float64A
  * @returns {void}
  */
 export function cloth_collider_from_local(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): void;
+/**
+ * {@link cloth_collider_from_local} with the point read from an array, for the same reason as
+ * {@link cloth_collider_signed_distance_array}. `out` may be `point`.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, local
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_from_local_array(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, point: Float32Array | Float64Array | number[], point_offset: number): void;
 /**
  * Bring a point out of the table's frame into a collider's own local frame,
  * using the interpolated pose. The anchoring half of
@@ -91,4 +121,17 @@ export function cloth_collider_from_local(out: Float32Array | Float64Array | num
  * @returns {void}
  */
 export function cloth_collider_to_local(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, x: number, y: number, z: number): void;
+/**
+ * {@link cloth_collider_to_local} with the point read from an array, for the same reason as
+ * {@link cloth_collider_signed_distance_array}. `out` may be `point`.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array} table
+ * @param {number} record
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`, in the frame `table` is expressed in
+ * @param {number} point_offset
+ * @returns {void}
+ */
+export function cloth_collider_to_local_array(out: Float32Array | Float64Array | number[], out_offset: number, table: Float32Array | Float64Array, record: number, point: Float32Array | Float64Array | number[], point_offset: number): void;
 //# sourceMappingURL=cloth_collider_sdf.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"cloth_collider_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_sdf.js"],"names":[],"mappings":"AAsCA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CALW,YAAY,GAAC,YAAY,SACzB,MAAM,KACN,MAAM,GACJ,IAAI,CAiDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,mBAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CA4DlB;AAED;;;;;;;;;;;;;;;GAeG;AACH,+CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAchB;AAED;;;;;;;;;;;;;GAaG;AACH,6CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAahB"}
+{"version":3,"file":"cloth_collider_sdf.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/cloth/collider/cloth_collider_sdf.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AAEH;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,8CALW,YAAY,GAAC,YAAY,SACzB,MAAM,KACN,MAAM,GACJ,IAAI,CAiDhB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,mBAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAclB;AAED;;;;;;;;;;;;;;GAcG;AACH,0DATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAElC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAgChB;AAED;;;;;;;;;;;;;;;GAeG;AACH,+CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;;;;GAWG;AACH,qDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAUhB;AAED;;;;;;;;;;;;;GAaG;AACH,6CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,IAAI,CAQhB;AAED;;;;;;;;;;;GAWG;AACH,mDARW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,SACN,YAAY,GAAC,YAAY,UACzB,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,GACJ,IAAI,CAUhB"}