@woosh/meep-engine 3.40.0 → 3.42.0

package/src/engine/physics/fluid/solver/v3_grid_advect_maccormack_velocity.js

@@ -1,7 +1,7 @@
 import { v3_grid_limit8_at_indices } from "./v3_grid_limit8_at_indices.js";
 import { assert } from "../../../../core/assert.js";
 import { clamp } from "../../../../core/math/clamp.js";
-import { scs3d_sample_linear3 } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
+import { scs3d_sample_linear3_array } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
 
 /*
  * COLLOCATED VARIANT. FluidSimulator transports through the MAC (staggered-grid) kernels in the sibling
@@ -76,6 +76,7 @@ export function v3_grid_advect_maccormack_velocity(outputs, sources, carrier_x,
     const last_y = res_y - 1;
     const last_z = res_z - 1;
     const sample = scratch_sample;
+    const position = scratch_position;
 
     // ─── pass 1: forward SL step into the scratch trio ──────────────────────
     for (let z = 0; z < res_z; z++) {
@@ -93,7 +94,10 @@ export function v3_grid_advect_maccormack_velocity(outputs, sources, carrier_x,
                 const s_x = x - carrier_x[c] * time_delta;
                 const s_y = y - carrier_y[c] * time_delta;
                 const s_z = z - carrier_z[c] * time_delta;
-                scs3d_sample_linear3(sample, src_x, src_y, src_z, res_x, res_y, res_z, s_x, s_y, s_z);
+                position[0] = s_x;
+                position[1] = s_y;
+                position[2] = s_z;
+                scs3d_sample_linear3_array(sample, src_x, src_y, src_z, res_x, res_y, res_z, position, 0);
                 fwd_x[c] = sample[0];
                 fwd_y[c] = sample[1];
                 fwd_z[c] = sample[2];
@@ -119,7 +123,10 @@ export function v3_grid_advect_maccormack_velocity(outputs, sources, carrier_x,
                 const vy = carrier_y[c] * time_delta;
                 const vz = carrier_z[c] * time_delta;
 
-                scs3d_sample_linear3(sample, fwd_x, fwd_y, fwd_z, res_x, res_y, res_z, x + vx, y + vy, z + vz);
+                position[0] = x + vx;
+                position[1] = y + vy;
+                position[2] = z + vz;
+                scs3d_sample_linear3_array(sample, fwd_x, fwd_y, fwd_z, res_x, res_y, res_z, position, 0);
                 const corr_x = fwd_x[c] + 0.5 * (src_x[c] - sample[0]);
                 const corr_y = fwd_y[c] + 0.5 * (src_y[c] - sample[1]);
                 const corr_z = fwd_z[c] + 0.5 * (src_z[c] - sample[2]);
@@ -160,3 +167,5 @@ export function v3_grid_advect_maccormack_velocity(outputs, sources, carrier_x,
 
 /** Module-static sample destination — avoids per-cell allocation. */
 const scratch_sample = new Float32Array(3);
+/** Continuous coordinates passed to the sampler during this synchronous typed-array sweep. */
+const scratch_position = new Float64Array(3);

package/src/engine/physics/fluid/solver/v3_grid_advect_sl_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_grid_advect_sl_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_advect_sl_velocity.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oDAdW,YAAY,EAAE,WACd,YAAY,EAAE,aAEd,YAAY,aACZ,YAAY,aACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QA+DpB"}
+{"version":3,"file":"v3_grid_advect_sl_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_advect_sl_velocity.js"],"names":[],"mappings":"AAUA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,oDAdW,YAAY,EAAE,WACd,YAAY,EAAE,aAEd,YAAY,aACZ,YAAY,aACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QAmEpB"}

package/src/engine/physics/fluid/solver/v3_grid_advect_sl_velocity.js

@@ -1,5 +1,5 @@
 import { assert } from "../../../../core/assert.js";
-import { scs3d_sample_linear3 } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
+import { scs3d_sample_linear3_array } from "../../../graphics/texture/3d/scs3d_sample_linear3.js";
 
 /*
  * COLLOCATED VARIANT. FluidSimulator transports through the MAC (staggered-grid) kernels in the sibling
@@ -72,6 +72,7 @@ export function v3_grid_advect_sl_velocity(outputs, sources, carrier_x, carrier_
 
     const slice_size = res_x * res_y;
     const sample = scratch_sample;
+    const position = scratch_position;
 
     for (let z = 0; z < res_z; z++) {
         const z_off = z * slice_size;
@@ -94,7 +95,10 @@ export function v3_grid_advect_sl_velocity(outputs, sources, carrier_x, carrier_
                 const s_y = y - carrier_y[c] * time_delta;
                 const s_z = z - carrier_z[c] * time_delta;
 
-                scs3d_sample_linear3(sample, src_x, src_y, src_z, res_x, res_y, res_z, s_x, s_y, s_z);
+                position[0] = s_x;
+                position[1] = s_y;
+                position[2] = s_z;
+                scs3d_sample_linear3_array(sample, src_x, src_y, src_z, res_x, res_y, res_z, position, 0);
                 out_x[c] = sample[0];
                 out_y[c] = sample[1];
                 out_z[c] = sample[2];
@@ -105,3 +109,5 @@ export function v3_grid_advect_sl_velocity(outputs, sources, carrier_x, carrier_
 
 /** Module-static sample destination — avoids per-cell allocation. */
 const scratch_sample = new Float32Array(3);
+/** Continuous coordinates passed to the sampler during this synchronous typed-array sweep. */
+const scratch_position = new Float64Array(3);

package/src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.d.ts

@@ -27,4 +27,23 @@
  * @return {number}
  */
 export function v3_grid_sample_scalar_masked(data: Float32Array, solid: Uint8Array, res_x: number, res_y: number, res_z: number, x: number, y: number, z: number, fallback: number): number;
+/**
+ * {@link v3_grid_sample_scalar_masked} with `[x, y, z, fallback]` read from a reusable operand record
+ * and the sample written into `out`. No continuous number crosses the call boundary, including the
+ * result, so a per-cell caller does not need this sampler to be inlined to avoid numeric boxes.
+ *
+ * The operands are read before any output write; `out` may overlap `operands` or `data`. Float64
+ * operands preserve the scalar form's coordinate and fallback precision.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array} data
+ * @param {Uint8Array} solid
+ * @param {number} res_x
+ * @param {number} res_y
+ * @param {number} res_z
+ * @param {Float64Array} operands `[x, y, z, fallback]`
+ * @param {number} operands_offset
+ */
+export function v3_grid_sample_scalar_masked_array(out: Float32Array | Float64Array | number[], out_offset: number, data: Float32Array, solid: Uint8Array, res_x: number, res_y: number, res_z: number, operands: Float64Array, operands_offset: number): void;
 //# sourceMappingURL=v3_grid_sample_scalar_masked.d.ts.map

package/src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_grid_sample_scalar_masked.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mDAXW,YAAY,SACZ,UAAU,SACV,MAAM,SACN,MAAM,SACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,GACL,MAAM,CA+DjB"}
+{"version":3,"file":"v3_grid_sample_scalar_masked.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,mDAXW,YAAY,SACZ,UAAU,SACV,MAAM,SACN,MAAM,SACN,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,GACL,MAAM,CAYjB;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wDAVW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,QACN,YAAY,SACZ,UAAU,SACV,MAAM,SACN,MAAM,SACN,MAAM,YACN,YAAY,mBACZ,MAAM,QAqEhB"}

package/src/engine/physics/fluid/solver/v3_grid_sample_scalar_masked.js

@@ -1,5 +1,8 @@
 import { clamp } from "../../../../core/math/clamp.js";
 
+const scratch_operands = new Float64Array(4);
+const scratch_sample = new Float64Array(1);
+
 /**
  * Trilinearly sample a cell-centered scalar at a fractional position,
  * EXCLUDING solid cells from the interpolation: solid taps contribute zero
@@ -29,6 +32,41 @@ import { clamp } from "../../../../core/math/clamp.js";
  * @return {number}
  */
 export function v3_grid_sample_scalar_masked(data, solid, res_x, res_y, res_z, x, y, z, fallback) {
+    const operands = scratch_operands;
+    operands[0] = x;
+    operands[1] = y;
+    operands[2] = z;
+    operands[3] = fallback;
+
+    v3_grid_sample_scalar_masked_array(scratch_sample, 0, data, solid, res_x, res_y, res_z, operands, 0);
+
+    return scratch_sample[0];
+}
+
+/**
+ * {@link v3_grid_sample_scalar_masked} with `[x, y, z, fallback]` read from a reusable operand record
+ * and the sample written into `out`. No continuous number crosses the call boundary, including the
+ * result, so a per-cell caller does not need this sampler to be inlined to avoid numeric boxes.
+ *
+ * The operands are read before any output write; `out` may overlap `operands` or `data`. Float64
+ * operands preserve the scalar form's coordinate and fallback precision.
+ *
+ * @param {Float32Array|Float64Array|number[]} out
+ * @param {number} out_offset
+ * @param {Float32Array} data
+ * @param {Uint8Array} solid
+ * @param {number} res_x
+ * @param {number} res_y
+ * @param {number} res_z
+ * @param {Float64Array} operands `[x, y, z, fallback]`
+ * @param {number} operands_offset
+ */
+export function v3_grid_sample_scalar_masked_array(out, out_offset, data, solid, res_x, res_y, res_z, operands, operands_offset) {
+    const x = operands[operands_offset];
+    const y = operands[operands_offset + 1];
+    const z = operands[operands_offset + 2];
+    const fallback = operands[operands_offset + 3];
+
     const x_max = res_x - 1;
     const y_max = res_y - 1;
     const z_max = res_z - 1;
@@ -80,7 +118,8 @@ export function v3_grid_sample_scalar_masked(data, solid, res_x, res_y, res_z, x
 
     const total = w000 + w100 + w010 + w110 + w001 + w101 + w011 + w111;
     if (total <= 0) {
-        return fallback;
+        out[out_offset] = fallback;
+        return;
     }
 
     const sum = w000 * data[c000] + w100 * data[c100]
@@ -88,5 +127,5 @@ export function v3_grid_sample_scalar_masked(data, solid, res_x, res_y, res_z, x
         + w001 * data[c001] + w101 * data[c101]
         + w011 * data[c011] + w111 * data[c111];
 
-    return sum / total;
+    out[out_offset] = sum / total;
 }

package/src/engine/physics/fluid/solver/v3_mac_advect_scalar.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_mac_advect_scalar.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_scalar.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QA4CpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wDAZW,YAAY,SACZ,YAAY,mBACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QA8GpB"}
+{"version":3,"file":"v3_mac_advect_scalar.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_scalar.js"],"names":[],"mappings":"AAmCA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,gDAXW,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QAgDpB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,wDAZW,YAAY,SACZ,YAAY,mBACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,YAAY,SACZ,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,SACN,UAAU,QA8GpB"}

package/src/engine/physics/fluid/solver/v3_mac_advect_scalar.js

@@ -1,9 +1,11 @@
 import { assert } from "../../../../core/assert.js";
 import { clamp } from "../../../../core/math/clamp.js";
-import { v3_grid_sample_scalar_masked } from "./v3_grid_sample_scalar_masked.js";
+import { v3_grid_sample_scalar_masked, v3_grid_sample_scalar_masked_array } from "./v3_grid_sample_scalar_masked.js";
 import { v3_mac_clip_trace } from "./v3_mac_clip_trace.js";
 
 const scratch_clip = new Float32Array(3);
+// This synchronous typed-array kernel has no callbacks while a sample is in progress.
+const scratch_sample_operands = new Float64Array(4);
 
 /**
  * Straight-line (loop-free, inlinable) test: is the cell containing the
@@ -66,6 +68,7 @@ export function v3_mac_advect_sl_scalar(output, input, vel_u, vel_v, vel_w, res_
     assert.greaterThanOrEqual(input.length, cell_count, "input covers grid");
 
     const cell_slice = res_x * res_y;
+    const operands = scratch_sample_operands;
     const sx = res_x + 1;
     const v_slice = res_x * (res_y + 1);
 
@@ -96,8 +99,11 @@ export function v3_mac_advect_sl_scalar(output, input, vel_u, vel_v, vel_w, res_
                     bx = scratch_clip[0]; by = scratch_clip[1]; bz = scratch_clip[2];
                 }
 
-                output[c] = v3_grid_sample_scalar_masked(input, solid, res_x, res_y, res_z,
-                    bx, by, bz, input[c]);
+                operands[0] = bx;
+                operands[1] = by;
+                operands[2] = bz;
+                operands[3] = input[c];
+                v3_grid_sample_scalar_masked_array(output, c, input, solid, res_x, res_y, res_z, operands, 0);
             }
         }
     }

package/src/engine/physics/fluid/solver/v3_mac_advect_sl_velocity.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"v3_mac_advect_sl_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_sl_velocity.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,mDAZW,YAAY,EAAE,WACd,YAAY,EAAE,WACd,YAAY,EAAE,SACd,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,gBACN,UAAU,gBACV,UAAU,gBACV,UAAU,SACV,UAAU,QAwKpB"}
+{"version":3,"file":"v3_mac_advect_sl_velocity.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/fluid/solver/v3_mac_advect_sl_velocity.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2CG;AACH,mDAZW,YAAY,EAAE,WACd,YAAY,EAAE,WACd,YAAY,EAAE,SACd,MAAM,SACN,MAAM,SACN,MAAM,cACN,MAAM,gBACN,UAAU,gBACV,UAAU,gBACV,UAAU,SACV,UAAU,QAuLpB"}

package/src/engine/physics/fluid/solver/v3_mac_advect_sl_velocity.js

@@ -1,8 +1,9 @@
 import { assert } from "../../../../core/assert.js";
-import { scs3d_sample_linear } from "../../../graphics/texture/3d/scs3d_sample_linear.js";
+import { scs3d_sample_linear_array } from "../../../graphics/texture/3d/scs3d_sample_linear.js";
 import { v3_mac_clip_trace } from "./v3_mac_clip_trace.js";
 
 const scratch_clip = new Float32Array(3);
+const scratch_position = new Float64Array(3);
 
 /**
  * Semi-Lagrangian advection of a MAC (face-centered) velocity field along a
@@ -116,12 +117,17 @@ export function v3_mac_advect_sl_velocity(outputs, sources, carrier, res_x, res_
                 if (ecy < 0) ecy = 0; else if (ecy >= res_y) ecy = last_cy;
                 if (ecz < 0) ecz = 0; else if (ecz >= res_z) ecz = last_cz;
                 if (solid[ecz * cell_slice + ecy * res_x + ecx] === 0) {
-                    out_u[f] = scs3d_sample_linear(src_u, sx, res_y, res_z, ex + 0.5, ey, ez);
+                    scratch_position[0] = ex + 0.5;
+                    scratch_position[1] = ey;
+                    scratch_position[2] = ez;
+                    scs3d_sample_linear_array(out_u, f, src_u, sx, res_y, res_z, scratch_position, 0);
                 } else {
                     v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z,
                         x - 0.5, y, z, ex, ey, ez);
-                    out_u[f] = scs3d_sample_linear(src_u, sx, res_y, res_z,
-                        scratch_clip[0] + 0.5, scratch_clip[1], scratch_clip[2]);
+                    scratch_position[0] = scratch_clip[0] + 0.5;
+                    scratch_position[1] = scratch_clip[1];
+                    scratch_position[2] = scratch_clip[2];
+                    scs3d_sample_linear_array(out_u, f, src_u, sx, res_y, res_z, scratch_position, 0);
                 }
             }
         }
@@ -159,12 +165,17 @@ export function v3_mac_advect_sl_velocity(outputs, sources, carrier, res_x, res_
                 if (ecy < 0) ecy = 0; else if (ecy >= res_y) ecy = last_cy;
                 if (ecz < 0) ecz = 0; else if (ecz >= res_z) ecz = last_cz;
                 if (solid[ecz * cell_slice + ecy * res_x + ecx] === 0) {
-                    out_v[f] = scs3d_sample_linear(src_v, res_x, sy, res_z, ex, ey + 0.5, ez);
+                    scratch_position[0] = ex;
+                    scratch_position[1] = ey + 0.5;
+                    scratch_position[2] = ez;
+                    scs3d_sample_linear_array(out_v, f, src_v, res_x, sy, res_z, scratch_position, 0);
                 } else {
                     v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z,
                         x, y - 0.5, z, ex, ey, ez);
-                    out_v[f] = scs3d_sample_linear(src_v, res_x, sy, res_z,
-                        scratch_clip[0], scratch_clip[1] + 0.5, scratch_clip[2]);
+                    scratch_position[0] = scratch_clip[0];
+                    scratch_position[1] = scratch_clip[1] + 0.5;
+                    scratch_position[2] = scratch_clip[2];
+                    scs3d_sample_linear_array(out_v, f, src_v, res_x, sy, res_z, scratch_position, 0);
                 }
             }
         }
@@ -204,12 +215,17 @@ export function v3_mac_advect_sl_velocity(outputs, sources, carrier, res_x, res_
                 if (ecy < 0) ecy = 0; else if (ecy >= res_y) ecy = last_cy;
                 if (ecz < 0) ecz = 0; else if (ecz >= res_z) ecz = last_cz;
                 if (solid[ecz * cell_slice + ecy * res_x + ecx] === 0) {
-                    out_w[f] = scs3d_sample_linear(src_w, res_x, res_y, sz, ex, ey, ez + 0.5);
+                    scratch_position[0] = ex;
+                    scratch_position[1] = ey;
+                    scratch_position[2] = ez + 0.5;
+                    scs3d_sample_linear_array(out_w, f, src_w, res_x, res_y, sz, scratch_position, 0);
                 } else {
                     v3_mac_clip_trace(scratch_clip, solid, res_x, res_y, res_z,
                         x, y, z - 0.5, ex, ey, ez);
-                    out_w[f] = scs3d_sample_linear(src_w, res_x, res_y, sz,
-                        scratch_clip[0], scratch_clip[1], scratch_clip[2] + 0.5);
+                    scratch_position[0] = scratch_clip[0];
+                    scratch_position[1] = scratch_clip[1];
+                    scratch_position[2] = scratch_clip[2] + 0.5;
+                    scs3d_sample_linear_array(out_w, f, src_w, res_x, res_y, sz, scratch_position, 0);
                 }
             }
         }

package/src/engine/physics/inverse_kinematics/frame_fabrik/FrameFabrikProblem.d.ts

@@ -0,0 +1,205 @@
+/**
+ * One tree for {@link frame_fabrik_solve} to pose: its joints, as the animation left them, the goals
+ * pulling on them, and, once solved, where they went.
+ *
+ * Every array is sized once, at construction, for the most joints and goals the problem will ever
+ * hold; a solve allocates nothing. Joints are indices into the problem, not entities: the problem
+ * knows nothing about where its tree came from.
+ *
+ * The caller fills the inputs and {@link joint_count} / {@link goal_count}; the fields under "solver
+ * state" belong to the solver, which overwrites them on every solve.
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export class FrameFabrikProblem {
+    /**
+     * @param {number} joint_capacity the most joints a solve will be given
+     * @param {number} goal_capacity the most goals a solve will be given
+     */
+    constructor(joint_capacity: number, goal_capacity: number);
+    /**
+     * @readonly
+     * @type {number}
+     */
+    readonly joint_capacity: number;
+    /**
+     * @readonly
+     * @type {number}
+     */
+    readonly goal_capacity: number;
+    /**
+     * How many joints this solve poses.
+     * @type {number}
+     */
+    joint_count: number;
+    /**
+     * How many goals pull on them.
+     * @type {number}
+     */
+    goal_count: number;
+    /**
+     * Each joint's parent, as an index into this problem, or -1 for a joint whose parent the solve
+     * does not pose: its parent's frame is fixed, as animated. Every parent comes before its
+     * children, `joint_parent[i] < i`.
+     * @type {Int32Array}
+     */
+    joint_parent: Int32Array;
+    /**
+     * Where each joint is as animated, in world. Packed `[x, y, z]` per joint.
+     * @type {Float64Array}
+     */
+    base_position: Float64Array;
+    /**
+     * How each joint is turned as animated, in world, a unit quaternion. Packed `[x, y, z, w]` per
+     * joint.
+     * @type {Float64Array}
+     */
+    base_rotation: Float64Array;
+    /**
+     * How each joint is turned relative to its parent as animated, a unit quaternion: the parent's
+     * {@link base_rotation} composed with it is the joint's. For a joint whose parent is not posed,
+     * relative to that parent, whose frame it gives the solve. Packed `[x, y, z, w]` per joint.
+     * @type {Float64Array}
+     */
+    base_local_rotation: Float64Array;
+    /**
+     * 1 for a joint whose turn relative to its parent is limited, by {@link limit_basis_a},
+     * {@link limit_basis_b}, {@link limit_lower} and {@link limit_upper}; 0 for one that turns
+     * freely.
+     * @type {Uint8Array}
+     */
+    joint_limited: Uint8Array;
+    /**
+     * The limit's frame in the parent's, a unit quaternion: a physics `Joint`'s `localBasisA`.
+     * Packed `[x, y, z, w]` per joint.
+     * @type {Float64Array}
+     */
+    limit_basis_a: Float64Array;
+    /**
+     * The limit's frame in the joint's own, a unit quaternion: a physics `Joint`'s `localBasisB`.
+     * Packed `[x, y, z, w]` per joint.
+     * @type {Float64Array}
+     */
+    limit_basis_b: Float64Array;
+    /**
+     * Lower bounds of the turn of frame B relative to frame A, as `swing_twist_error_array`
+     * measures it: `[twist about X, swing Y, swing Z]` per joint, radians. `-Infinity` for an
+     * axis that turns freely, 0 for a locked one.
+     * @type {Float64Array}
+     */
+    limit_lower: Float64Array;
+    /**
+     * Upper bounds, as {@link limit_lower}.
+     * @type {Float64Array}
+     */
+    limit_upper: Float64Array;
+    /**
+     * The joint each goal pulls on.
+     * @type {Int32Array}
+     */
+    goal_effector: Int32Array;
+    /**
+     * The highest joint each goal turns: its effector or an ancestor of it. The goal's path runs
+     * from the effector up to here. This joint turns and never moves.
+     * @type {Int32Array}
+     */
+    goal_root: Int32Array;
+    /**
+     * How hard each goal pulls, 0..1. 0 gives the pose the solve gives without the goal, and the
+     * pose is continuous in it.
+     * @type {Float64Array}
+     */
+    goal_weight: Float64Array;
+    /**
+     * The joint each goal's target hangs below, or -1 for a target the solve does not move. A
+     * target hanging below a joint is carried by that joint's frame as the solve turns it, read
+     * afresh on every iteration.
+     * @type {Int32Array}
+     */
+    goal_target_joint: Int32Array;
+    /**
+     * Where each goal wants its effector, in world, as animated: the frame of
+     * {@link goal_target_joint} carries it from there. Packed `[x, y, z]` per goal.
+     * @type {Float64Array}
+     */
+    goal_target: Float64Array;
+    /**
+     * The solved pose: where each joint went, in world. Packed `[x, y, z]` per joint.
+     * @type {Float64Array}
+     */
+    solved_position: Float64Array;
+    /**
+     * The solved pose: how each joint is turned, in world. Packed `[x, y, z, w]` per joint.
+     * @type {Float64Array}
+     */
+    solved_rotation: Float64Array;
+    /**
+     * Each joint's place in its parent's frame, as animated: the rigid offset the solve keeps.
+     * @type {Float64Array}
+     */
+    _offset: Float64Array;
+    /**
+     * The weight of the link from each joint's parent to it: the heaviest goal whose path holds
+     * both ends. 0 for a link no path holds.
+     * @type {Float64Array}
+     */
+    _link_weight: Float64Array;
+    /**
+     * Children of joint `i` are `_child[_child_start[i] .. _child_start[i + 1]]`.
+     * @type {Int32Array}
+     */
+    _child_start: Int32Array;
+    /**
+     * @type {Int32Array}
+     */
+    _child: Int32Array;
+    /**
+     * How many goals of non-zero weight have the joint on their path.
+     * @type {Int32Array}
+     */
+    _path_count: Int32Array;
+    /**
+     * 1 for a joint some goal's path holds below that goal's root.
+     * @type {Uint8Array}
+     */
+    _interior: Uint8Array;
+    /**
+     * 1 for a joint that turns and never moves: a goal's root no path holds below its own root.
+     * @type {Uint8Array}
+     */
+    _root_only: Uint8Array;
+    /**
+     * The goal whose effector the joint is, or -1.
+     * @type {Int32Array}
+     */
+    _effector_goal: Int32Array;
+    /**
+     * The joint whose frame carries each goal's effector when the goal does not pull: the deepest
+     * joint of its path another goal's path holds too, else its root's parent (-1 when that is
+     * not posed).
+     * @type {Int32Array}
+     */
+    _goal_anchor: Int32Array;
+    /**
+     * The effector in its anchor's frame, as animated. Packed `[x, y, z]` per goal.
+     * @type {Float64Array}
+     */
+    _goal_anchor_offset: Float64Array;
+    /**
+     * Each target in its target joint's frame, as animated. Packed `[x, y, z]` per goal.
+     * @type {Float64Array}
+     */
+    _goal_target_local: Float64Array;
+    /**
+     * This iteration's target for each effector. Packed `[x, y, z]` per goal.
+     * @type {Float64Array}
+     */
+    _target: Float64Array;
+    /**
+     * Where each joint was before this iteration, to measure how far the iteration moved it.
+     * @type {Float64Array}
+     */
+    _previous: Float64Array;
+}
+//# sourceMappingURL=FrameFabrikProblem.d.ts.map

package/src/engine/physics/inverse_kinematics/frame_fabrik/FrameFabrikProblem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FrameFabrikProblem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/physics/inverse_kinematics/frame_fabrik/FrameFabrikProblem.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;GAaG;AACH;IAEI;;;OAGG;IACH,4BAHW,MAAM,iBACN,MAAM,EA+NhB;IAzNG;;;OAGG;IACH,yBAFU,MAAM,CAEoB;IAEpC;;;OAGG;IACH,wBAFU,MAAM,CAEkB;IAElC;;;OAGG;IACH,aAFU,MAAM,CAEI;IAEpB;;;OAGG;IACH,YAFU,MAAM,CAEG;IAEnB;;;;;OAKG;IACH,cAFU,UAAU,CAE8B;IAElD;;;OAGG;IACH,eAFU,YAAY,CAEmC;IAEzD;;;;OAIG;IACH,eAFU,YAAY,CAEmC;IAEzD;;;;;OAKG;IACH,qBAFU,YAAY,CAEyC;IAE/D;;;;;OAKG;IACH,eAFU,UAAU,CAE+B;IAEnD;;;;OAIG;IACH,eAFU,YAAY,CAEmC;IAEzD;;;;OAIG;IACH,eAFU,YAAY,CAEmC;IAEzD;;;;;OAKG;IACH,aAFU,YAAY,CAEiC;IAEvD;;;OAGG;IACH,aAFU,YAAY,CAEiC;IAEvD;;;OAGG;IACH,eAFU,UAAU,CAE8B;IAElD;;;;OAIG;IACH,WAFU,UAAU,CAE0B;IAE9C;;;;OAIG;IACH,aAFU,YAAY,CAE4B;IAElD;;;;;OAKG;IACH,mBAFU,UAAU,CAEkC;IAEtD;;;;OAIG;IACH,aAFU,YAAY,CAEgC;IAEtD;;;OAGG;IACH,iBAFU,YAAY,CAEqC;IAE3D;;;OAGG;IACH,iBAFU,YAAY,CAEqC;IAI3D;;;OAGG;IACH,SAFU,YAAY,CAE6B;IAEnD;;;;OAIG;IACH,cAFU,YAAY,CAE8B;IAEpD;;;OAGG;IACH,cAFU,UAAU,CAEkC;IAEtD;;OAEG;IACH,QAFU,UAAU,CAEwB;IAE5C;;;OAGG;IACH,aAFU,UAAU,CAE6B;IAEjD;;;OAGG;IACH,WAFU,UAAU,CAE2B;IAE/C;;;OAGG;IACH,YAFU,UAAU,CAE4B;IAEhD;;;OAGG;IACH,gBAFU,UAAU,CAEgC;IAEpD;;;;;OAKG;IACH,cAFU,UAAU,CAE6B;IAEjD;;;OAGG;IACH,qBAFU,YAAY,CAEwC;IAE9D;;;OAGG;IACH,oBAFU,YAAY,CAEuC;IAE7D;;;OAGG;IACH,SAFU,YAAY,CAE4B;IAElD;;;OAGG;IACH,WAFU,YAAY,CAE+B;CAE5D"}