@woosh/meep-engine 3.49.0 → 3.50.0

package/editor/particles/effect/ParticleReferenceSimulation.d.ts

@@ -50,6 +50,17 @@ export class ParticleReferenceSimulation {
      * @type {number}
      */
     time: number;
+    /**
+     * The wind `SAMPLE_WIND` reads here, m/s, the same at every point: a far field.
+     *
+     * The preview has no scene, so no published wind field to sample, and it answers the opcode with
+     * what its host hands it — a `GlobalFluidEffector`'s far field, read off
+     * `FluidEffectorsSystem.read_atmosphere` (its `VELOCITY_*` words), is the obvious source. Still
+     * air until someone writes it. Written in place; read at every sample.
+     *
+     * @type {Float32Array}
+     */
+    wind: Float32Array;
     /**
      * @type {number}
      */

package/editor/particles/effect/ParticleReferenceSimulation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AAE9C;IAgGI;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IAjHD;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAoDL;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAYC;IAED;;;;;;;;;;;;OAYG;IACH;QAJ0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;aAsBhB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAmBhB;IA0KD;;;;;;;;;OASG;IACH,gCAFoB;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,gBA2C7H;;CACJ"}
+{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AAuCA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AAE9C;IA0HI;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IA3ID;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAET;;;;;;;;;OASG;IACH,MAFU,YAAY,CAEK;IAkEvB;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAYC;IAED;;;;;;;;;;;;OAYG;IACH;QAJ0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;aAsBhB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAmBhB;IA4KD;;;;;;;;;OASG;IACH,gCAFoB;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC,gBA2C7H;;CACJ"}

package/editor/particles/effect/ParticleReferenceSimulation.js

@@ -97,6 +97,32 @@ export class ParticleReferenceSimulation {
      */
     time = 0;
 
+    /**
+     * The wind `SAMPLE_WIND` reads here, m/s, the same at every point: a far field.
+     *
+     * The preview has no scene, so no published wind field to sample, and it answers the opcode with
+     * what its host hands it — a `GlobalFluidEffector`'s far field, read off
+     * `FluidEffectorsSystem.read_atmosphere` (its `VELOCITY_*` words), is the obvious source. Still
+     * air until someone writes it. Written in place; read at every sample.
+     *
+     * @type {Float32Array}
+     */
+    wind = new Float32Array(3);
+
+    /**
+     * The reference VM's host function for `SAMPLE_WIND`: {@link wind}, wherever it is asked. Made
+     * once, so a sample allocates nothing.
+     *
+     * @type {import("../../../src/shade/renderer/particles/vm/ParticleVMReference.js").ParticleVMWindSampler}
+     */
+    #sample_wind = (out) => {
+        const wind = this.wind;
+
+        out[0] = wind[0];
+        out[1] = wind[1];
+        out[2] = wind[2];
+    };
+
     /**
      * How many spawns have happened, so two particles born in the same frame get different seeds.
      * @type {number}
@@ -325,6 +351,7 @@ export class ParticleReferenceSimulation {
                 record,
                 builtins: this.#builtins(dt, slot, count === 0 ? 0 : i / count),
                 rng_state: this.rng[slot],
+                sample_wind: this.#sample_wind,
             });
 
             this.rng[slot] = result.rng_state;
@@ -368,6 +395,7 @@ export class ParticleReferenceSimulation {
                 record: this.#record(slot),
                 builtins: this.#builtins(dt_particle, slot, 0),
                 rng_state: this.rng[slot],
+                sample_wind: this.#sample_wind,
             });
 
             this.rng[slot] = result.rng_state;

package/editor/view/particles/effect/ParticleGraphEditorView.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleGraphEditorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleGraphEditorView.js"],"names":[],"mappings":"AA0LA;IA6FI;;;;;OAKG;IACH;QAJyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;QAC1D,eAAe;OAsDnD;IAhDG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IAEpB;;OAEG;IACH,2CAAsC;IA4X1C;;;;;;;;;;;;;;;OAeG;IACH,kBAHa,QAAQ,eAAa,IAAI,CAAC,CAwEtC;IAED;;;;;;;;OAQG;IACH,oBAFa,QAAQ,cAAc,CAAC,CAgCnC;IA+ID;;;;;;;;;;;;;OAaG;IACH,iBAHW,OAAO,qEAAqE,EAAE,iBAAiB,GAC7F,IAAI,CAsDhB;IAED;;;OAGG;IACH,cAFa,IAAI,CAIhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,IAAI,CAWhB;IAED;;;;OAIG;IACH,cAFa,OAAO,qEAAqE,EAAE,iBAAiB,EAAE,CAI7G;IAED;;;;;;;;;;OAUG;IACH,gBAuCC;IAwBD;;;;;;;OAOG;IACH,wDAHW,MAAM,GACJ,qBAAqB,CAiBjC;IAiED;;;;OAIG;IACH,gBAFa,mBAAmB,CAQ/B;IAED;;OAEG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAmBhB;IAoGD;;;;;;;;;OASG;IACH,mBAJW,OAAO,qEAAqE,EAAE,iBAAiB,SAC/F,MAAM,GACJ,IAAI,CAqBhB;IAED;;;;;;;;;;;OAWG;IACH,wBAoCC;IAoDD;;;;;OAKG;IACH,qBAHW,MAAM,WACN,MAAM,QA2BhB;IAED;;;;;OAKG;IACH,cAFa,OAAO,6CAA6C,EAAE,uBAAuB,GAAC,IAAI,CAI9F;IAED,eAuBC;;CAgCJ;iBAtgDgB,8BAA8B;gCAvCf,sDAAsD;oCA0ClD,yCAAyC"}
+{"version":3,"file":"ParticleGraphEditorView.d.ts","sourceRoot":"","sources":["../../../../../editor/view/particles/effect/ParticleGraphEditorView.js"],"names":[],"mappings":"AA4LA;IA6FI;;;;;OAKG;IACH;QAJyG,MAAM,EAApG,OAAO,qDAAqD,EAAE,sBAAsB;QAC1D,eAAe;OAsDnD;IAhDG,mBAAuC;IAIvC;;OAEG;IACH,QAFU,OAAO,qDAAqD,EAAE,sBAAsB,CAE1E;IAEpB;;OAEG;IACH,2CAAsC;IA4X1C;;;;;;;;;;;;;;;OAeG;IACH,kBAHa,QAAQ,eAAa,IAAI,CAAC,CAwEtC;IAED;;;;;;;;OAQG;IACH,oBAFa,QAAQ,cAAc,CAAC,CAgCnC;IA+ID;;;;;;;;;;;;;OAaG;IACH,iBAHW,OAAO,qEAAqE,EAAE,iBAAiB,GAC7F,IAAI,CAsDhB;IAED;;;OAGG;IACH,cAFa,IAAI,CAIhB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,GACJ,IAAI,CAWhB;IAED;;;;OAIG;IACH,cAFa,OAAO,qEAAqE,EAAE,iBAAiB,EAAE,CAI7G;IAED;;;;;;;;;;OAUG;IACH,gBAuCC;IAwBD;;;;;;;OAOG;IACH,wDAHW,MAAM,GACJ,qBAAqB,CAiBjC;IAiED;;;;OAIG;IACH,gBAFa,mBAAmB,CAQ/B;IAED;;OAEG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,aAFW,MAAM,QAmBhB;IAoGD;;;;;;;;;OASG;IACH,mBAJW,OAAO,qEAAqE,EAAE,iBAAiB,SAC/F,MAAM,GACJ,IAAI,CAqBhB;IAED;;;;;;;;;;;OAWG;IACH,wBAoCC;IAoDD;;;;;OAKG;IACH,qBAHW,MAAM,WACN,MAAM,QA2BhB;IAED;;;;;OAKG;IACH,cAFa,OAAO,6CAA6C,EAAE,uBAAuB,GAAC,IAAI,CAI9F;IAED,eAuBC;;CAgCJ;iBAxgDgB,8BAA8B;gCAvCf,sDAAsD;oCA0ClD,yCAAyC"}

package/editor/view/particles/effect/ParticleGraphEditorView.js

@@ -148,6 +148,8 @@ const PALETTE_CATEGORIES = [
     { name: "rotation", types: ["quatFromAxisAngle", "quatLookRotation", "quatRotate", "quatMultiply", "quatIntegrate", "sampleRotation", "emitterRotation"] },
     { name: "sampling", types: ["sampleSphereSurface", "sampleSphereVolume"] },
     { name: "noise", types: ["simplex3", "simplex4", "curl3", "curl4", "srdnoise3", "psrdnoise3"] },
+    // What the scene around the particle holds, read at a point.
+    { name: "scene", types: ["wind"] },
 ];
 
 /**

package/package.json

@@ -6,7 +6,7 @@
   "description": "Advanced 3D game engine",
   "type": "module",
   "author": "Alexander Goldring",
-  "version": "3.49.0",
+  "version": "3.50.0",
   "exports": {
     "./build/*": "./build/*",
     "./src/*": "./src/*",

package/src/core/color/xyz/m3_rgb_to_xyz_from_primaries.d.ts

@@ -0,0 +1,11 @@
+/**
+ * The matrix from linear RGB to CIE XYZ for a set of primaries and a white point, derived from their chromaticities
+ * so that RGB 1,1,1 lands on the white at Y = 1. Row-major.
+ *
+ * @param {Float64Array|number[]} out 9 elements, row-major
+ * @param {number[]} primaries xy of red, green and blue: `[xr, yr, xg, yg, xb, yb]`
+ * @param {number} white_x
+ * @param {number} white_y
+ */
+export function m3_rgb_to_xyz_from_primaries(out: Float64Array | number[], primaries: number[], white_x: number, white_y: number): void;
+//# sourceMappingURL=m3_rgb_to_xyz_from_primaries.d.ts.map

package/src/core/color/xyz/m3_rgb_to_xyz_from_primaries.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m3_rgb_to_xyz_from_primaries.d.ts","sourceRoot":"","sources":["../../../../../src/core/color/xyz/m3_rgb_to_xyz_from_primaries.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,kDALW,YAAY,GAAC,MAAM,EAAE,aACrB,MAAM,EAAE,WACR,MAAM,WACN,MAAM,QA4BhB"}

package/src/core/color/xyz/m3_rgb_to_xyz_from_primaries.js

@@ -0,0 +1,40 @@
+import { m3_invert } from "../../geom/mat3/m3_invert.js";
+
+const scratch_inverse = new Float64Array(9);
+
+/**
+ * The matrix from linear RGB to CIE XYZ for a set of primaries and a white point, derived from their chromaticities
+ * so that RGB 1,1,1 lands on the white at Y = 1. Row-major.
+ *
+ * @param {Float64Array|number[]} out 9 elements, row-major
+ * @param {number[]} primaries xy of red, green and blue: `[xr, yr, xg, yg, xb, yb]`
+ * @param {number} white_x
+ * @param {number} white_y
+ */
+export function m3_rgb_to_xyz_from_primaries(out, primaries, white_x, white_y) {
+    // each primary's XYZ at Y = 1, one per column
+    for (let column = 0; column < 3; column++) {
+        const x = primaries[column * 2];
+        const y = primaries[column * 2 + 1];
+
+        out[column] = x / y;
+        out[3 + column] = 1;
+        out[6 + column] = (1 - x - y) / y;
+    }
+
+    const inverse = scratch_inverse;
+    m3_invert(inverse, out);
+
+    const wX = white_x / white_y;
+    const wZ = (1 - white_x - white_y) / white_y;
+
+    // scale each primary so that the three together make the white
+    for (let column = 0; column < 3; column++) {
+        const row = column * 3;
+        const scale = inverse[row] * wX + inverse[row + 1] + inverse[row + 2] * wZ;
+
+        out[column] *= scale;
+        out[3 + column] *= scale;
+        out[6 + column] *= scale;
+    }
+}

package/src/core/geom/3d/mat4/m4_decompose_rigid_array.d.ts

@@ -0,0 +1,24 @@
+/**
+ * Decompose an affine matrix into a translation and a rotation, if it is a rigid motion: affine, unit
+ * columns, perpendicular columns, no reflection.
+ *
+ * What a `TransformedShape3D` wrapper is when it only moves its subject. The physics narrowphase asks
+ * this to collide a rigidly wrapped mesh where it sits, and the shape record asks it to pack a rigidly
+ * wrapped primitive with a pose rather than refuse it. A matrix that scales, shears, mirrors or projects
+ * is no such thing.
+ *
+ * The test is per column, within {@link RIGID_TOLERANCE}; a reflection fails it as a negative x scale,
+ * which is how {@link m4_decompose_array} folds it. Contrast {@link m4_rigidity_defect}, which measures
+ * orthonormality alone and reads a reflection as rigid.
+ *
+ * Nothing is allocated. `m4` may be either destination.
+ *
+ * @param {ArrayLike<number>} m4 column-major, 16 elements
+ * @param {number[]|Float32Array|Float64Array} translation receives `[x, y, z]`
+ * @param {number} translation_offset
+ * @param {number[]|Float32Array|Float64Array} rotation receives a unit quaternion `[x, y, z, w]`
+ * @param {number} rotation_offset
+ * @returns {boolean} whether `m4` is a rigid motion; both destinations are untouched when it is not
+ */
+export function m4_decompose_rigid_array(m4: ArrayLike<number>, translation: number[] | Float32Array | Float64Array, translation_offset: number, rotation: number[] | Float32Array | Float64Array, rotation_offset: number): boolean;
+//# sourceMappingURL=m4_decompose_rigid_array.d.ts.map

package/src/core/geom/3d/mat4/m4_decompose_rigid_array.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"m4_decompose_rigid_array.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/mat4/m4_decompose_rigid_array.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,6CAPW,UAAU,MAAM,CAAC,eACjB,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,sBAClC,MAAM,YACN,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,mBAClC,MAAM,GACJ,OAAO,CAwCnB"}

package/src/core/geom/3d/mat4/m4_decompose_rigid_array.js

@@ -0,0 +1,80 @@
+import { m4_decompose_array } from "./m4_decompose_array.js";
+
+/**
+ * How far a matrix may be from a rigid motion — column lengths off 1, columns off perpendicular — and
+ * still be treated as one. A matrix handed over in float32 arrives rounded at about 1e-7, an exact
+ * rotation included.
+ * @type {number}
+ */
+const RIGID_TOLERANCE = 1e-5;
+
+/**
+ * The decomposition, held here until the matrix has passed, so a refused matrix leaves the caller's
+ * destinations untouched.
+ * @type {Float64Array}
+ */
+const scratch_translation = new Float64Array(3);
+const scratch_rotation = new Float64Array(4);
+const scratch_scale = new Float64Array(3);
+
+/**
+ * Decompose an affine matrix into a translation and a rotation, if it is a rigid motion: affine, unit
+ * columns, perpendicular columns, no reflection.
+ *
+ * What a `TransformedShape3D` wrapper is when it only moves its subject. The physics narrowphase asks
+ * this to collide a rigidly wrapped mesh where it sits, and the shape record asks it to pack a rigidly
+ * wrapped primitive with a pose rather than refuse it. A matrix that scales, shears, mirrors or projects
+ * is no such thing.
+ *
+ * The test is per column, within {@link RIGID_TOLERANCE}; a reflection fails it as a negative x scale,
+ * which is how {@link m4_decompose_array} folds it. Contrast {@link m4_rigidity_defect}, which measures
+ * orthonormality alone and reads a reflection as rigid.
+ *
+ * Nothing is allocated. `m4` may be either destination.
+ *
+ * @param {ArrayLike<number>} m4 column-major, 16 elements
+ * @param {number[]|Float32Array|Float64Array} translation receives `[x, y, z]`
+ * @param {number} translation_offset
+ * @param {number[]|Float32Array|Float64Array} rotation receives a unit quaternion `[x, y, z, w]`
+ * @param {number} rotation_offset
+ * @returns {boolean} whether `m4` is a rigid motion; both destinations are untouched when it is not
+ */
+export function m4_decompose_rigid_array(m4, translation, translation_offset, rotation, rotation_offset) {
+    if (m4[3] !== 0 || m4[7] !== 0 || m4[11] !== 0 || m4[15] !== 1) {
+        return false;
+    }
+
+    // a reflection comes back as a negative x scale, so it fails here too
+    m4_decompose_array(m4, scratch_translation, 0, scratch_rotation, 0, scratch_scale, 0);
+
+    if (Math.abs(scratch_scale[0] - 1) > RIGID_TOLERANCE
+        || Math.abs(scratch_scale[1] - 1) > RIGID_TOLERANCE
+        || Math.abs(scratch_scale[2] - 1) > RIGID_TOLERANCE) {
+        return false;
+    }
+
+    // the decomposition assumes no shear; a sheared matrix has unit columns that are not perpendicular
+    const d01 = m4[0] * m4[4] + m4[1] * m4[5] + m4[2] * m4[6];
+    const d02 = m4[0] * m4[8] + m4[1] * m4[9] + m4[2] * m4[10];
+    const d12 = m4[4] * m4[8] + m4[5] * m4[9] + m4[6] * m4[10];
+
+    // written as "within", so a NaN column is refused here
+    const perpendicular = Math.abs(d01) <= RIGID_TOLERANCE
+        && Math.abs(d02) <= RIGID_TOLERANCE
+        && Math.abs(d12) <= RIGID_TOLERANCE;
+
+    if (!perpendicular) {
+        return false;
+    }
+
+    translation[translation_offset] = scratch_translation[0];
+    translation[translation_offset + 1] = scratch_translation[1];
+    translation[translation_offset + 2] = scratch_translation[2];
+
+    rotation[rotation_offset] = scratch_rotation[0];
+    rotation[rotation_offset + 1] = scratch_rotation[1];
+    rotation[rotation_offset + 2] = scratch_rotation[2];
+    rotation[rotation_offset + 3] = scratch_rotation[3];
+
+    return true;
+}

package/src/core/geom/3d/shape/PosedShape3D.d.ts

@@ -82,6 +82,16 @@ export class PosedShape3D extends AbstractShape3D {
      * @returns {number}
      */
     signed_distance_at_point(point: number[] | Float32Array | Float64Array): number;
+    /**
+     * Signed distance and its gradient at a WORLD-space point. The distance is the local shape's, as in
+     * {@link signed_distance_at_point}; the gradient is the local shape's turned back into the world by
+     * the pose's rotation, which keeps it unit. The position does not enter a direction.
+     *
+     * @param {number[]|Float32Array|Float64Array} result out: world-space gradient, length 3
+     * @param {number[]|Float32Array|Float64Array} point  world-space, length 3
+     * @returns {number}
+     */
+    signed_distance_gradient_at_point(result: number[] | Float32Array | Float64Array, point: number[] | Float32Array | Float64Array): number;
     /**
      * Whether a WORLD-space point lies inside the posed shape.
      *

package/src/core/geom/3d/shape/PosedShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PosedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PosedShape3D.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAEI,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CAClB;IAEb,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IAEP;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAe1D;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBATW,eAAe,MACf,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAMhB;IAED;;;;;;;OAOG;IACH,kBAJW,eAAe,QACf,MAAM,EAAE,GAAC,YAAY,eACrB,MAAM,QAOhB;IAwID,wCASC;IA4BD;;;;;;;OAOG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,CAKlB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,OAAO,CAKnB;IAED;;;;;;;OAOG;IACH,cAHW,YAAY,GACV,OAAO,CAoBnB;IAiBL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;gCApV+B,sBAAsB"}
+{"version":3,"file":"PosedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/PosedShape3D.js"],"names":[],"mappings":"AAiBA;;;;;;;;;;;;;;;;;;;GAmBG;AACH;IAEI,mCAAmC;IACnC,OADW,eAAe,GAAC,IAAI,CAClB;IAEb,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IACP,WAAO;IAgBP;;;;;;;OAOG;IACH,aAJW,eAAe,YACf,UAAQ;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,YACpC,aAAW;QAAC,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAC;QAAA,CAAC,EAAC,MAAM,CAAA;KAAC,QAe1D;IAED;;;;;;;;;;;;;;;OAeG;IACH,wBATW,eAAe,MACf,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,QAMhB;IAED;;;;;;;OAOG;IACH,kBAJW,eAAe,QACf,MAAM,EAAE,GAAC,YAAY,eACrB,MAAM,QAOhB;IAsID,wCASC;IAiCD;;;;;;;OAOG;IACH,gCAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,CAIlB;IAED;;;;;;;;OAQG;IACH,0CAJW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,SAClC,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,MAAM,CAelB;IAED;;;;;OAKG;IACH,sBAHW,MAAM,EAAE,GAAC,YAAY,GAAC,YAAY,GAChC,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,cAHW,YAAY,GACV,OAAO,CAoBnB;IAiBL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;;CAPpC;gCA3X+B,sBAAsB"}

package/src/core/geom/3d/shape/PosedShape3D.js

@@ -48,6 +48,20 @@ export class PosedShape3D extends AbstractShape3D {
     qz = 0;
     qw = 1;
 
+    /**
+     * The body-frame point a point query hands the shape. This instance's own, not shared with every
+     * posed shape: it is live across the call to the shape, and a posed shape below this one — under a
+     * union, say — would write its own point over it while the union still had children to ask.
+     * @type {Float64Array}
+     */
+    #local_point = new Float64Array(3);
+
+    /**
+     * The body-frame ray {@link raycast} hands the shape, this instance's own for the same reason.
+     * @type {Ray3}
+     */
+    #local_ray = new Ray3();
+
     /**
      * Bind a shape and a world pose. Subsequent calls to {@link support} and
      * {@link compute_bounding_box} return results in world space.
@@ -220,9 +234,7 @@ export class PosedShape3D extends AbstractShape3D {
 
         const qx = this.qx, qy = this.qy, qz = this.qz, qw = this.qw;
 
-        // Allocated per call rather than kept as a module scratch: a posed shape may wrap another
-        // wrapper, and every level of that recursion needs its own sub-ray alive across the call below.
-        const local_ray = new Ray3();
+        const local_ray = this.#local_ray;
 
         v3_quaternion_apply_inverse(local_ray, 0, ray[0] - this.px, ray[1] - this.py, ray[2] - this.pz, qx, qy, qz, qw);
         v3_quaternion_apply_inverse(local_ray, 3, ray[3], ray[4], ray[5], qx, qy, qz, qw);
@@ -256,9 +268,10 @@ export class PosedShape3D extends AbstractShape3D {
     /**
      * Transform a world-space point into the body frame (inverse rigid pose:
      * translate by −position, rotate by the conjugate quaternion) and write it
-     * into {@link scratch_local}. Shared by the point-query adapters below.
+     * into {@link #local_point}. Shared by the point-query adapters below.
      *
      * @param {number[]|Float32Array|Float64Array} point  world-space, length 3
+     * @returns {Float64Array} {@link #local_point}
      */
     #world_point_to_local(point) {
         const dx = point[0] - this.px;
@@ -274,9 +287,13 @@ export class PosedShape3D extends AbstractShape3D {
         const tz = qw * dz - qx * dy + qy * dx;
         const tw = qx * dx + qy * dy + qz * dz;
 
-        scratch_local[0] = tx * qw + tw * qx + ty * qz - tz * qy;
-        scratch_local[1] = ty * qw + tw * qy + tz * qx - tx * qz;
-        scratch_local[2] = tz * qw + tw * qz + tx * qy - ty * qx;
+        const local_point = this.#local_point;
+
+        local_point[0] = tx * qw + tw * qx + ty * qz - tz * qy;
+        local_point[1] = ty * qw + tw * qy + tz * qx - tx * qz;
+        local_point[2] = tz * qw + tw * qz + tx * qy - ty * qx;
+
+        return local_point;
     }
 
     /**
@@ -288,8 +305,31 @@ export class PosedShape3D extends AbstractShape3D {
      * @returns {number}
      */
     signed_distance_at_point(point) {
-        this.#world_point_to_local(point);
-        return this.shape.signed_distance_at_point(scratch_local);
+        return this.shape.signed_distance_at_point(this.#world_point_to_local(point));
+    }
+
+    /**
+     * Signed distance and its gradient at a WORLD-space point. The distance is the local shape's, as in
+     * {@link signed_distance_at_point}; the gradient is the local shape's turned back into the world by
+     * the pose's rotation, which keeps it unit. The position does not enter a direction.
+     *
+     * @param {number[]|Float32Array|Float64Array} result out: world-space gradient, length 3
+     * @param {number[]|Float32Array|Float64Array} point  world-space, length 3
+     * @returns {number}
+     */
+    signed_distance_gradient_at_point(result, point) {
+        const local_point = this.#world_point_to_local(point);
+
+        // The shape answers into this instance's own point, which it has finished reading by then.
+        const distance = this.shape.signed_distance_gradient_at_point(local_point, local_point);
+
+        v3_quaternion_apply(
+            result, 0,
+            local_point[0], local_point[1], local_point[2],
+            this.qx, this.qy, this.qz, this.qw
+        );
+
+        return distance;
     }
 
     /**
@@ -299,8 +339,7 @@ export class PosedShape3D extends AbstractShape3D {
      * @returns {boolean}
      */
     contains_point(point) {
-        this.#world_point_to_local(point);
-        return this.shape.contains_point(scratch_local);
+        return this.shape.contains_point(this.#world_point_to_local(point));
     }
 
     /**

package/src/core/geom/3d/shape/TransformedShape3D.d.ts

@@ -1,3 +1,11 @@
+/**
+ * Everything a wrapper hands its subject — a point, a direction, a box, a ray — is the wrapper's OWN
+ * array, allocated with it, never one shared by every instance. A shared one is live across the call to
+ * the subject, and the subject may hold another wrapper: under a union, the first child's wrapper wrote
+ * its own point over the one its siblings were still to be asked about, and a wrapped union of two
+ * wrapped unit spheres answered 1.024 for a distance of 0.118. Only a cycle, which no shape can answer
+ * anyway, re-enters the same instance, so one array per instance is never in use twice.
+ */
 export class TransformedShape3D extends AbstractShape3D {
     /**
      *
@@ -43,6 +51,35 @@ export class TransformedShape3D extends AbstractShape3D {
      * @private
      */
     private __subject;
+    /**
+     * The subject-frame point a query hands the subject, and what the subject answers into it. In
+     * double precision, as everything that passes through it: the subject's support point goes
+     * through here on its way into this frame, and in float32 a support a metre out was rounded by
+     * 6e-8 m and one 1e3 m out by 6e-5 m — support planes that overstated the gap, so a cast parked
+     * closer than its 1e-5 m, or stopped early.
+     * @type {Float64Array}
+     * @private
+     */
+    private __subject_point;
+    /**
+     * The subject-frame query direction {@link support} hands its subject.
+     * @type {Float64Array}
+     * @private
+     */
+    private __subject_direction;
+    /**
+     * The subject's box in {@link compute_bounding_box}. In double precision, as the array each call
+     * once allocated held it.
+     * @type {Float64Array}
+     * @private
+     */
+    private __subject_box;
+    /**
+     * The subject-frame ray {@link raycast} hands its subject.
+     * @type {Ray3}
+     * @private
+     */
+    private __subject_ray;
     /**
      *
      * @returns {AbstractShape3D|null}

package/src/core/geom/3d/shape/TransformedShape3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AA4CA;IAuCI;;;;;OAKG;IACH,wBAHW,eAAe,MADf,MAAM,EAAE,GAAC,YAAY,OAAK,GAExB,kBAAkB,CAS9B;IAED;;;;;OAKG;IACH,uCAJW,eAAe,eACf,MAAM,EAAE,SACR,MAAM,EAAE,sBAiBlB;IAED;;;;OAIG;IACH,iCAHW,eAAe,eACf,MAAM,EAAE,sBAIlB;IAED;;;;;OAKG;IACH,2BAHW,eAAe,SACf,MAAM,EAAE,GAAC,YAAY,OAAK,GAFxB,kBAAkB,CAM9B;IA7FD;;;;OAIG;IACH,iBAAgC;IAEhC;;;OAGG;IACH,yBAAwC;IAExC;;;;OAIG;IACH,kBAAiB;IAEjB;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,+BAIC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;;;OAOG;IACH,sCAEC;IAUD,wCASC;IAED,mEAyDC;IAED,6CAEC;IAED,oCAKC;IAED,kFAIC;IAED,sFAiDC;IAuGD;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;IAQL;;;;;OAKG;IACH,+BAFU,OAAO,CAEgC;CARhD;gCAra+B,sBAAsB"}
+{"version":3,"file":"TransformedShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/TransformedShape3D.js"],"names":[],"mappings":"AAkBA;;;;;;;GAOG;AACH;IAwEI;;;;;OAKG;IACH,wBAHW,eAAe,MADf,MAAM,EAAE,GAAC,YAAY,OAAK,GAExB,kBAAkB,CAS9B;IAED;;;;;OAKG;IACH,uCAJW,eAAe,eACf,MAAM,EAAE,SACR,MAAM,EAAE,sBAiBlB;IAED;;;;OAIG;IACH,iCAHW,eAAe,eACf,MAAM,EAAE,sBAIlB;IAED;;;;;OAKG;IACH,2BAHW,eAAe,SACf,MAAM,EAAE,GAAC,YAAY,OAAK,GAFxB,kBAAkB,CAM9B;IA9HD;;;;OAIG;IACH,iBAAgC;IAEhC;;;OAGG;IACH,yBAAwC;IAExC;;;;OAIG;IACH,kBAAiB;IAEjB;;;;;;;;OAQG;IACH,wBAAsC;IAEtC;;;;OAIG;IACH,4BAA0C;IAE1C;;;;;OAKG;IACH,sBAAoC;IAEpC;;;;OAIG;IACH,sBAA2B;IAE3B;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,+BAIC;IAED;;OAEG;IACH,8BAEC;IAED;;;;;;;OAOG;IACH,sCAEC;IAYD,wCASC;IAED,mEA2DC;IAED,6CAGC;IAED,oCAOC;IAED,kFAMC;IAED,sFAmDC;IAqGD;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;IAQL;;;;;OAKG;IACH,+BAFU,OAAO,CAEgC;CARhD;gCA7b+B,sBAAsB"}