@woosh/meep-engine 3.38.0 → 3.40.0

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

@@ -63,6 +63,15 @@ export class PosedShape3D extends AbstractShape3D {
      * @param {number} qw
      */
     setup_components(shape: AbstractShape3D, px: number, py: number, pz: number, qx: number, qy: number, qz: number, qw: number): void;
+    /**
+     * The same, from a pose packed in an array, `[px, py, pz, qx, qy, qz, qw]`: a caller that cannot
+     * inline {@link setup_components} would box all seven numbers it passes.
+     *
+     * @param {AbstractShape3D} shape
+     * @param {number[]|Float64Array} pose
+     * @param {number} pose_offset
+     */
+    setup_pose(shape: AbstractShape3D, pose: number[] | Float64Array, pose_offset: number): void;
     compute_bounding_box(result: any): void;
     /**
      * Signed distance from a WORLD-space point to the posed shape's boundary.

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":"AAWA;;;;;;;;;;;;;;;;;;;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;IA+HD,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;gCAtT+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;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"}

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

@@ -9,6 +9,12 @@ import { AbstractShape3D } from "./AbstractShape3D.js";
 const scratch_local = new Float64Array(3);
 const scratch_local_aabb = new Float64Array(6);
 
+/**
+ * The body-local query direction {@link PosedShape3D#support} hands its shape.
+ * @type {Float64Array}
+ */
+const scratch_direction = new Float64Array(3);
+
 /**
  * AbstractShape3D adapter that re-frames a shape's `support` (and bounding box)
  * into world space under a rigid pose (position + unit quaternion). The
@@ -87,6 +93,21 @@ export class PosedShape3D extends AbstractShape3D {
         this.qx = qx; this.qy = qy; this.qz = qz; this.qw = qw;
     }
 
+    /**
+     * The same, from a pose packed in an array, `[px, py, pz, qx, qy, qz, qw]`: a caller that cannot
+     * inline {@link setup_components} would box all seven numbers it passes.
+     *
+     * @param {AbstractShape3D} shape
+     * @param {number[]|Float64Array} pose
+     * @param {number} pose_offset
+     */
+    setup_pose(shape, pose, pose_offset) {
+        this.shape = shape;
+        this.px = pose[pose_offset]; this.py = pose[pose_offset + 1]; this.pz = pose[pose_offset + 2];
+        this.qx = pose[pose_offset + 3]; this.qy = pose[pose_offset + 4];
+        this.qz = pose[pose_offset + 5]; this.qw = pose[pose_offset + 6];
+    }
+
     /**
      * A rigid pose is an isometry: it moves the shape without deforming it, so the volume it encloses
      * is the subject's, with nothing to re-frame. (Contrast {@link TransformedShape3D}, whose matrix
@@ -110,11 +131,11 @@ export class PosedShape3D extends AbstractShape3D {
     /**
      * @param {number[]|Float32Array|Float64Array} result
      * @param {number} result_offset
-     * @param {number} dx world-space query direction x (unit)
-     * @param {number} dy world-space query direction y
-     * @param {number} dz world-space query direction z
+     * @param {number[]|Float32Array|Float64Array} direction world-space query direction (unit), at
+     *   `direction_offset`
+     * @param {number} direction_offset
      */
-    support(result, result_offset, dx, dy, dz) {
+    support(result, result_offset, direction, direction_offset) {
         // Inline q·v·q* math: PosedShape3D.support is the hottest GJK call
         // (twice per iteration of the body-level fallback, once per
         // triangle for concave dispatch). V8 declines to inline
@@ -122,6 +143,10 @@ export class PosedShape3D extends AbstractShape3D {
         // inline here at the cost of ~7 extra lines per direction.
         // See core/geom/vec3/v3_quat3_apply.js for the canonical form
         // — this is a literal expansion of it.
+        const dx = direction[direction_offset];
+        const dy = direction[direction_offset + 1];
+        const dz = direction[direction_offset + 2];
+
         const qx = this.qx;
         const qy = this.qy;
         const qz = this.qz;
@@ -139,8 +164,13 @@ export class PosedShape3D extends AbstractShape3D {
         const ldy = tdy * qw + tdw * qy + tdz * qx - tdx * qz;
         const ldz = tdz * qw + tdw * qz + tdx * qy - tdy * qx;
 
-        // Ask the local shape for its support point in body-local space.
-        this.shape.support(scratch_local, 0, ldx, ldy, ldz);
+        // Ask the local shape for its support point in body-local space. The direction goes down in
+        // module scratch: a posed shape wrapping another reads it before it writes its own there.
+        scratch_direction[0] = ldx;
+        scratch_direction[1] = ldy;
+        scratch_direction[2] = ldz;
+
+        this.shape.support(scratch_local, 0, scratch_direction, 0);
 
         // Rotate the body-local support point back to world: v_world =
         // q · v_local · q*.

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

@@ -25,7 +25,7 @@ export class SphereShape3D extends AbstractShape3D {
      * @type {number}
      */
     radius: number;
-    support(result: any, result_offset: any, direction_x: any, direction_y: any, direction_z: any): void;
+    support(result: any, result_offset: any, direction: any, direction_offset: any): void;
     raycast(hit: any, ray: any): boolean;
     compute_bounding_box(result: any): void;
     nearest_point_on_surface(result: any, reference: any): void;

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

@@ -1 +1 @@
-{"version":3,"file":"SphereShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/SphereShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH;IAOI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,aAAa,CAMzB;IAfD;;;OAGG;IACH,QAFU,MAAM,CAEL;IAuBX,qGAQC;IAED,qCAYC;IAED,wCAQC;IAED,4DAaC;IAED,mEAEC;IAED,6CAEC;IAED,oCAOC;IAED,kFAMC;IAED,4BAEC;IAOL;;;;;;;;OAQG;IACH,0BAFU,OAAO,CAEsB;CAXtC;gCA/H+B,sBAAsB"}
+{"version":3,"file":"SphereShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/SphereShape3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;GAcG;AACH;IAOI;;;;OAIG;IACH,oBAHW,MAAM,GACJ,aAAa,CAMzB;IAfD;;;OAGG;IACH,QAFU,MAAM,CAEL;IAuBX,sFAYC;IAED,qCAYC;IAED,wCAQC;IAED,4DAaC;IAED,mEAEC;IAED,6CAEC;IAED,oCAOC;IAED,kFAMC;IAED,4BAEC;IAOL;;;;;;;;OAQG;IACH,0BAFU,OAAO,CAEsB;CAXtC;gCAnI+B,sBAAsB"}

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

@@ -48,10 +48,14 @@ export class SphereShape3D extends AbstractShape3D {
         return 4 * Math.PI * r * r;
     }
 
-    support(result, result_offset, direction_x, direction_y, direction_z) {
+    support(result, result_offset, direction, direction_offset) {
         // Farthest point along `direction` on a sphere of this radius. Matches
         // the unit-sphere convention (no normalisation — callers pass a unit
         // direction); for radius r it is simply the direction scaled by r.
+        const direction_x = direction[direction_offset];
+        const direction_y = direction[direction_offset + 1];
+        const direction_z = direction[direction_offset + 2];
+
         const r = this.radius;
         result[result_offset] = direction_x * r;
         result[result_offset + 1] = direction_y * r;

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

@@ -27,14 +27,13 @@ export class TransformedShape3D extends AbstractShape3D {
      */
     static from_scale(subject: AbstractShape3D, scale: number[] | Float32Array | vec3): TransformedShape3D;
     /**
-     *
-     * @type {number[]|Float32Array|mat4}
+     * In double precision, as the points and supports mapped through it are.
+     * @type {Float64Array}
      * @private
      */
     private __matrix;
     /**
-     *
-     * @type {Float32Array|mat4}
+     * @type {Float64Array}
      * @private
      */
     private __inverse_matrix;
@@ -51,25 +50,28 @@ export class TransformedShape3D extends AbstractShape3D {
     get subject(): AbstractShape3D;
     /**
      *
-     * @param {number[]|Float32Array} m
+     * @param {number[]|Float32Array|Float64Array} m
+     */
+    set transform(m: Float64Array);
+    /**
+     * @returns {Float64Array}
      */
-    set transform(m: Float32Array | number[]);
-    get transform(): Float32Array | number[];
+    get transform(): Float64Array;
     /**
      * The inverse of {@link transform}, kept in step with it by the setter. Exposed because the
      * operations that map a WORLD query into the subject's frame — the ray refinement in the
      * physics narrowphase — need it, and re-inverting a 4x4 per query to recover something already
      * stored is pure waste.
      *
-     * @returns {Float32Array|mat4}
+     * @returns {Float64Array}
      */
-    get inverse_transform(): any;
+    get inverse_transform(): Float64Array;
     compute_bounding_box(result: any): void;
     signed_distance_gradient_at_point(result: any, point: any): number;
     signed_distance_at_point(point: any): number;
     contains_point(point: any): boolean;
     sample_random_point_in_volume(result: any, result_offset: any, random: any): void;
-    support(result: any, result_offset: any, direction_x: any, direction_y: any, direction_z: any): void;
+    support(result: any, result_offset: any, direction: any, direction_offset: any): void;
     /**
      *
      * @param {TransformedShape3D} other

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":"AAyBA;IAwCI;;;;;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;IA9FD;;;;OAIG;IACH,iBAAgC;IAEhC;;;;OAIG;IACH,yBAAwC;IAExC;;;;OAIG;IACH,kBAAiB;IAEjB;;;OAGG;IACH,+BAEC;IAqED;;;OAGG;IACH,0CAIC;IAED,yCAEC;IAED;;;;;;;OAOG;IACH,6BAEC;IAUD,wCAKC;IAED,mEAyDC;IAED,6CAEC;IAED,oCAKC;IAED,kFAIC;IAED,qGAwCC;IAuGD;;;;OAIG;IACH,cAHW,kBAAkB,GAChB,OAAO,CAOnB;IAQL;;;;;OAKG;IACH,+BAFU,OAAO,CAEgC;CARhD;gCAnY+B,sBAAsB"}
+{"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"}

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

@@ -12,31 +12,49 @@ import { Ray3 } from "../ray/Ray3.js";
 import { AbstractShape3D } from "./AbstractShape3D.js";
 
 /**
- *
- * @type {number[]|Float32Array|vec3}
+ * 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}
  */
-const scratch_v3_0 = new Float32Array(3);
+const scratch_v3_0 = new Float64Array(3);
 
 /**
- *
- * @type {Float32Array|mat4}
+ * @type {Float64Array}
  */
-const scratch_m4_0 = new Float32Array(16);
+const scratch_m4_0 = new Float64Array(16);
+
+/**
+ * The subject-frame query direction {@link TransformedShape3D#support} hands its subject.
+ * @type {Float64Array}
+ */
+const scratch_direction = new Float64Array(3);
+
+/**
+ * The subject's box in {@link TransformedShape3D#compute_bounding_box}, and the copy of it the
+ * projection reads. A wrapper nested in another is handed the outer one's `subject_box` as its result,
+ * and the projection cannot read and write one array; the copy is taken once the subject has
+ * answered, so each level is done with the first before the next writes it. In double precision, as
+ * the array each call allocated held it.
+ * @type {Float64Array}
+ */
+const subject_box = new Float64Array(6);
+const subject_box_copy = new Float64Array(6);
 
 export class TransformedShape3D extends AbstractShape3D {
     /**
-     *
-     * @type {number[]|Float32Array|mat4}
+     * In double precision, as the points and supports mapped through it are.
+     * @type {Float64Array}
      * @private
      */
-    __matrix = new Float32Array(16);
+    __matrix = new Float64Array(16);
 
     /**
-     *
-     * @type {Float32Array|mat4}
+     * @type {Float64Array}
      * @private
      */
-    __inverse_matrix = new Float32Array(16);
+    __inverse_matrix = new Float64Array(16);
 
     /**
      *
@@ -122,7 +140,7 @@ export class TransformedShape3D extends AbstractShape3D {
 
     /**
      *
-     * @param {number[]|Float32Array} m
+     * @param {number[]|Float32Array|Float64Array} m
      */
     set transform(m) {
         this.__matrix.set(m);
@@ -130,6 +148,9 @@ export class TransformedShape3D extends AbstractShape3D {
         m4_invert(this.__inverse_matrix, this.__matrix);
     }
 
+    /**
+     * @returns {Float64Array}
+     */
     get transform() {
         return this.__matrix;
     }
@@ -140,7 +161,7 @@ export class TransformedShape3D extends AbstractShape3D {
      * physics narrowphase — need it, and re-inverting a 4x4 per query to recover something already
      * stored is pure waste.
      *
-     * @returns {Float32Array|mat4}
+     * @returns {Float64Array}
      */
     get inverse_transform() {
         return this.__inverse_matrix;
@@ -155,10 +176,14 @@ export class TransformedShape3D extends AbstractShape3D {
     }
 
     compute_bounding_box(result) {
-        const tmp = [];
-        this.__subject.compute_bounding_box(tmp);
+        // No array allocated per call: a physics step asks every wrapped collider for its box at
+        // least twice (broadphase refit, the narrowphase's collider-pair test), and those arrays were
+        // 5% of a scene of 40 compound tables' step, and much of its garbage.
+        this.__subject.compute_bounding_box(subject_box);
 
-        aabb3_matrix4_project(result, tmp, this.__matrix);
+        subject_box_copy.set(subject_box);
+
+        aabb3_matrix4_project(result, subject_box_copy, this.__matrix);
     }
 
     signed_distance_gradient_at_point(result, point) {
@@ -237,7 +262,11 @@ export class TransformedShape3D extends AbstractShape3D {
         v3_matrix4_multiply(result, result_offset, scratch_v3_0, 0, this.__matrix);
     }
 
-    support(result, result_offset, direction_x, direction_y, direction_z) {
+    support(result, result_offset, direction, direction_offset) {
+        const direction_x = direction[direction_offset];
+        const direction_y = direction[direction_offset + 1];
+        const direction_z = direction[direction_offset + 2];
+
         // Support function under a 4x4 affine transform.
         //
         // For a shape S = { M·x : x ∈ subject }, the support point is
@@ -274,7 +303,12 @@ export class TransformedShape3D extends AbstractShape3D {
             ld_x *= inv; ld_y *= inv; ld_z *= inv;
         }
 
-        this.__subject.support(scratch_v3_0, 0, ld_x, ld_y, ld_z);
+        // Down in module scratch: a wrapper nested in this one reads it before it writes its own there.
+        scratch_direction[0] = ld_x;
+        scratch_direction[1] = ld_y;
+        scratch_direction[2] = ld_z;
+
+        this.__subject.support(scratch_v3_0, 0, scratch_direction, 0);
 
         v3_matrix4_multiply(result, result_offset, scratch_v3_0, 0, this.__matrix);
     }

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

@@ -57,7 +57,7 @@ export class Triangle3D extends AbstractShape3D {
      * @returns {Triangle3D} this (for chaining)
      */
     bind(buffer: Float64Array, offset: number): Triangle3D;
-    support(result: any, result_offset: any, direction_x: any, direction_y: any, direction_z: any): void;
+    support(result: any, result_offset: any, direction: any, direction_offset: any): void;
     raycast(hit: any, ray: any): boolean;
     compute_bounding_box(result: any): void;
     /**

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

@@ -1 +1 @@
-{"version":3,"file":"Triangle3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/Triangle3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA+BI;;;;;;;;;;;;;;;OAeG;IACH,gBAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAWtB;IAvDD;;;OAGG;IACH,QAFU,YAAY,GAAG,IAAI,CAEf;IAEd;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;;;OAOG;IACH,aAJW,YAAY,UACZ,MAAM,GACJ,UAAU,CAStB;IA6BD,qGAyBC;IAED,qCAuBC;IAED,wCAeC;IAED;;OAEG;IACH,qCAEC;IAED;;;;;;;;OAQG;IACH,6CA+BC;IAED,4DAeC;IAED;;;OAGG;IACH,kFAsBC;IAwBD;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAenB;IAgBL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC;gCA1S+B,sBAAsB"}
+{"version":3,"file":"Triangle3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/Triangle3D.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IA+BI;;;;;;;;;;;;;;;OAeG;IACH,gBAXW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,UAAU,CAWtB;IAvDD;;;OAGG;IACH,QAFU,YAAY,GAAG,IAAI,CAEf;IAEd;;;;OAIG;IACH,QAFU,MAAM,CAEL;IAEX;;;;;;;OAOG;IACH,aAJW,YAAY,UACZ,MAAM,GACJ,UAAU,CAStB;IA6BD,sFA6BC;IAED,qCAuBC;IAED,wCAeC;IAED;;OAEG;IACH,qCAEC;IAED;;;;;;;;OAQG;IACH,6CA+BC;IAED,4DAeC;IAED;;;OAGG;IACH,kFAsBC;IAwBD;;;OAGG;IACH,cAHW,UAAU,GACR,OAAO,CAenB;IAgBL;;;;OAIG;IACH,uBAFU,OAAO,CAEgB;CAPhC;gCA9S+B,sBAAsB"}

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

@@ -84,7 +84,11 @@ export class Triangle3D extends AbstractShape3D {
         return t;
     }
 
-    support(result, result_offset, direction_x, direction_y, direction_z) {
+    support(result, result_offset, direction, direction_offset) {
+        const direction_x = direction[direction_offset];
+        const direction_y = direction[direction_offset + 1];
+        const direction_z = direction[direction_offset + 2];
+
         const b = this.buffer;
         const o = this.offset;
 

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

@@ -35,7 +35,7 @@ export class UnionShape3D extends AbstractShape3D {
     signed_distance_at_point(point: any): number;
     contains_point(point: any): boolean;
     sample_random_point_in_volume(result: any, result_offset: any, random: any): void;
-    support(result: any, result_offset: any, direction_x: any, direction_y: any, direction_z: any): void;
+    support(result: any, result_offset: any, direction: any, direction_offset: any): void;
     /**
      *
      * @param {UnionShape3D} other

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

@@ -1 +1 @@
-{"version":3,"file":"UnionShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/UnionShape3D.js"],"names":[],"mappings":"AA4BA;IAkII;;;;OAIG;IACH,sBAHW,eAAe,EAAE,GACf,YAAY,CAYxB;IAhJD;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,kCAA+B;IAE/B,qBAAkB;IAClB,qBAAmB;IACnB,uBAAqB;IAErB,wCAgCC;IAED;;;OAGG;IACH,mCAkBC;IAED;;;OAGG;IACH,2CA+CC;IA2DD,mEAEC;IAED,6CAaC;IAED,oCAYC;IAED,kFAoDC;IAED,qGA0CC;IAiED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;IA6BL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;CApBpC;gCAra+B,sBAAsB"}
+{"version":3,"file":"UnionShape3D.d.ts","sourceRoot":"","sources":["../../../../../../src/core/geom/3d/shape/UnionShape3D.js"],"names":[],"mappings":"AAkCA;IAkII;;;;OAIG;IACH,sBAHW,eAAe,EAAE,GACf,YAAY,CAYxB;IAhJD;;;OAGG;IACH,UAFU,eAAe,EAAE,CAEb;IAEd;;;;;OAKG;IACH,kCAA+B;IAE/B,qBAAkB;IAClB,qBAAmB;IACnB,uBAAqB;IAErB,wCAgCC;IAED;;;OAGG;IACH,mCAkBC;IAED;;;OAGG;IACH,2CA+CC;IA2DD,mEAEC;IAED,6CAaC;IAED,oCAYC;IAED,kFAoDC;IAED,sFAqDC;IAiED;;;;OAIG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;IA6BL;;;;OAIG;IACH,yBAFU,OAAO,CAEoB;CApBpC;gCAtb+B,sBAAsB"}

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

@@ -26,6 +26,12 @@ const VOLUME_OVERLAP_ESTIMATION_SUB_TAPS = 4;
 
 const scratch_array = [];
 
+/**
+ * The query direction {@link UnionShape3D#support} hands each child.
+ * @type {Float64Array}
+ */
+const scratch_direction = new Float64Array(3);
+
 export class UnionShape3D extends AbstractShape3D {
     /**
      *
@@ -300,7 +306,11 @@ export class UnionShape3D extends AbstractShape3D {
         }
     }
 
-    support(result, result_offset, direction_x, direction_y, direction_z) {
+    support(result, result_offset, direction, direction_offset) {
+        const direction_x = direction[direction_offset];
+        const direction_y = direction[direction_offset + 1];
+        const direction_z = direction[direction_offset + 2];
+
         let best_distance = -Infinity;
 
         // NOTE: the winner is held in locals, not written into `result` as it is found. When this
@@ -317,7 +327,14 @@ export class UnionShape3D extends AbstractShape3D {
         for (let i = 0; i < child_count; i++) {
             const child = children[i];
 
-            child.support(scratch_array, 0, direction_x, direction_y, direction_z);
+            // Written out afresh for every child rather than passed through: a child of a wrapping
+            // class reuses its own module scratch once it has read it, and that can be this array (a
+            // union child) or `direction` itself (when this union is wrapped by the child's class).
+            scratch_direction[0] = direction_x;
+            scratch_direction[1] = direction_y;
+            scratch_direction[2] = direction_z;
+
+            child.support(scratch_array, 0, scratch_direction, 0);
 
             const x = scratch_array[0];
             const y = scratch_array[1];

package/src/core/geom/3d/shape/sdf/sdf3_box.d.ts

@@ -48,4 +48,18 @@ export function sdf3_box(x: number, y: number, z: number, half_x: number, half_y
  * @returns {number} the signed distance
  */
 export function sdf3_box_gradient(out: Float32Array | Float64Array | number[], out_offset: number, x: number, y: number, z: number, half_x: number, half_y: number, half_z: number): number;
+/**
+ * {@link sdf3_box_gradient} with the point and the box read from arrays, and the distance written
+ * after the gradient rather than returned. See `sdf3_sphere.js` for why both forms exist.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} box `[half_x, half_y, half_z]`
+ * @param {number} box_offset
+ * @returns {void}
+ */
+export function sdf3_box_gradient_array(out: Float32Array | Float64Array | number[], out_offset: number, point: Float32Array | Float64Array | number[], point_offset: number, box: Float32Array | Float64Array | number[], box_offset: number): void;
 //# sourceMappingURL=sdf3_box.d.ts.map

package/src/core/geom/3d/shape/sdf/sdf3_box.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdf3_box.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_box.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;GAUG;AACH,4BARW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;;;;;;;;GAYG;AACH,uCAVW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CA6ClB"}
+{"version":3,"file":"sdf3_box.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_box.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;;;;;;;GAUG;AACH,4BARW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;;;;;;;;GAYG;AACH,uCAVW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAkBlB;AAED;;;;;;;;;;;;GAYG;AACH,6CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAElC,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,OACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,GACJ,IAAI,CAuDhB"}

package/src/core/geom/3d/shape/sdf/sdf3_box.js

@@ -68,6 +68,45 @@ export function sdf3_box(x, y, z, half_x, half_y, half_z) {
  * @returns {number} the signed distance
  */
 export function sdf3_box_gradient(out, out_offset, x, y, z, half_x, half_y, half_z) {
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
+
+    SCALAR_SHAPE[0] = half_x;
+    SCALAR_SHAPE[1] = half_y;
+    SCALAR_SHAPE[2] = half_z;
+
+    sdf3_box_gradient_array(SCALAR_RESULT, 0, SCALAR_POINT, 0, SCALAR_SHAPE, 0);
+
+    out[out_offset] = SCALAR_RESULT[0];
+    out[out_offset + 1] = SCALAR_RESULT[1];
+    out[out_offset + 2] = SCALAR_RESULT[2];
+
+    return SCALAR_RESULT[3];
+}
+
+/**
+ * {@link sdf3_box_gradient} with the point and the box read from arrays, and the distance written
+ * after the gradient rather than returned. See `sdf3_sphere.js` for why both forms exist.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} box `[half_x, half_y, half_z]`
+ * @param {number} box_offset
+ * @returns {void}
+ */
+export function sdf3_box_gradient_array(out, out_offset, point, point_offset, box, box_offset) {
+    const x = point[point_offset];
+    const y = point[point_offset + 1];
+    const z = point[point_offset + 2];
+
+    const half_x = box[box_offset];
+    const half_y = box[box_offset + 1];
+    const half_z = box[box_offset + 2];
+
     const qx = Math.abs(x) - half_x;
     const qy = Math.abs(y) - half_y;
     const qz = Math.abs(z) - half_z;
@@ -84,8 +123,9 @@ export function sdf3_box_gradient(out, out_offset, x, y, z, half_x, half_y, half
         out[out_offset] = (x < 0 ? -ex : ex) * inverse;
         out[out_offset + 1] = (y < 0 ? -ey : ey) * inverse;
         out[out_offset + 2] = (z < 0 ? -ez : ez) * inverse;
+        out[out_offset + 3] = outside;
 
-        return outside;
+        return;
     }
 
     // Inside, or exactly on the surface. The field is `max(q)` and its gradient
@@ -97,17 +137,39 @@ export function sdf3_box_gradient(out, out_offset, x, y, z, half_x, half_y, half
 
     if (qx >= qy && qx >= qz) {
         out[out_offset] = x < 0 ? -1 : 1;
+        out[out_offset + 3] = qx;
 
-        return qx;
+        return;
     }
 
     if (qy >= qz) {
         out[out_offset + 1] = y < 0 ? -1 : 1;
+        out[out_offset + 3] = qy;
 
-        return qy;
+        return;
     }
 
     out[out_offset + 2] = z < 0 ? -1 : 1;
-
-    return qz;
+    out[out_offset + 3] = qz;
 }
+
+/**
+ * The scalar form's point, packed for the array form it delegates to.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_POINT = new Float64Array(3);
+
+/**
+ * The scalar form's `[half_x, half_y, half_z]`.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_SHAPE = new Float64Array(3);
+
+/**
+ * The scalar form's gradient and distance, as the array form writes them.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_RESULT = new Float64Array(4);

package/src/core/geom/3d/shape/sdf/sdf3_capsule.d.ts

@@ -43,4 +43,18 @@ export function sdf3_capsule(x: number, y: number, z: number, radius: number, he
  * @returns {number} the signed distance
  */
 export function sdf3_capsule_gradient(out: Float32Array | Float64Array | number[], out_offset: number, x: number, y: number, z: number, radius: number, height: number): number;
+/**
+ * {@link sdf3_capsule_gradient} with the point and the capsule read from arrays, and the distance
+ * written after the gradient rather than returned. See `sdf3_sphere.js` for why both forms exist.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} capsule `[radius, height]`
+ * @param {number} capsule_offset
+ * @returns {void}
+ */
+export function sdf3_capsule_gradient_array(out: Float32Array | Float64Array | number[], out_offset: number, point: Float32Array | Float64Array | number[], point_offset: number, capsule: Float32Array | Float64Array | number[], capsule_offset: number): void;
 //# sourceMappingURL=sdf3_capsule.d.ts.map

package/src/core/geom/3d/shape/sdf/sdf3_capsule.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"sdf3_capsule.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_capsule.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;GASG;AACH,gCAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;;;;;;;;;GAWG;AACH,2CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAwBlB"}
+{"version":3,"file":"sdf3_capsule.d.ts","sourceRoot":"","sources":["../../../../../../../src/core/geom/3d/shape/sdf/sdf3_capsule.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;;;;;;;GASG;AACH,gCAPW,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAQlB;AAED;;;;;;;;;;;GAWG;AACH,2CATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAClC,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,MAAM,CAiBlB;AAED;;;;;;;;;;;;GAYG;AACH,iDATW,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,cAElC,MAAM,SACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,gBAClC,MAAM,WACN,YAAY,GAAC,YAAY,GAAC,MAAM,EAAE,kBAClC,MAAM,GACJ,IAAI,CA+BhB"}

package/src/core/geom/3d/shape/sdf/sdf3_capsule.js

@@ -58,6 +58,43 @@ export function sdf3_capsule(x, y, z, radius, height) {
  * @returns {number} the signed distance
  */
 export function sdf3_capsule_gradient(out, out_offset, x, y, z, radius, height) {
+    SCALAR_POINT[0] = x;
+    SCALAR_POINT[1] = y;
+    SCALAR_POINT[2] = z;
+
+    SCALAR_SHAPE[0] = radius;
+    SCALAR_SHAPE[1] = height;
+
+    sdf3_capsule_gradient_array(SCALAR_RESULT, 0, SCALAR_POINT, 0, SCALAR_SHAPE, 0);
+
+    out[out_offset] = SCALAR_RESULT[0];
+    out[out_offset + 1] = SCALAR_RESULT[1];
+    out[out_offset + 2] = SCALAR_RESULT[2];
+
+    return SCALAR_RESULT[3];
+}
+
+/**
+ * {@link sdf3_capsule_gradient} with the point and the capsule read from arrays, and the distance
+ * written after the gradient rather than returned. See `sdf3_sphere.js` for why both forms exist.
+ *
+ * @param {Float32Array|Float64Array|number[]} out receives `[gx, gy, gz, distance]` at `out_offset`:
+ *   the unit outward gradient, then the signed distance
+ * @param {number} out_offset
+ * @param {Float32Array|Float64Array|number[]} point `[x, y, z]`
+ * @param {number} point_offset
+ * @param {Float32Array|Float64Array|number[]} capsule `[radius, height]`
+ * @param {number} capsule_offset
+ * @returns {void}
+ */
+export function sdf3_capsule_gradient_array(out, out_offset, point, point_offset, capsule, capsule_offset) {
+    const x = point[point_offset];
+    const y = point[point_offset + 1];
+    const z = point[point_offset + 2];
+
+    const radius = capsule[capsule_offset];
+    const height = capsule[capsule_offset + 1];
+
     const half = height * 0.5;
 
     const dy = y < -half ? y + half : (y > half ? y - half : 0);
@@ -68,8 +105,9 @@ export function sdf3_capsule_gradient(out, out_offset, x, y, z, radius, height)
         out[out_offset] = SDF3_DEGENERATE_NORMAL_X;
         out[out_offset + 1] = SDF3_DEGENERATE_NORMAL_Y;
         out[out_offset + 2] = SDF3_DEGENERATE_NORMAL_Z;
+        out[out_offset + 3] = -radius;
 
-        return -radius;
+        return;
     }
 
     const inverse = 1 / length;
@@ -77,6 +115,26 @@ export function sdf3_capsule_gradient(out, out_offset, x, y, z, radius, height)
     out[out_offset] = x * inverse;
     out[out_offset + 1] = dy * inverse;
     out[out_offset + 2] = z * inverse;
-
-    return length - radius;
+    out[out_offset + 3] = length - radius;
 }
+
+/**
+ * The scalar form's point, packed for the array form it delegates to.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_POINT = new Float64Array(3);
+
+/**
+ * The scalar form's `[radius, height]`.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_SHAPE = new Float64Array(2);
+
+/**
+ * The scalar form's gradient and distance, as the array form writes them.
+ * @type {Float64Array}
+ * @private
+ */
+const SCALAR_RESULT = new Float64Array(4);