@woosh/meep-engine 3.41.0 → 3.42.0

package/src/core/geom/3d/gjk/gjk_epa_penetration.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AAkkBA;;;;;;;;;;;;;;;;GAgBG;AACH,yCATW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CA0BlB;AA7DD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4BAFU,MAAM,CAEgB;;;;;;;8BAzdnB;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,CAAC,YAAY,GAAC,MAAM,EAAE,CAAC,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}
+{"version":3,"file":"gjk_epa_penetration.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/gjk/gjk_epa_penetration.js"],"names":[],"mappings":"AAmkBA;;;;;;;;;;;;;;;;GAgBG;AACH,yCATW,YAAY,GAAC,MAAM,EAAE,KACrB,eAAe,KACf,eAAe,GACb,MAAM,CA0BlB;AA7DD;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4BAFU,MAAM,CAEgB;;;;;;;8BA1dnB;IAAE,OAAO,SAAW,YAAY,QAAE,MAAM,QAAE,CAAC,YAAY,GAAC,MAAM,EAAE,CAAC,QAAE,MAAM,KAAG,IAAI,CAAA;CAAE"}

package/src/core/geom/3d/gjk/gjk_epa_penetration.js

@@ -533,9 +533,6 @@ function epa(A, B, out) {
         // Degenerate: no face survived. Report no usable axis (the caller treats a
         // non-positive depth as a miss) rather than reading a stale face and
         // throwing out of the narrowphase step.
-        out[0] = 0;
-        out[1] = 0;
-        out[2] = 0;
         return 0;
     }
 
@@ -545,11 +542,15 @@ function epa(A, B, out) {
             best = f;
         }
     }
+    const depth = FACE_DIST[best];
+    if (!(depth > 0) || !Number.isFinite(depth)) {
+        return 0;
+    }
     const bn = best * 3;
     out[0] = FACE_N[bn];
     out[1] = FACE_N[bn + 1];
     out[2] = FACE_N[bn + 2];
-    return FACE_DIST[best];
+    return depth;
 }
 
 /**

package/src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAkFlB"}
+{"version":3,"file":"line3_compute_segment_point_distance_eikonal.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;GAcG;AACH,iEAbW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAwFlB"}

package/src/core/geom/3d/line/line3_compute_segment_point_distance_eikonal.js

@@ -26,7 +26,13 @@ export function line3_compute_segment_point_distance_eikonal(
     const ab_z = z1 - z0;
     const L = Math.hypot(ab_x, ab_y, ab_z);
 
-    if (L < 1e-9) return Math.min(d0, d1);
+    if (L < 1e-9) {
+        // A point-like edge still leaves the distance from its endpoints to the target.
+        return Math.min(
+            d0 + Math.hypot(px - x0, py - y0, pz - z0),
+            d1 + Math.hypot(px - x1, py - y1, pz - z1)
+        );
+    }
 
     // Vector AC
     const ac_x = px - x0;
@@ -93,4 +99,4 @@ export function line3_compute_segment_point_distance_eikonal(
         const dist_to_v1 = Math.hypot(px - x1, py - y1, pz - z1);
         return Math.min(d0 + dist_to_v0, d1 + dist_to_v1);
     }
-}
+}

package/src/core/geom/3d/triangle/tri3_ray_intersection.d.ts

@@ -20,4 +20,24 @@
  * @returns {boolean}
  */
 export function tri3_ray_intersection(result: SurfacePoint3, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, ax: number, ay: number, az: number, bx: number, by: number, bz: number, cx: number, cy: number, cz: number): boolean;
+/**
+ * Ray-triangle intersection with vertices read from a packed triangle,
+ * [ax, ay, az, bx, by, bz, cx, cy, cz] at triangle_offset.
+ *
+ * All nine coordinates are read before validation or output writes so output
+ * callbacks can mutate the source without changing this intersection.
+ * The arithmetic and output order match tri3_ray_intersection.
+ *
+ * @param {import("../SurfacePoint3.js").SurfacePoint3} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} triangle
+ * @param {number} [triangle_offset=0]
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection_triangle_array(result: import("../SurfacePoint3.js").SurfacePoint3, origin_x: number, origin_y: number, origin_z: number, direction_x: number, direction_y: number, direction_z: number, triangle: ArrayLike<number> | number[] | Float32Array | Float64Array, triangle_offset?: number): boolean;
 //# sourceMappingURL=tri3_ray_intersection.d.ts.map

package/src/core/geom/3d/triangle/tri3_ray_intersection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"tri3_ray_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uEAjBW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoJnB"}
+{"version":3,"file":"tri3_ray_intersection.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/triangle/tri3_ray_intersection.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,uEAjBW,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAoJnB;AAGD;;;;;;;;;;;;;;;;;;GAkBG;AACH,6DAXW,OAAO,qBAAqB,EAAE,aAAa,YAC3C,MAAM,YACN,MAAM,YACN,MAAM,eACN,MAAM,eACN,MAAM,eACN,MAAM,YACN,UAAU,MAAM,CAAC,GAAC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,oBACpD,MAAM,GACJ,OAAO,CAmKnB"}

package/src/core/geom/3d/triangle/tri3_ray_intersection.js

@@ -170,3 +170,185 @@ export function tri3_ray_intersection(
     return true;
 }
 
+
+/**
+ * Ray-triangle intersection with vertices read from a packed triangle,
+ * [ax, ay, az, bx, by, bz, cx, cy, cz] at triangle_offset.
+ *
+ * All nine coordinates are read before validation or output writes so output
+ * callbacks can mutate the source without changing this intersection.
+ * The arithmetic and output order match tri3_ray_intersection.
+ *
+ * @param {import("../SurfacePoint3.js").SurfacePoint3} result
+ * @param {number} origin_x
+ * @param {number} origin_y
+ * @param {number} origin_z
+ * @param {number} direction_x
+ * @param {number} direction_y
+ * @param {number} direction_z
+ * @param {ArrayLike<number>|number[]|Float32Array|Float64Array} triangle
+ * @param {number} [triangle_offset=0]
+ * @returns {boolean}
+ */
+export function tri3_ray_intersection_triangle_array(
+    result,
+    origin_x, origin_y, origin_z,
+    direction_x, direction_y, direction_z,
+    triangle, triangle_offset = 0
+) {
+    const ax = triangle[triangle_offset];
+    const ay = triangle[triangle_offset + 1];
+    const az = triangle[triangle_offset + 2];
+    const bx = triangle[triangle_offset + 3];
+    const by = triangle[triangle_offset + 4];
+    const bz = triangle[triangle_offset + 5];
+    const cx = triangle[triangle_offset + 6];
+    const cy = triangle[triangle_offset + 7];
+    const cz = triangle[triangle_offset + 8];
+
+    // Finite primitive numbers keep the valid path unboxed. The fallback
+    // preserves the scalar form's validation order and diagnostic messages.
+    if (!(Number.isFinite(ax) && Number.isFinite(ay) && Number.isFinite(az)
+        && Number.isFinite(bx) && Number.isFinite(by) && Number.isFinite(bz)
+        && Number.isFinite(cx) && Number.isFinite(cy) && Number.isFinite(cz))) {
+        assert.isNumber(ax, 'ax');
+        assert.isNumber(ay, 'ay');
+        assert.isNumber(az, 'az');
+
+        assert.isNumber(bx, 'bx');
+        assert.isNumber(by, 'by');
+        assert.isNumber(bz, 'bz');
+
+        assert.isNumber(cx, 'cx');
+        assert.isNumber(cy, 'cy');
+        assert.isNumber(cz, 'cz');
+
+        // nan checks
+        assert.notNaN(ax, 'ax');
+        assert.notNaN(ay, 'ay');
+        assert.notNaN(az, 'az');
+
+        assert.notNaN(bx, 'bx');
+        assert.notNaN(by, 'by');
+        assert.notNaN(bz, 'bz');
+
+        assert.notNaN(cx, 'cx');
+        assert.notNaN(cy, 'cy');
+        assert.notNaN(cz, 'cz');
+
+        // finate number check
+        assert.isFinite(ax, 'ax');
+        assert.isFinite(ay, 'ay');
+        assert.isFinite(az, 'az');
+
+        assert.isFinite(bx, 'bx');
+        assert.isFinite(by, 'by');
+        assert.isFinite(bz, 'bz');
+
+        assert.isFinite(cx, 'cx');
+        assert.isFinite(cy, 'cy');
+        assert.isFinite(cz, 'cz');
+
+
+    }
+
+    // edge1 = a - b
+    const edge1_x = bx - ax;
+    const edge1_y = by - ay;
+    const edge1_z = bz - az;
+
+    // edge2 = c - a
+    const edge2_x = cx - ax;
+    const edge2_y = cy - ay;
+    const edge2_z = cz - az;
+
+    // Compute triangle normal
+
+    // normal = edge1 x edge2
+    const normal_x = edge1_y * edge2_z - edge1_z * edge2_y;
+    const normal_y = edge1_z * edge2_x - edge1_x * edge2_z;
+    const normal_z = edge1_x * edge2_y - edge1_y * edge2_x
+
+    let DdN = v3_dot(direction_x, direction_y, direction_z, normal_x, normal_y, normal_z);
+    let sign = 1;
+
+    if (DdN === 0) {
+        // ray and the triangle normal are orthogonal, means that the ray can not pass penetrate triangle
+        return false;
+    } else if (DdN < 0) {
+        sign = -1;
+        DdN = -DdN;
+    }
+
+    // diff = origin - a
+    const diff_x = origin_x - ax;
+    const diff_y = origin_y - ay;
+    const diff_z = origin_z - az;
+
+    // edge3 = diff x edge2
+    const edge3_x = diff_y * edge2_z - diff_z * edge2_y;
+    const edge3_y = diff_z * edge2_x - diff_x * edge2_z;
+    const edge3_z = diff_x * edge2_y - diff_y * edge2_x;
+
+    // DdQxE2 = sign * ( direction . edge3)
+    const DdQxE2 = sign * v3_dot(direction_x, direction_y, direction_z, edge3_x, edge3_y, edge3_z);
+
+    if (DdQxE2 < 0) {
+        // b1 < 0, no intersection
+        return false;
+    }
+
+    const edge4_x = edge1_y * diff_z - edge1_z * diff_y;
+    const edge4_y = edge1_z * diff_x - edge1_x * diff_z;
+    const edge4_z = edge1_x * diff_y - edge1_y * diff_x;
+
+    const DdE1xQ = sign * v3_dot(direction_x, direction_y, direction_z, edge4_x, edge4_y, edge4_z);
+
+    if (DdE1xQ < 0) {
+        // b2 < 0, no intersection
+        return false;
+    }
+
+    if (DdQxE2 + DdE1xQ > DdN) {
+        // b1+b2 > 1, no intersection
+        return false;
+    }
+
+    // Line intersects triangle, check if ray does.
+    const QdN = -sign * v3_dot(diff_x, diff_y, diff_z, normal_x, normal_y, normal_z);
+
+    if (QdN < 0) {
+        // t < 0, no intersection
+        return false;
+
+    }
+
+    // Ray intersects triangle.
+    const t = QdN / DdN;
+
+    // `normal_x/y/z` is the raw `edge1 x edge2`, whose length is twice the triangle's area - it was
+    // written straight into `SurfacePoint3.normal`, which is documented as a surface normal and is
+    // a unit vector out of every other producer in the tree.
+    //
+    // NOTE: normalised but NOT turned to meet the ray, unlike `tri3_raycast`. This normal keeps the
+    // winding's facing on purpose: `StaticSceneBVH.raycast_nearest` derives `geometric_back_face`
+    // from `dot(normal, direction)`, and a normal pre-flipped toward the ray would report every hit
+    // as front-facing.
+    const normal_length = Math.sqrt(normal_x * normal_x + normal_y * normal_y + normal_z * normal_z);
+
+    const inv_normal_length = 1 / normal_length;
+
+    result.normal.set(
+        normal_x * inv_normal_length,
+        normal_y * inv_normal_length,
+        normal_z * inv_normal_length
+    );
+
+    result.position.set(
+        direction_x * t + origin_x,
+        direction_y * t + origin_y,
+        direction_z * t + origin_z,
+    );
+
+    return true;
+}

package/src/core/math/noise/curl_noise_3dt.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"curl_noise_3dt.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/curl_noise_3dt.js"],"names":[],"mappings":"AAMA;;;;;;;GAOG;AACH,uCANW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAehB"}
+{"version":3,"file":"curl_noise_3dt.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/curl_noise_3dt.js"],"names":[],"mappings":"AAOA;;;;;;;GAOG;AACH,uCANW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,QAwBhB"}

package/src/core/math/noise/curl_noise_3dt.js

@@ -1,8 +1,9 @@
-import { sdnoise3 } from "./sdnoise.js";
+import { sdnoise3_array } from "./sdnoise.js";
 
-const p_x0 = [];
-const p_y0 = [];
-const p_z0 = [];
+const p_x0 = new Float64Array(4);
+const p_y0 = new Float64Array(4);
+const p_z0 = new Float64Array(4);
+const sample_position = new Float64Array(3);
 
 /**
  *
@@ -14,13 +15,22 @@ const p_z0 = [];
  */
 export function curl_noise_3dt(result, x, y, z, w) {
 
-    sdnoise3(p_x0, x + w, y, z);
-    sdnoise3(p_y0, x + 31.341, y - 43.23 + w, z + 12.34);
-    sdnoise3(p_z0, x - 231.141, y + 124.123, z - 54.4341 + w);
+    sample_position[0] = x + w;
+    sample_position[1] = y;
+    sample_position[2] = z;
+    sdnoise3_array(p_x0, 0, sample_position, 0);
+    sample_position[0] = x + 31.341;
+    sample_position[1] = y - 43.23 + w;
+    sample_position[2] = z + 12.34;
+    sdnoise3_array(p_y0, 0, sample_position, 0);
+    sample_position[0] = x - 231.141;
+    sample_position[1] = y + 124.123;
+    sample_position[2] = z - 54.4341 + w;
+    sdnoise3_array(p_z0, 0, sample_position, 0);
 
-    const _x = p_z0[1] - p_y0[2];
-    const _y = p_x0[2] - p_z0[0];
-    const _z = p_y0[0] - p_x0[1];
+    const _x = p_z0[2] - p_y0[3];
+    const _y = p_x0[3] - p_z0[1];
+    const _z = p_y0[1] - p_x0[2];
 
     result[0] = _x;
     result[1] = _y;

package/src/core/math/noise/sdnoise.d.ts

@@ -17,17 +17,28 @@ export function sdnoise1(derivatives: number[], x: number): number;
  * @returns {number}
  */
 export function sdnoise2(derivatives: number[], x: number, y: number): number;
-/** 3D simplex noise with derivatives.
- * If the last tthree arguments are not null, the analytic derivative
- * (the 3D gradient of the scalar noise field) is also calculated.
+/** 3D simplex noise with its analytic gradient, written into derivatives[0..2].
+ * Scalar facade over {@link sdnoise3_array}; returns the noise value.
  *
+ * @param {number[]|Float32Array|Float64Array} derivatives
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} derivatives
  * @returns {number}
  */
-export function sdnoise3(derivatives: number[], x: number, y: number, z: number): number;
+export function sdnoise3(derivatives: number[] | Float32Array | Float64Array, x: number, y: number, z: number): number;
+/**
+ * 3D simplex noise and its analytic gradient, with packed coordinates.
+ * Writes [noise, dx, dy, dz] at out_offset and returns nothing. Coordinates
+ * are read before output stores, so input and output may overlap.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} position
+ * @param {number} position_offset
+ * @returns {void}
+ */
+export function sdnoise3_array(out: number[] | Float32Array | Float64Array, out_offset: number, position: ArrayLike<number>, position_offset: number): void;
 /**
  * 4D simplex noise with derivatives.
  * If the last four arguments are not null, the analytic derivative

package/src/core/math/noise/sdnoise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAsDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAmIlB;AAUD;;;;;;;;;GASG;AACH,sCAHW,MAAM,EAAE,KAHR,MAAM,KACN,MAAM,KACN,MAAM,GAEJ,MAAM,CAgPlB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgSlB"}
+{"version":3,"file":"sdnoise.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/noise/sdnoise.js"],"names":[],"mappings":"AA6LA;;;;;;;GAOG;AACH,sCAHW,MAAM,EAAE,KADR,MAAM,GAEJ,MAAM,CAsDlB;AAUD;;;;;;;;GAQG;AACH,sCAHW,MAAM,EAAE,KAFR,MAAM,KACN,MAAM,GAEJ,MAAM,CAmIlB;AAaD;;;;;;;;GAQG;AACH,sCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,KAClC,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAmBlB;AAED;;;;;;;;;;GAUG;AACH,oCANW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,YACN,UAAU,MAAM,CAAC,mBACjB,MAAM,GACJ,IAAI,CAkPhB;AAMD;;;;;;;;;;GAUG;AACH,sCAPW,MAAM,EAAE,KACR,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAgSlB"}

package/src/core/math/noise/sdnoise.js

@@ -404,18 +404,53 @@ export function sdnoise2(derivatives, x, y) {
 const F3 = 0.3333333333333333;
 const G3 = 0.16666666666666666;
 
+const scalar_position = new Float64Array(3);
+const scalar_noise_gradient = new Float64Array(4);
 
-/** 3D simplex noise with derivatives.
- * If the last tthree arguments are not null, the analytic derivative
- * (the 3D gradient of the scalar noise field) is also calculated.
+
+/** 3D simplex noise with its analytic gradient, written into derivatives[0..2].
+ * Scalar facade over {@link sdnoise3_array}; returns the noise value.
  *
+ * @param {number[]|Float32Array|Float64Array} derivatives
  * @param {number} x
  * @param {number} y
  * @param {number} z
- * @param {number[]} derivatives
  * @returns {number}
  */
 export function sdnoise3(derivatives, x, y, z) {
+    scalar_position[0] = x;
+    scalar_position[1] = y;
+    scalar_position[2] = z;
+    sdnoise3_array(scalar_noise_gradient, 0, scalar_position, 0);
+
+    // A destination setter may start another sample and overwrite our scratch.
+    // Capture every lane before the first externally observable store.
+    const noise = scalar_noise_gradient[0];
+    const dx = scalar_noise_gradient[1];
+    const dy = scalar_noise_gradient[2];
+    const dz = scalar_noise_gradient[3];
+
+    derivatives[0] = dx;
+    derivatives[1] = dy;
+    derivatives[2] = dz;
+    return noise;
+}
+
+/**
+ * 3D simplex noise and its analytic gradient, with packed coordinates.
+ * Writes [noise, dx, dy, dz] at out_offset and returns nothing. Coordinates
+ * are read before output stores, so input and output may overlap.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} position
+ * @param {number} position_offset
+ * @returns {void}
+ */
+export function sdnoise3_array(out, out_offset, position, position_offset) {
+    const x = position[position_offset];
+    const y = position[position_offset + 1];
+    const z = position[position_offset + 2];
     let n0, n1, n2, n3; /* Noise contributions from the four simplex corners */
     let gx0, gy0, gz0, gx1, gy1, gz1; /* Gradients at simplex corners */
     let gx2, gy2, gz2, gx3, gy3, gz3;
@@ -648,11 +683,10 @@ export function sdnoise3(derivatives, x, y, z) {
     dnoise_dy *= 28.0;
     dnoise_dz *= 28.0;
 
-    derivatives[0] = dnoise_dx;
-    derivatives[1] = dnoise_dy;
-    derivatives[2] = dnoise_dz;
-
-    return noise;
+    out[out_offset] = noise;
+    out[out_offset + 1] = dnoise_dx;
+    out[out_offset + 2] = dnoise_dy;
+    out[out_offset + 3] = dnoise_dz;
 }
 
 // The skewing and unskewing factors are hairy again for the 4D case

package/src/core/math/spline/spline3_hermite_nearest_point.d.ts

@@ -1,7 +1,7 @@
 /**
  * Finds the parameter 't' of the nearest point on a 1D Hermite spline
  * function graph to a reference point. The curve is defined by (t, p(t)).
- * This version is optimized to avoid allocations.
+ * Scalar facade over {@link spline3_hermite_nearest_point_array}.
  *
  * @param {number} ref_t - The 't' coordinate of the reference point.
  * @param {number} ref_p - The 'p' coordinate of the reference point.
@@ -12,4 +12,19 @@
  * @returns {number} The parameter 't' of the nearest point. This value is always in [0..1] range
  */
 export function spline3_hermite_nearest_point(ref_t: number, ref_p: number, p0: number, p1: number, m0: number, m1: number): number;
+/**
+ * Finds the nearest parameter on a 1D Hermite spline using packed inputs and
+ * writes it into `out[out_offset]`. The reference is `[ref_t, ref_p]` and the
+ * spline is `[p0, p1, m0, m1]`. All inputs are read before the output store,
+ * so the destination may overlap either input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} reference
+ * @param {number} reference_offset
+ * @param {ArrayLike<number>} spline
+ * @param {number} spline_offset
+ * @returns {void}
+ */
+export function spline3_hermite_nearest_point_array(out: number[] | Float32Array | Float64Array, out_offset: number, reference: ArrayLike<number>, reference_offset: number, spline: ArrayLike<number>, spline_offset: number): void;
 //# sourceMappingURL=spline3_hermite_nearest_point.d.ts.map

package/src/core/math/spline/spline3_hermite_nearest_point.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spline3_hermite_nearest_point.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_nearest_point.js"],"names":[],"mappings":"AAyBA;;;;;;;;;;;;GAYG;AACH,qDARW,MAAM,SACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAyFlB"}
+{"version":3,"file":"spline3_hermite_nearest_point.d.ts","sourceRoot":"","sources":["../../../../../src/core/math/spline/spline3_hermite_nearest_point.js"],"names":[],"mappings":"AA6BA;;;;;;;;;;;;GAYG;AACH,qDARW,MAAM,SACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,MAAM,CAgBlB;AAED;;;;;;;;;;;;;GAaG;AACH,yDARW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,cAClC,MAAM,aACN,UAAU,MAAM,CAAC,oBACjB,MAAM,UACN,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ,IAAI,CAgGhB"}

package/src/core/math/spline/spline3_hermite_nearest_point.js

@@ -20,13 +20,17 @@ function polyval(p, t, size) {
 const quintic_coeffs = new Float32Array(6);
 const quartic_coeffs = new Float32Array(5);
 
+const scalar_reference = new Float64Array(2);
+const scalar_spline = new Float64Array(4);
+const scalar_result = new Float64Array(1);
+
 const NEWTON_STEPS = 3;
 const START_ROOT_COUNT = 5;
 
 /**
  * Finds the parameter 't' of the nearest point on a 1D Hermite spline
  * function graph to a reference point. The curve is defined by (t, p(t)).
- * This version is optimized to avoid allocations.
+ * Scalar facade over {@link spline3_hermite_nearest_point_array}.
  *
  * @param {number} ref_t - The 't' coordinate of the reference point.
  * @param {number} ref_p - The 'p' coordinate of the reference point.
@@ -40,6 +44,43 @@ export function spline3_hermite_nearest_point(
     ref_t, ref_p,
     p0, p1, m0, m1
 ) {
+    scalar_reference[0] = ref_t;
+    scalar_reference[1] = ref_p;
+    scalar_spline[0] = p0;
+    scalar_spline[1] = p1;
+    scalar_spline[2] = m0;
+    scalar_spline[3] = m1;
+
+    spline3_hermite_nearest_point_array(scalar_result, 0, scalar_reference, 0, scalar_spline, 0);
+
+    return scalar_result[0];
+}
+
+/**
+ * Finds the nearest parameter on a 1D Hermite spline using packed inputs and
+ * writes it into `out[out_offset]`. The reference is `[ref_t, ref_p]` and the
+ * spline is `[p0, p1, m0, m1]`. All inputs are read before the output store,
+ * so the destination may overlap either input.
+ *
+ * @param {number[]|Float32Array|Float64Array} out
+ * @param {number} out_offset
+ * @param {ArrayLike<number>} reference
+ * @param {number} reference_offset
+ * @param {ArrayLike<number>} spline
+ * @param {number} spline_offset
+ * @returns {void}
+ */
+export function spline3_hermite_nearest_point_array(
+    out, out_offset,
+    reference, reference_offset,
+    spline, spline_offset
+) {
+    const ref_t = reference[reference_offset];
+    const ref_p = reference[reference_offset + 1];
+    const p0 = spline[spline_offset];
+    const p1 = spline[spline_offset + 1];
+    const m0 = spline[spline_offset + 2];
+    const m1 = spline[spline_offset + 3];
 
     // 1. Calculate polynomial coefficients A, B, C for p(t)
     const A = 2 * p0 - 2 * p1 + m0 + m1;
@@ -122,5 +163,5 @@ export function spline3_hermite_nearest_point(
         }
     }
 
-    return best_t;
-}
+    out[out_offset] = best_t;
+}

package/src/engine/Engine.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IAiGI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBAuGC;IAqBD;;OAEG;IACH,sBAgEC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAl5B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}
+{"version":3,"file":"Engine.d.ts","sourceRoot":"","sources":["../../../src/engine/Engine.js"],"names":[],"mappings":";6BAqCa,OAAO,8BAA8B,EAAE,cAAc;AAwClE;IAiGI;;;;;;;;;OASG;IACH,sBARW,cAAc;QAEU,aAAa,GAArC,aAAa;QACK,cAAc,GAAhC,OAAO;QACW,WAAW,GAA7B,OAAO;QACW,KAAK,GAAvB,OAAO;OAiPjB;IAtSD;;;OAGG;IACH,UAFU,cAAc,GAAC,IAAI,CAEb;IAEhB;;;OAGG;IACH,OAFU,WAAW,GAAC,IAAI,CAEb;IAEb,qBAA4B;IAE5B;;;;;;;;;OASG;IACH,0BAFU,uBAAuB,CAEe;IAEhD;;;OAGG;IACH,kBAFU,mBAAmB,CAEO;IAEpC;;;;OAIG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;OAIG;IACH,mBAFU,kBAAkB,CAEa;IAoBrC;;;OAGG;IACH,UAFU,cAAc,CAEA;IAKxB;;;OAGG;IACH,aAFU,gBAAgB,CAEe;IAGzC,yCAAkE;IAK9D,6BAAkC;IAMtC;;;OAGG;IACH,cAFU,aAAa,MAAM,CAAC,CAK5B;IAEF,8CAiCE;IAgCF;;;OAGG;IACH,SAFU,WAAW,CAEoB;IAEzC;;;OAGG;IACH,oCAA0C;IAE1C;;;OAGG;IACH,sCAFU,2BAA2B,CAE+B;IAEpE,yBAAoC;IAGpC;;OAEG;IACH,aAAkB;IAElB;;;OAGG;IACH,SAFU,OAAO,CAEwB;IAGzC,2BAAsC;IAuCtC;;;OAGG;IACH,KAFU,SAAS,CAEO;IAE1B;;;OAGG;IACH,uBAFU,YAAY,CAEqD;IAI3E;;;;;MAKC;IA8BD;;;OAGG;IACH,kBAFU,OAAO,CAEW;IAwIhC,wBAgCC;IApBG,oBAAwB;IAsB5B,2BA8CC;IAED,oBAiBC;IAED;;;OAGG;IACH,+CAUC;IAED,eAkDC;IAED;;;OAGG;IACH,sBA2GC;IAqBD;;OAEG;IACH,sBAgEC;IAED,aAEC;IAED;;OAEG;IACH,4BAOC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;;CAPxB;+BAt5B8B,+BAA+B;wBAWtC,wBAAwB;0BArBtB,0CAA0C;wCAeN,iDAAiD;oCAG3E,iCAAiC;mBAElD,wBAAwB;+BAtBZ,gDAAgD;iCAO9C,+CAA+C;8BAGlD,wBAAwB;6BALzB,yBAAyB;uCAIf,6DAA6D;4BAUxE,0BAA0B;+BArBvB,iCAAiC;4CAapB,qDAAqD;AAgBjG;;GAEG;AAGH;IACI,gDAA2D;IAC3D,0BAAkC;IAClC,iCAAyC;CAC5C;6BAvC4B,sCAAsC;sBA4B7C,mBAAmB;yBAJhB,yBAAyB;8BALpB,kCAAkC;2BADrC,mCAAmC;8BAFhC,kCAAkC;8BAClC,kCAAkC;sBAb1C,+BAA+B;+BAKtB,qCAAqC;4BAPxC,kCAAkC;oBAH1C,yBAAyB"}

package/src/engine/Engine.js

@@ -770,12 +770,14 @@ class Engine {
             ? knowledge.load(this.assetManager, this.executor)
             : Promise.resolve();
 
-        return Promise.all([
+        const startupPromises = [
             soundStarted.then(promiseEntityManager),
             knowledgeLoaded,
             this.gui.startup(this),
             this.plugins.startup()
-        ]).then(async () => {
+        ];
+
+        return Promise.all(startupPromises).then(async () => {
 
             this.#last_frame_timestamp = performance.now();
 
@@ -804,6 +806,8 @@ class Engine {
             logger.info('engine started');
         }, async (e) => {
             logger.error(`Engine Failed to start: ${e}`);
+            // Each branch must settle before its resources can safely be released.
+            await Promise.allSettled(startupPromises);
 
             // Unwind what did come up. Before the Promise.all this method has already acquired the
             // GPU device, started the asset manager, subscribed the sound engine to pointer and

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

@@ -134,6 +134,15 @@ export class FirstPersonPlayerController {
                 upFactor: number;
                 nearWallMaxDistance: number;
             };
+            scrambleUp: {
+                baseJumpForce: number;
+                momentumForcePerSpeed: number;
+                maxJumpForce: number;
+                decel: number;
+                hugSpeed: number;
+                maxDuration: number;
+                kickOutwardImpulse: number;
+            };
             slide: {
                 minEntrySpeed: number;
                 endSpeed: 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;IAEhD,0CAAiD;IACjD,0BAAiC;IACjC,wBAA+B;IAC/B,sBAA6B;IAC7B,4BAAmC;IAEnC;;;;;;OAMG;IACH,SAFU,UAAU,CAEO;IAE3B;;;;;OAKG;IACH,WAFU,UAAU,CAES;IAE7B;;;;;;OAMG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;qCA7FA,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+F9E;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;;kDAzMiD,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,mBAA0B;IAC1B,yEAAyE;IACzE,oBAA2B;IAC3B,kBAAkB;IAClB,mBAA0B;IAC1B,6BAA6B;IAC7B,sBAA6B;IAC7B,iDAAiD;IACjD,eAAsB;IACtB,sBAA6B;IAC7B,qBAA4B;IAC5B,sBAA6B;IAC7B,qBAA4B;IAC5B,2EAA2E;IAC3E,mBAA0B;IAC1B,2EAA2E;IAC3E,oBAA2B;IAC3B,6DAA6D;IAC7D,oBAA2B;IAC3B,+DAA+D;IAC/D,uBAA8B;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;IAEhD,0CAAiD;IACjD,0BAAiC;IACjC,wBAA+B;IAC/B,sBAA6B;IAC7B,4BAAmC;IAEnC;;;;;;OAMG;IACH,SAFU,UAAU,CAEO;IAE3B;;;;;OAKG;IACH,WAFU,UAAU,CAES;IAE7B;;;;;;OAMG;IACH,WAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;qCA7FA,+EAA+E;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;MA+F9E;IAED,0BAIC;IAED;;OAEG;IACH,YAFW,2BAA2B,QAKrC;IAED,qCAIC;IAED,4BAGC;IAED,eAGC;CACJ;;;;;kDAzMiD,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,mBAA0B;IAC1B,yEAAyE;IACzE,oBAA2B;IAC3B,kBAAkB;IAClB,mBAA0B;IAC1B,6BAA6B;IAC7B,sBAA6B;IAC7B,iDAAiD;IACjD,eAAsB;IACtB,sBAA6B;IAC7B,qBAA4B;IAC5B,sBAA6B;IAC7B,qBAA4B;IAC5B,2EAA2E;IAC3E,mBAA0B;IAC1B,2EAA2E;IAC3E,oBAA2B;IAC3B,6DAA6D;IAC7D,oBAA2B;IAC3B,+DAA+D;IAC/D,uBAA8B;CACjC;2BAvH0B,yBAAyB;2BAFzB,2BAA2B;uCAG6B,2BAA2B;0CAA3B,2BAA2B;oBAL1F,+BAA+B;oBAC/B,+BAA+B;mBAFhC,uCAAuC"}

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

@@ -797,6 +797,32 @@ export class FirstPersonPlayerControllerConfig {
              *  is allowed (when not already wall-running). */
             nearWallMaxDistance: number;
         };
+        scrambleUp: {
+            /** Standstill push-off force (N) — a scramble jumped with no run-up. At
+             *  the default 80 kg body + 0.45 m push-off this launches ~5 m/s (~0.9 m
+             *  up the wall at the default decel). */
+            baseJumpForce: number;
+            /** Force (N) added per m/s of horizontal approach speed at the jump —
+             *  the running-start reward, in the same physical currency as the base. */
+            momentumForcePerSpeed: number;
+            /** Cap on the push-off force (N) — a full sprint run-up tops out here
+             *  (~9 m/s launch, ~2.9 m climb at the default body + decel). */
+            maxJumpForce: number;
+            /** Upward deceleration (m/s²) — strong, so the climb is a SHORT burst:
+             *  apex ≈ launchVy²/(2·decel) m high, reached in launchVy/decel s. */
+            decel: number;
+            /** Small into-wall speed (m/s) holding the body against the face as it
+             *  climbs (the mover clips the penetration). */
+            hugSpeed: number;
+            /** Safety cap on scramble duration (s) — releases even if the apex
+             *  somehow isn't reached. */
+            maxDuration: number;
+            /** Wall-kick (jump during the scramble): outward impulse (m/s along the
+             *  wall normal). The kick's UPWARD launch is not tuned here — it uses the
+             *  body's full jump push-off force (`runtime.jumpForce`), so a wall-kick
+             *  rises like a max-height jump. */
+            kickOutwardImpulse: number;
+        };
         slide: {
             /**
              * Required horizontal speed to start a slide. Below this,