@woosh/meep-engine 2.139.0 → 2.140.0

package/src/core/geom/vec3/v3_quat3_apply.d.ts

@@ -0,0 +1,29 @@
+/**
+ * Rotate a 3-D vector by a unit quaternion: `result = q · v · q*`.
+ *
+ * The closed-form expansion below is the standard "two Hamilton
+ * products with a pure-quaternion v" derivation. We compute the
+ * intermediate `t = q · v` (treating v as a quaternion with `w = 0`),
+ * then `result = t · q*` (where `q* = (-qx, -qy, -qz, qw)`). Inline
+ * the sign of the conjugate so the final multiplies avoid temporary
+ * negations.
+ *
+ * Sign convention: `(qx, qy, qz, qw)` — `w` last, matching the
+ * project's existing {@link Quaternion} class and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * Companion to {@link v3_quat3_apply_inverse} (rotates by the
+ * conjugate, i.e. inverse rotation).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} qx unit quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw unit quaternion w (last)
+ */
+export function v3_quat3_apply(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+//# sourceMappingURL=v3_quat3_apply.d.ts.map

package/src/core/geom/vec3/v3_quat3_apply.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_quat3_apply.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quat3_apply.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,oCAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAahB"}

package/src/core/geom/vec3/v3_quat3_apply.js

@@ -0,0 +1,39 @@
+/**
+ * Rotate a 3-D vector by a unit quaternion: `result = q · v · q*`.
+ *
+ * The closed-form expansion below is the standard "two Hamilton
+ * products with a pure-quaternion v" derivation. We compute the
+ * intermediate `t = q · v` (treating v as a quaternion with `w = 0`),
+ * then `result = t · q*` (where `q* = (-qx, -qy, -qz, qw)`). Inline
+ * the sign of the conjugate so the final multiplies avoid temporary
+ * negations.
+ *
+ * Sign convention: `(qx, qy, qz, qw)` — `w` last, matching the
+ * project's existing {@link Quaternion} class and the rest of the
+ * `core/geom/3d/quaternion/` family.
+ *
+ * Companion to {@link v3_quat3_apply_inverse} (rotates by the
+ * conjugate, i.e. inverse rotation).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} qx unit quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw unit quaternion w (last)
+ */
+export function v3_quat3_apply(out, out_offset, vx, vy, vz, qx, qy, qz, qw) {
+    // t = q · v   (Hamilton product, v as pure quaternion w=0)
+    const tx =  qw * vx + qy * vz - qz * vy;
+    const ty =  qw * vy + qz * vx - qx * vz;
+    const tz =  qw * vz + qx * vy - qy * vx;
+    const tw = -qx * vx - qy * vy - qz * vz;
+
+    // result = t · q*   (q* = -qx, -qy, -qz, qw)
+    out[out_offset]     = tx * qw - tw * qx - ty * qz + tz * qy;
+    out[out_offset + 1] = ty * qw - tw * qy - tz * qx + tx * qz;
+    out[out_offset + 2] = tz * qw - tw * qz - tx * qy + ty * qx;
+}

package/src/core/geom/vec3/v3_quat3_apply_inverse.d.ts

@@ -0,0 +1,30 @@
+/**
+ * Inverse-rotate a 3-D vector by a unit quaternion: `result = q* · v · q`,
+ * where `q* = (-qx, -qy, -qz, qw)` is the conjugate.
+ *
+ * Geometrically: if {@link v3_quat3_apply} rotates a body-local vector
+ * into world space (`v_world = q · v_local · q*`), this is the inverse —
+ * it takes a world-space vector and writes it in body-local coordinates.
+ * For unit quaternions the conjugate IS the inverse, so the two
+ * functions are exact inverses of each other.
+ *
+ * Implementation: the conjugate's `xyz` are negated relative to `q`.
+ * Expanding `c · v · c*` with `(cx, cy, cz, cw) = (-qx, -qy, -qz, qw)`
+ * and simplifying produces the closed form below — different sign
+ * pattern than {@link v3_quat3_apply}, NOT just a call with negated
+ * components (the optimisation matters for hot-path callers such as
+ * `PosedShape.support` and the per-triangle concave dispatch in
+ * `narrowphase_step`).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} qx unit quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw unit quaternion w (last)
+ */
+export function v3_quat3_apply_inverse(out: number[] | Float32Array | Float64Array, out_offset: number, vx: number, vy: number, vz: number, qx: number, qy: number, qz: number, qw: number): void;
+//# sourceMappingURL=v3_quat3_apply_inverse.d.ts.map

package/src/core/geom/vec3/v3_quat3_apply_inverse.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_quat3_apply_inverse.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_quat3_apply_inverse.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,4CAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAchB"}

package/src/core/geom/vec3/v3_quat3_apply_inverse.js

@@ -0,0 +1,41 @@
+/**
+ * Inverse-rotate a 3-D vector by a unit quaternion: `result = q* · v · q`,
+ * where `q* = (-qx, -qy, -qz, qw)` is the conjugate.
+ *
+ * Geometrically: if {@link v3_quat3_apply} rotates a body-local vector
+ * into world space (`v_world = q · v_local · q*`), this is the inverse —
+ * it takes a world-space vector and writes it in body-local coordinates.
+ * For unit quaternions the conjugate IS the inverse, so the two
+ * functions are exact inverses of each other.
+ *
+ * Implementation: the conjugate's `xyz` are negated relative to `q`.
+ * Expanding `c · v · c*` with `(cx, cy, cz, cw) = (-qx, -qy, -qz, qw)`
+ * and simplifying produces the closed form below — different sign
+ * pattern than {@link v3_quat3_apply}, NOT just a call with negated
+ * components (the optimisation matters for hot-path callers such as
+ * `PosedShape.support` and the per-triangle concave dispatch in
+ * `narrowphase_step`).
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset offset into `out`; receives 3 floats
+ * @param {number} vx
+ * @param {number} vy
+ * @param {number} vz
+ * @param {number} qx unit quaternion x
+ * @param {number} qy
+ * @param {number} qz
+ * @param {number} qw unit quaternion w (last)
+ */
+export function v3_quat3_apply_inverse(out, out_offset, vx, vy, vz, qx, qy, qz, qw) {
+    // t = q* · v   (conjugate · v, v as pure quaternion w=0)
+    // Conjugate xyz negated; expanded:
+    const tx = qw * vx - qy * vz + qz * vy;
+    const ty = qw * vy - qz * vx + qx * vz;
+    const tz = qw * vz - qx * vy + qy * vx;
+    const tw = qx * vx + qy * vy + qz * vz; // note: +, conjugate-w stays qw
+
+    // result = t · q   (q is the conjugate-of-conjugate)
+    out[out_offset]     = tx * qw + tw * qx + ty * qz - tz * qy;
+    out[out_offset + 1] = ty * qw + tw * qy + tz * qx - tx * qz;
+    out[out_offset + 2] = tz * qw + tw * qz + tx * qy - ty * qx;
+}

package/src/core/geom/vec3/v3_triple_cross_product.d.ts

@@ -0,0 +1,32 @@
+/**
+ * Compute the triple cross product `(a × b) × a` in 3D.
+ *
+ * Identity used in GJK and related Voronoi-region searches: given an
+ * edge `a` from a simplex and the vector `b` from one endpoint toward
+ * the origin (or any other "where do we want to go" reference), the
+ * triple cross gives a direction PERPENDICULAR to `a` that lies in
+ * the plane of `(a, b)` and points toward `b`. This is the right
+ * search direction to extend the simplex away from the edge toward
+ * the origin without re-entering territory already covered.
+ *
+ * Sign convention: `result = (a × b) × a` (not `a × (b × a)` — the
+ * triple cross product is not associative).
+ *
+ * The function is allocation-free: `result` is a caller-provided
+ * typed array (or array-like) that receives the three components
+ * starting at `result_offset`. `a` and `b` are passed as raw scalar
+ * components, matching the convention of {@link v3_compute_triangle_normal}
+ * and the rest of the scalar-input vec3 helpers.
+ *
+ * @param {number[]|Float32Array|Float64Array} result destination
+ * @param {number} result_offset offset into `result` where the
+ *   three output components are written
+ * @param {number} ax first input vector x
+ * @param {number} ay first input vector y
+ * @param {number} az first input vector z
+ * @param {number} bx second input vector x
+ * @param {number} by second input vector y
+ * @param {number} bz second input vector z
+ */
+export function v3_triple_cross_product(result: number[] | Float32Array | Float64Array, result_offset: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number): void;
+//# sourceMappingURL=v3_triple_cross_product.d.ts.map

package/src/core/geom/vec3/v3_triple_cross_product.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"v3_triple_cross_product.d.ts","sourceRoot":"","sources":["../../../../../src/core/geom/vec3/v3_triple_cross_product.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH,gDAVW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,iBAClC,MAAM,MAEN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAgBhB"}

package/src/core/geom/vec3/v3_triple_cross_product.js

@@ -0,0 +1,45 @@
+/**
+ * Compute the triple cross product `(a × b) × a` in 3D.
+ *
+ * Identity used in GJK and related Voronoi-region searches: given an
+ * edge `a` from a simplex and the vector `b` from one endpoint toward
+ * the origin (or any other "where do we want to go" reference), the
+ * triple cross gives a direction PERPENDICULAR to `a` that lies in
+ * the plane of `(a, b)` and points toward `b`. This is the right
+ * search direction to extend the simplex away from the edge toward
+ * the origin without re-entering territory already covered.
+ *
+ * Sign convention: `result = (a × b) × a` (not `a × (b × a)` — the
+ * triple cross product is not associative).
+ *
+ * The function is allocation-free: `result` is a caller-provided
+ * typed array (or array-like) that receives the three components
+ * starting at `result_offset`. `a` and `b` are passed as raw scalar
+ * components, matching the convention of {@link v3_compute_triangle_normal}
+ * and the rest of the scalar-input vec3 helpers.
+ *
+ * @param {number[]|Float32Array|Float64Array} result destination
+ * @param {number} result_offset offset into `result` where the
+ *   three output components are written
+ * @param {number} ax first input vector x
+ * @param {number} ay first input vector y
+ * @param {number} az first input vector z
+ * @param {number} bx second input vector x
+ * @param {number} by second input vector y
+ * @param {number} bz second input vector z
+ */
+export function v3_triple_cross_product(
+    result, result_offset,
+    ax, ay, az,
+    bx, by, bz
+) {
+    // First: t = a × b
+    const tx = ay * bz - az * by;
+    const ty = az * bx - ax * bz;
+    const tz = ax * by - ay * bx;
+
+    // Then: t × a
+    result[result_offset]     = ty * az - tz * ay;
+    result[result_offset + 1] = tz * ax - tx * az;
+    result[result_offset + 2] = tx * ay - ty * ax;
+}

package/src/engine/control/first-person/FirstPersonPlayerController.d.ts

@@ -55,7 +55,7 @@ export class FirstPersonPlayerController {
                 sprintSpeed: number;
                 crouchSpeed: number;
                 airControl: number;
-                groundAccel: number;
+                groundAccelHalfLife: number;
                 groundDecel: number;
                 airAccel: number;
                 backwardSpeedFactor: number;
@@ -68,9 +68,20 @@ export class FirstPersonPlayerController {
                 };
                 peakHeight: number;
                 timeToApex: number;
+                /**
+                 * First-person camera + body controller. See DESIGN.md (sibling file) for
+                 * the goals, layered architecture, and tuning rationale.
+                 *
+                 * Lifecycle: only `config` is serialized. `intent`, `state`, `pose`,
+                 * `signals`, and `eyeEntity` are transient — rebuilt by the system on
+                 * link.
+                 *
+                 * @author Alex Goldring
+                 * @copyright Company Named Limited (c) 2026
+                 */
                 coyoteTime: number;
                 bufferTime: number;
-                fallGravityMult: number; /** {verticalSpeed:number, kind:"soft"|"hard"} */
+                fallGravityMult: number;
                 cutGravityMult: number;
             };
             landing: {
@@ -104,7 +115,9 @@ export class FirstPersonPlayerController {
             };
             wallRun: {
                 minSpeed: number;
-                minAirborneTime: number;
+                minAirborneTime: number; /**
+                 * @param {FirstPersonPlayerController} other
+                 */
                 maxDuration: number;
                 gravityFactor: number;
                 cameraRollDeg: number;

package/src/engine/control/first-person/FirstPersonPlayerController.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"FirstPersonPlayerController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerController.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IACI,wBAAgD;IAG5C,0CAAqD;IACrD,0BAAqC;IACrC,wBAAmC;IACnC,sBAAiC;IACjC,4BAAuC;IAEvC;;;;;;OAMG;IACH,SAFU,UAAU,CAEW;IAE/B;;;;;OAKG;IACH,WAFU,UAAU,CAEa;IAEjC;;;;;;OAMG;IACH,WAFU,MAAM,CAEG;IAGvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAhEA,iDAAiD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAkEhD;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;;kDA3MiD,wCAAwC;AAK1F;;;;;;;;GAQG;AACH;IACI,oEAAoE;IACpE,MADyD,OAAO,CACvC;IAEzB;;;;OAIG;IACH,MAFU,OAAO,CAEQ;IAEzB,mEAAmE;IACnE,MADwD,OAAO,CAClD;IAEb,0EAA0E;IAC1E,QAD+D,OAAO,CACvD;IAEf,qEAAqE;IACrE,QAD0D,OAAO,CAClD;CAClB;AAED;;;GAGG;AACH;IACI,kBAAgB;IAChB,0BAAsB;IAEtB,4EAA4E;IAC5E,sBAAoC;IACpC,gBAAkB;IAElB,cAAU;IACV,4DAA4D;IAC5D,wBAAoB;IACpB,yEAAyE;IACzE,uBAAgD;IAEhD,sBAAkB;IAClB,qBAAiB;IACjB,qBAAiB;IAEjB,4BAAwB;IACxB,4BAA2B;IAC3B,2BAA0B;IAC1B,2EAA2E;IAC3E,qBAAoB;IAEpB,iBAAa;IACb,oBAAgB;IAChB,qBAAiB;IACjB,yBAAqB;IAErB,oBAAgB;IAChB,kBAAc;IACd,kDAAkD;IAClD,iBAAa;IAEb,kBAAiB;IAEjB,+EAA+E;IAC/E,uBAAsB;IACtB,6EAA6E;IAC7E,sBAAqB;IAErB;;;;;;;OAOG;IACH,SAFU,MAAM,CAEmB;IAEnC,oBAAgB;CACnB;gCAzFkF,2BAA2B;AA2F9G;;;GAGG;AACH;IACI,uDAAuD;IACvD,2DAA0B;IAC1B,yEAAyE;IACzE,4DAA2B;IAC3B,kBAAkB;IAClB,2DAA0B;IAC1B,6BAA6B;IAC7B,8DAA6B;IAC7B,iDAAiD;IACjD,uDAAsB;IACtB,8DAA6B;IAC7B,6DAA4B;IAC5B,8DAA6B;IAC7B,6DAA4B;IAC5B,2EAA2E;IAC3E,2DAA0B;IAC1B,2EAA2E;IAC3E,4DAA2B;IAC3B,6DAA6D;IAC7D,4DAA2B;IAC3B,uDAAuD;IACvD,+DAA8B;CACjC;2BAvH0B,yBAAyB;2BAFzB,2BAA2B;uCAG6B,2BAA2B;0CAA3B,2BAA2B;oBAL1F,+BAA+B;oBAC/B,+BAA+B;mBAFhC,uCAAuC"}
+{"version":3,"file":"FirstPersonPlayerController.d.ts","sourceRoot":"","sources":["../../../../../src/engine/control/first-person/FirstPersonPlayerController.js"],"names":[],"mappings":"AA8HA;;;;;;;;;;GAUG;AACH;IACI,wBAAgD;IAG5C,0CAAqD;IACrD,0BAAqC;IACrC,wBAAmC;IACnC,sBAAiC;IACjC,4BAAuC;IAEvC;;;;;;OAMG;IACH,SAFU,UAAU,CAEW;IAE/B;;;;;OAKG;IACH,WAFU,UAAU,CAEa;IAEjC;;;;;;OAMG;IACH,WAFU,MAAM,CAEG;IAGvB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;gBAhDJ;;;;;;;;;;mBAUG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yCAgDC;;mBAEG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MAVF;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;;kDA3MiD,wCAAwC;AAK1F;;;;;;;;GAQG;AACH;IACI,oEAAoE;IACpE,MADyD,OAAO,CACvC;IAEzB;;;;OAIG;IACH,MAFU,OAAO,CAEQ;IAEzB,mEAAmE;IACnE,MADwD,OAAO,CAClD;IAEb,0EAA0E;IAC1E,QAD+D,OAAO,CACvD;IAEf,qEAAqE;IACrE,QAD0D,OAAO,CAClD;CAClB;AAED;;;GAGG;AACH;IACI,kBAAgB;IAChB,0BAAsB;IAEtB,4EAA4E;IAC5E,sBAAoC;IACpC,gBAAkB;IAElB,cAAU;IACV,4DAA4D;IAC5D,wBAAoB;IACpB,yEAAyE;IACzE,uBAAgD;IAEhD,sBAAkB;IAClB,qBAAiB;IACjB,qBAAiB;IAEjB,4BAAwB;IACxB,4BAA2B;IAC3B,2BAA0B;IAC1B,2EAA2E;IAC3E,qBAAoB;IAEpB,iBAAa;IACb,oBAAgB;IAChB,qBAAiB;IACjB,yBAAqB;IAErB,oBAAgB;IAChB,kBAAc;IACd,kDAAkD;IAClD,iBAAa;IAEb,kBAAiB;IAEjB,+EAA+E;IAC/E,uBAAsB;IACtB,6EAA6E;IAC7E,sBAAqB;IAErB;;;;;;;OAOG;IACH,SAFU,MAAM,CAEmB;IAEnC,oBAAgB;CACnB;gCAzFkF,2BAA2B;AA2F9G;;;GAGG;AACH;IACI,uDAAuD;IACvD,2DAA0B;IAC1B,yEAAyE;IACzE,4DAA2B;IAC3B,kBAAkB;IAClB,2DAA0B;IAC1B,6BAA6B;IAC7B,8DAA6B;IAC7B,iDAAiD;IACjD,uDAAsB;IACtB,8DAA6B;IAC7B,6DAA4B;IAC5B,8DAA6B;IAC7B,6DAA4B;IAC5B,2EAA2E;IAC3E,2DAA0B;IAC1B,2EAA2E;IAC3E,4DAA2B;IAC3B,6DAA6D;IAC7D,4DAA2B;IAC3B,uDAAuD;IACvD,+DAA8B;CACjC;2BAvH0B,yBAAyB;2BAFzB,2BAA2B;uCAG6B,2BAA2B;0CAA3B,2BAA2B;oBAL1F,+BAA+B;oBAC/B,+BAA+B;mBAFhC,uCAAuC"}