@woosh/meep-engine 2.169.0 → 2.169.2

package/src/engine/ecs/EntityManager.d.ts

@@ -199,15 +199,15 @@ export class EntityManager {
     /**
      * @private
      * @param {System} system
-     * @param {function(system: System)} successCallback
-     * @param {function(reason:*)} errorCallback
+     * @param {(system: System) => void} successCallback
+     * @param {(reason: *) => void} errorCallback
      */
     private stopSystem;
     /**
      * @private
      * @param {System} system
-     * @param {function(system: System)} successCallback
-     * @param {function(reason:*)} errorCallback
+     * @param {(system: System) => void} successCallback
+     * @param {(reason: *) => void} errorCallback
      */
     private startSystem;
     /**

package/src/engine/ecs/EntityManager.js

@@ -633,8 +633,8 @@ export class EntityManager {
     /**
      * @private
      * @param {System} system
-     * @param {function(system: System)} successCallback
-     * @param {function(reason:*)} errorCallback
+     * @param {(system: System) => void} successCallback
+     * @param {(reason: *) => void} errorCallback
      */
     stopSystem(system, successCallback, errorCallback) {
         const self = this;
@@ -676,8 +676,8 @@ export class EntityManager {
     /**
      * @private
      * @param {System} system
-     * @param {function(system: System)} successCallback
-     * @param {function(reason:*)} errorCallback
+     * @param {(system: System) => void} successCallback
+     * @param {(reason: *) => void} errorCallback
      */
     startSystem(system, successCallback, errorCallback) {
         assert.defined(system, "system");

package/src/engine/ecs/EntityObserver.d.ts

@@ -10,12 +10,12 @@ export class EntityObserver {
     /**
      *
      * @param {Array} componentTypes
-     * @param {function(components:Array)} completedCallback
-     * @param {function(components:Array)} brokenCallback
+     * @param {(components: Array) => void} completedCallback
+     * @param {(components: Array) => void} brokenCallback
      * @param {*} [thisArg=undefined] will assume {@link this} value inside callbacks
      * @constructor
      */
-    constructor(componentTypes: any[], completedCallback: any, brokenCallback: any, thisArg?: any);
+    constructor(componentTypes: any[], completedCallback: (components: any[]) => void, brokenCallback: (components: any[]) => void, thisArg?: any);
     /**
      *
      * @type {BitSet}

package/src/engine/ecs/EntityObserver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"EntityObserver.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityObserver.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAoBI;;;;;;;OAOG;IACH,+FA4CC;IAvED;;;OAGG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,uBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,SAFU,yBAAuB,IAAI,CAEtB;IA0BX;;OAEG;IACH,oBAFU,MAAM,CAE2B;IAE3C;;;OAGG;IACH,uCAAyC;IAEzC;;;OAGG;IACH,qCAAoC;IAEpC;;;OAGG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,aAAsB;IAG1B;;;OAGG;IACH,qCAqBC;IAED;;;OAGG;IACH,+CAMC;IAED;;;OAGG;IACH,2BAEC;IAED;;OAEG;IACH,mBAQC;CACJ;uBA/IsB,6BAA6B"}
+{"version":3,"file":"EntityObserver.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/EntityObserver.js"],"names":[],"mappings":"AAGA;;;;;;;GAOG;AACH;IAoBI;;;;;;;OAOG;IACH,6EALkC,IAAI,yCACJ,IAAI,iBAgDrC;IAvED;;;OAGG;IACH,eAFU,MAAM,CAEa;IAE7B;;;;OAIG;IACH,uBAFU,MAAM,EAAE,CAES;IAE3B;;;OAGG;IACH,SAFU,yBAAuB,IAAI,CAEtB;IA0BX;;OAEG;IACH,oBAFU,MAAM,CAE2B;IAE3C;;;OAGG;IACH,uCAAyC;IAEzC;;;OAGG;IACH,qCAAoC;IAEpC;;;OAGG;IACH,sBAAoC;IAEpC;;;OAGG;IACH,aAAsB;IAG1B;;;OAGG;IACH,qCAqBC;IAED;;;OAGG;IACH,+CAMC;IAED;;;OAGG;IACH,2BAEC;IAED;;OAEG;IACH,mBAQC;CACJ;uBA/IsB,6BAA6B"}

package/src/engine/ecs/EntityObserver.js

@@ -32,8 +32,8 @@ export class EntityObserver {
     /**
      *
      * @param {Array} componentTypes
-     * @param {function(components:Array)} completedCallback
-     * @param {function(components:Array)} brokenCallback
+     * @param {(components: Array) => void} completedCallback
+     * @param {(components: Array) => void} brokenCallback
      * @param {*} [thisArg=undefined] will assume {@link this} value inside callbacks
      * @constructor
      */

package/src/engine/ecs/System.d.ts

@@ -139,17 +139,17 @@ export class System<C> {
     /**
      * Fixed update function, every step happens with the same exact time increment
      * useful for systems that must have a fixed time step to be predictable and stable, such as physics
-     * @type {function(time_delta_seconds:number)} time delta will always be the same value, controlled via {@link EntityManager.fixedUpdateStepSize}
+     * @type {(time_delta_seconds: number) => void} time delta will always be the same value, controlled via {@link EntityManager.fixedUpdateStepSize}
      */
-    fixedUpdate: (arg0: time_delta_seconds) => number;
+    fixedUpdate: (time_delta_seconds: number) => void;
     /**
      * This update is generally synchronized with the render loop.
      * Note that this time step can vary depending on system conditions and hardware we are running on.
      * It is generally safe to assume that this update will happen once per frame, but it is not guaranteed.
      * Also, note that when the application window/tab is suspended, the next update step can have a very large value.
-     * @type {function(time_delta_seconds:number)}
+     * @type {(time_delta_seconds: number) => void}
      */
-    update: (arg0: time_delta_seconds) => number;
+    update: (time_delta_seconds: number) => void;
 }
 export type SystemState = number;
 export namespace SystemState {

package/src/engine/ecs/System.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,uCAAqB;IAErB;;;;OAIG;IACH,oBAA+C;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,6BAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uCAHa,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wCAHa,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,2CAFsC,MAAM,CAEhB;IAG5B;;;;;;OAMG;IACH,sCAFsC,MAAM,CAErB;CAvBtB;0BA2BS,MAAM"}
+{"version":3,"file":"System.d.ts","sourceRoot":"","sources":["../../../../src/engine/ecs/System.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6BG;AACH;IAEI;;;;;OAKG;IACH,uCAAqB;IAErB;;;;OAIG;IACH,oBAA+C;IAE/C;;;;;;;;;OASG;IACH,6BAAkB;IAElB;;;;;;;;;;OAUG;IACH,0BAFU,6BAA6B,CAElB;IAGrB;;OAEG;IACH,mCAcC;IAED;;;;;OAKG;IACH,oCAFY,MAAM,CA8BjB;IAED;;;;;;OAMG;IACH,uCAHa,QAAQ,IAAI,CAAC,CAKzB;IAED;;;;;;;OAOG;IACH,wCAHa,QAAQ,IAAI,CAAC,CAKzB;IAGD;;;;;OAKG;IACH,wCAEC;IAED;;;;;OAKG;IACH,0CAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAED;;;;;;;;;;OAUG;IACH,6DAEC;IAIL;;;OAGG;IACH,mBAFU,OAAO,CAEQ;IAEzB;;;;OAIG;IACH,kDAA4B;IAG5B;;;;;;OAMG;IACH,6CAAuB;CAvBtB;0BA2BS,MAAM"}

package/src/engine/ecs/System.js

@@ -217,7 +217,7 @@ System.prototype.isSystem = true;
 /**
  * Fixed update function, every step happens with the same exact time increment
  * useful for systems that must have a fixed time step to be predictable and stable, such as physics
- * @type {function(time_delta_seconds:number)} time delta will always be the same value, controlled via {@link EntityManager.fixedUpdateStepSize}
+ * @type {(time_delta_seconds: number) => void} time delta will always be the same value, controlled via {@link EntityManager.fixedUpdateStepSize}
  */
 System.prototype.fixedUpdate = noop; // by assigning NO-OP we enable a simple check, whether running the update would be useful
 
@@ -227,7 +227,7 @@ System.prototype.fixedUpdate = noop; // by assigning NO-OP we enable a simple ch
  * Note that this time step can vary depending on system conditions and hardware we are running on.
  * It is generally safe to assume that this update will happen once per frame, but it is not guaranteed.
  * Also, note that when the application window/tab is suspended, the next update step can have a very large value.
- * @type {function(time_delta_seconds:number)}
+ * @type {(time_delta_seconds: number) => void}
  */
 System.prototype.update = noop; // by assigning NO-OP we enable a simple check, whether running the update would be useful
 

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.d.ts

@@ -91,12 +91,12 @@ export class DynamicActorSystem extends AbstractContextSystem<any> {
      * Useful for picking an actor for a response action
      *
      * @param {Object} context
-     * @param {function(entity:number,dataset:EntityComponentDataset):} [filter]
+     * @param {(entity: number, dataset: EntityComponentDataset) => void} [filter]
      * @param {*} [filterContext]
      * @param {number} [count]
      * @returns {{entity:number,rule:DynamicRuleDescription, scope: DataScope}[]}
      */
-    requestBestActors(context: any, filter?: typeof returnTrue, filterContext?: any, count?: number): {
+    requestBestActors(context: any, filter?: (entity: number, dataset: EntityComponentDataset) => void, filterContext?: any, count?: number): {
         entity: number;
         rule: DynamicRuleDescription;
         scope: DataScope;
@@ -124,5 +124,4 @@ import { DynamicActor } from "./DynamicActor.js";
 import { Blackboard } from "../../intelligence/blackboard/Blackboard.js";
 import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessSpecification.js";
 import { DataScope } from "./DataScope.js";
-import { returnTrue } from "../../../core/function/returnTrue.js";
 //# sourceMappingURL=DynamicActorSystem.d.ts.map

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AA6FA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,yFAHW,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAtkBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB;2BAnBf,sCAAsC"}
+{"version":3,"file":"DynamicActorSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/dynamic_actions/DynamicActorSystem.js"],"names":[],"mappings":"AA6FA;IA4DI;;;OAGG;IACH,4BASC;IAxED,sCAA8B;IAE9B,kEAEE;IAEF;;;OAGG;IACH,sCAAgB;IAEhB;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;;OAIG;IACH,iCAOG;IAEH;;;;OAIG;IACH,gCAAoC;IAEpC;;;OAGG;IACH,mCAAiB;IAEjB;;;;OAIG;IACH,uBAAmB;IAEnB;;;;OAIG;IACH,gBAAgB;IASZ;;;OAGG;IACH,eAAoB;IAIxB;;;OAGG;IACH,kBAFY,MAAM,CAIjB;IAED;;;;;OAKG;IACH,6BAJW,MAAM,uDAyBhB;IAED;;;OAGG;IACH,iCAFW,MAAM,QAehB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,oDA4DhB;IAED;;;;OAIG;IACH,4BAHW,MAAM,SACN,SAAS,QAsDnB;IAED;;;;OAIG;IACH,yBAFY,yBAAuB,SAAS,CA6E3C;IAED;;;;;;;;;OASG;IACH,kDALoB,MAAM,sCAAsC,IAAI,+BAEzD,MAAM,GACJ;QAAC,MAAM,EAAC,MAAM,CAAC;QAAA,IAAI,yBAAwB;QAAC,KAAK,EAAE,SAAS,CAAA;KAAC,EAAE,CA4E3E;IAED;;;;;;OAMG;IACH,cALW,MAAM,SACN,MAAM,iBAEJ,yBAAuB,SAAS,CAiC5C;IAED,2CAQC;IAED;;;;;OAKG;IACH,mCAiBC;IAED,6BAYC;CACJ;sCAtkBqC,oCAAoC;6BAG7C,mBAAmB;2BATrB,6CAA6C;4CAP5B,oDAAoD;0BAetE,gBAAgB"}

package/src/engine/ecs/dynamic_actions/DynamicActorSystem.js

@@ -432,7 +432,7 @@ export class DynamicActorSystem extends AbstractContextSystem {
      * Useful for picking an actor for a response action
      *
      * @param {Object} context
-     * @param {function(entity:number,dataset:EntityComponentDataset):} [filter]
+     * @param {(entity: number, dataset: EntityComponentDataset) => void} [filter]
      * @param {*} [filterContext]
      * @param {number} [count]
      * @returns {{entity:number,rule:DynamicRuleDescription, scope: DataScope}[]}

package/src/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"WeightedRandomActionDescription.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,UAFU,gBAAgB,yBAAyB,CAAC,EAAE,CAExC;IAEd,qFAsBC;IAED;;;;OAIG;IACH,mBAHW,yBAAyB,UACzB,MAAM,QAQhB;CACJ;0CA9CyC,gCAAgC;gCAF1C,+DAA+D;uCACxD,sEAAsE"}
+{"version":3,"file":"WeightedRandomActionDescription.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js"],"names":[],"mappings":"AAKA;IAEI;;;OAGG;IACH,UAFU,gBAAgB,yBAAyB,CAAC,EAAE,CAExC;IAEd,qFA2BC;IAED;;;;OAIG;IACH,mBAHW,yBAAyB,UACzB,MAAM,QAQhB;CACJ;0CAnDyC,gCAAgC;gCAF1C,+DAA+D;uCACxD,sEAAsE"}

package/src/engine/ecs/dynamic_actions/actions/definition/WeightedRandomActionDescription.js

@@ -28,6 +28,11 @@ export class WeightedRandomActionDescription extends AbstractActionDescription {
         // remix actor entity index to produce large difference for small entity ID differences
         const actor_seed = (actor >> 16) | (actor << 16);
 
+        // DETERMINISM HOLE: this Math.random() seeds an AI behaviour tree, so the same world state can
+        // produce different AI decisions across runs -- defeating replay, rewind and action-log
+        // replication. It cannot be removed on its own: without it every invocation for a given actor
+        // would return an identical sequence. The fix is to draw from a run-level seeded stream, which
+        // has to be threaded down to here first (see MarkerNodeActionSelectWeighted for the pattern).
         const seed = actor_seed ^ computeHashFloat(Math.random());
 
         b.setRandomSeed(seed);

package/src/engine/ecs/evaluation/complex/PointFitnessGaussianBlur.d.ts

@@ -1,11 +1,23 @@
+/**
+ * Blurs another {@link PointFitnessFunction} by sampling it over an axis-aligned box centred on the
+ * query point and weighting the samples with a separable 3D gaussian.
+ *
+ * Sampling convention (shared with {@link CellFilterGaussianBlur}): the taps are centred on
+ * `(samples-1)/2` and spaced `size/(samples-1)` apart, so the outermost taps land exactly on the
+ * faces of the box and the tap pattern is symmetric about the query point.
+ *
+ * An axis with a zero `size` still gets its (minimum) taps, but they all land on the query point,
+ * so the axis contributes a constant factor that cancels in the normalisation — i.e. a `size_z` of
+ * 0 gives a plain 2D blur.
+ */
 export class PointFitnessGaussianBlur extends PointFitnessFunction {
     /**
      *
      * @param {PointFitnessFunction} source
-     * @param {number} x
+     * @param {number} x size of the blur box along X, in world units
      * @param {number} y
      * @param {number} z
-     * @param {number} [quality]
+     * @param {number} [quality] taps per world unit along each axis
      * @returns {PointFitnessGaussianBlur}
      */
     static from(source: PointFitnessFunction, x: number, y: number, z: number, quality?: number): PointFitnessGaussianBlur;
@@ -18,6 +30,14 @@ export class PointFitnessGaussianBlur extends PointFitnessFunction {
     size_x: number;
     size_y: number;
     size_z: number;
+    /**
+     * Taps per world unit that {@link samples_x}/{@link samples_y}/{@link samples_z} were derived
+     * from. Kept only so the derivation can be reproduced (serialization records the box size and
+     * the quality, not the resulting tap counts); {@link evaluate} reads the sample counts.
+     *
+     * @type {number}
+     */
+    quality: number;
     /**
      *
      * @type {PointFitnessFunction}

package/src/engine/ecs/evaluation/complex/PointFitnessGaussianBlur.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PointFitnessGaussianBlur.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/evaluation/complex/PointFitnessGaussianBlur.js"],"names":[],"mappings":"AAIA;IAwBI;;;;;;;;OAQG;IACH,oBAPW,oBAAoB,KACpB,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,GACJ,wBAAwB,CAwBpC;IAnDG,kBAAkB;IAClB,kBAAkB;IAClB,kBAAkB;IAElB,gBAAiB;IACjB,gBAAiB;IACjB,gBAAiB;IAGjB,eAAe;IACf,eAAe;IACf,eAAe;IAEf;;;OAGG;IACH,QAFU,oBAAoB,CAEZ;IAoCtB,mDA4DC;IAGL,aAAuC;CAFtC;qCA1HoC,4BAA4B"}
+{"version":3,"file":"PointFitnessGaussianBlur.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/evaluation/complex/PointFitnessGaussianBlur.js"],"names":[],"mappings":"AAiCA;;;;;;;;;;;GAWG;AACH;IA6BI;;;;;;;;OAQG;IACH,oBAPW,oBAAoB,KACpB,MAAM,KACN,MAAM,KACN,MAAM,YACN,MAAM,GACJ,wBAAwB,CA8BpC;IAhED,kBAAc;IACd,kBAAc;IACd,kBAAc;IAEd,gBAAwB;IACxB,gBAAwB;IACxB,gBAAwB;IAExB,eAAW;IACX,eAAW;IACX,eAAW;IAEX;;;;;;OAMG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,QAFU,oBAAoB,CAEhB;IAyCd,mDA2DC;IAGL,aAAuC;CAFtC;qCA7KoC,4BAA4B"}

package/src/engine/ecs/evaluation/complex/PointFitnessGaussianBlur.js

@@ -1,38 +1,84 @@
 import { PointFitnessFunction } from "../PointFitnessFunction.js";
 import { assert } from "../../../../core/assert.js";
 import { gaussian } from "../../../../core/math/gaussian.js";
+import { max2 } from "../../../../core/math/max2.js";
+import { nextOdd } from "../../../../core/math/nextOdd.js";
+
+/**
+ * Number of taps to spread across one axis of the blur box.
+ *
+ * Forced odd so a tap lands exactly on the centre, and to at least 3 so the axis is actually
+ * sampled either side of centre. Matches {@link CellFilterGaussianBlur.from}.
+ *
+ * @param {number} extent size of the blur box along this axis, in world units
+ * @param {number} quality taps per world unit
+ * @returns {number} odd integer, at least 3
+ */
+function axis_sample_count(extent, quality) {
+    return max2(3, nextOdd(Math.round(quality * extent)));
+}
+
+/**
+ * Standard deviation for an axis, in kernel-index units.
+ *
+ * The kernel spans `±(samples-1)/2` indices and should cover `±3` sigma of the gaussian, otherwise
+ * the taps sit on a near-flat part of the bell and the "blur" degenerates into a box filter.
+ *
+ * @param {number} samples
+ * @returns {number}
+ */
+function axis_sigma(samples) {
+    return (samples - 1) / 6;
+}
 
+/**
+ * Blurs another {@link PointFitnessFunction} by sampling it over an axis-aligned box centred on the
+ * query point and weighting the samples with a separable 3D gaussian.
+ *
+ * Sampling convention (shared with {@link CellFilterGaussianBlur}): the taps are centred on
+ * `(samples-1)/2` and spaced `size/(samples-1)` apart, so the outermost taps land exactly on the
+ * faces of the box and the tap pattern is symmetric about the query point.
+ *
+ * An axis with a zero `size` still gets its (minimum) taps, but they all land on the query point,
+ * so the axis contributes a constant factor that cancels in the normalisation — i.e. a `size_z` of
+ * 0 gives a plain 2D blur.
+ */
 export class PointFitnessGaussianBlur extends PointFitnessFunction {
-    constructor() {
-        super();
 
-        this.samples_x = 5;
-        this.samples_y = 5;
-        this.samples_z = 5;
+    samples_x = 5;
+    samples_y = 5;
+    samples_z = 5;
 
-        this.sigma_x = 10;
-        this.sigma_y = 10;
-        this.sigma_z = 10;
+    sigma_x = axis_sigma(5);
+    sigma_y = axis_sigma(5);
+    sigma_z = axis_sigma(5);
 
+    size_x = 1;
+    size_y = 1;
+    size_z = 1;
 
-        this.size_x = 1;
-        this.size_y = 1;
-        this.size_z = 1;
+    /**
+     * Taps per world unit that {@link samples_x}/{@link samples_y}/{@link samples_z} were derived
+     * from. Kept only so the derivation can be reproduced (serialization records the box size and
+     * the quality, not the resulting tap counts); {@link evaluate} reads the sample counts.
+     *
+     * @type {number}
+     */
+    quality = 5;
 
-        /**
-         *
-         * @type {PointFitnessFunction}
-         */
-        this.source = null;
-    }
+    /**
+     *
+     * @type {PointFitnessFunction}
+     */
+    source = null;
 
     /**
      *
      * @param {PointFitnessFunction} source
-     * @param {number} x
+     * @param {number} x size of the blur box along X, in world units
      * @param {number} y
      * @param {number} z
-     * @param {number} [quality]
+     * @param {number} [quality] taps per world unit along each axis
      * @returns {PointFitnessGaussianBlur}
      */
     static from(source, x, y, z, quality = 5) {
@@ -48,14 +94,20 @@ export class PointFitnessGaussianBlur extends PointFitnessFunction {
 
         r.source = source;
 
-        r.samples_x = x * quality;
-        r.samples_y = y * quality;
-        r.samples_z = z * quality;
+        r.quality = quality;
+
+        r.samples_x = axis_sample_count(x, quality);
+        r.samples_y = axis_sample_count(y, quality);
+        r.samples_z = axis_sample_count(z, quality);
 
         r.size_x = x;
         r.size_y = y;
         r.size_z = z;
 
+        r.sigma_x = axis_sigma(r.samples_x);
+        r.sigma_y = axis_sigma(r.samples_y);
+        r.sigma_z = axis_sigma(r.samples_z);
+
         return r;
     }
 
@@ -64,13 +116,17 @@ export class PointFitnessGaussianBlur extends PointFitnessFunction {
         const samplesY = this.samples_y;
         const samplesZ = this.samples_z;
 
-        const half_samples_x = (samplesX / 2);
-        const half_samples_y = (samplesY / 2);
-        const half_samples_z = (samplesZ / 2);
+        // taps are centred on the middle index, so they are symmetric about the query point
+        const half_samples_x = (samplesX - 1) * 0.5;
+        const half_samples_y = (samplesY - 1) * 0.5;
+        const half_samples_z = (samplesZ - 1) * 0.5;
+
+        // spacing that puts the outermost taps exactly on the faces of the blur box
+        const step_x = this.size_x / (samplesX - 1);
+        const step_y = this.size_y / (samplesY - 1);
+        const step_z = this.size_z / (samplesZ - 1);
 
-        const sizeX = this.size_x;
-        const sizeY = this.size_y;
-        const sizeZ = this.size_z;
+        const source = this.source;
 
         let sum = 0;
         let powerTotal = 0;
@@ -81,18 +137,14 @@ export class PointFitnessGaussianBlur extends PointFitnessFunction {
 
             const fz = gaussian(this.sigma_z, local_z);
 
-            const nz = local_z / samplesZ;
-
-            const offset_z = sizeZ * nz;
+            const offset_z = local_z * step_z;
 
             for (let iy = 0; iy < samplesY; iy++) {
                 const local_y = iy - half_samples_y;
 
                 const fy = gaussian(this.sigma_y, local_y);
 
-                const ny = local_y / samplesY;
-
-                const offset_y = sizeY * ny;
+                const offset_y = local_y * step_y;
 
                 for (let ix = 0; ix < samplesX; ix++) {
 
@@ -100,15 +152,13 @@ export class PointFitnessGaussianBlur extends PointFitnessFunction {
 
                     const fx = gaussian(this.sigma_x, local_x);
 
-                    const nx = local_x / samplesX;
-
-                    const offset_x = sizeX * nx;
+                    const offset_x = local_x * step_x;
 
                     const power = fx * fy * fz;
 
                     powerTotal += power;
 
-                    const sourceValue = this.source.evaluate(ecd, x + offset_x, y + offset_y, z + offset_z);
+                    const sourceValue = source.evaluate(ecd, x + offset_x, y + offset_y, z + offset_z);
 
                     sum += sourceValue * power;
 
@@ -116,9 +166,10 @@ export class PointFitnessGaussianBlur extends PointFitnessFunction {
             }
         }
 
-        const result = sum / powerTotal;
-
-        return result;
+        // dividing by the accumulated power is exactly what a pre-normalized kernel
+        // (see `core/math/build_gaussian_kernel_2d.js`) does; there is no `initialize` stage on
+        // PointFitnessFunction to precompute one into, so the weights are evaluated inline
+        return sum / powerTotal;
     }
 }
 

package/src/engine/ecs/grid/pick.d.ts

@@ -4,7 +4,9 @@
  * @param {number} y
  * @param {GraphicsEngine} graphicsEngine
  * @param {Terrain} terrain
- * @param {function(gridPosition:Vector2,worldPosition:Vector3,normal:Vector3)} callback
+ * @param {(gridPosition: Vector2, worldPosition: Vector3, normal: Vector3) => void} callback
  */
-export function pick(x: number, y: number, graphicsEngine: GraphicsEngine, terrain: Terrain, callback: any): void;
+export function pick(x: number, y: number, graphicsEngine: GraphicsEngine, terrain: Terrain, callback: (gridPosition: Vector2, worldPosition: Vector3, normal: Vector3) => void): void;
+import Vector2 from "../../../core/geom/Vector2.js";
+import Vector3 from "../../../core/geom/Vector3.js";
 //# sourceMappingURL=pick.d.ts.map

package/src/engine/ecs/grid/pick.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/grid/pick.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBANW,MAAM,KACN,MAAM,yEAmChB"}
+{"version":3,"file":"pick.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/grid/pick.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,wBANW,MAAM,KACN,MAAM,6EAGS,OAAO,iBAAiB,OAAO,UAAU,OAAO,KAAK,IAAI,QAgClF;oBAxCmB,+BAA+B;oBAF/B,+BAA+B"}

package/src/engine/ecs/grid/pick.js

@@ -9,7 +9,7 @@ import Vector2 from "../../../core/geom/Vector2.js";
  * @param {number} y
  * @param {GraphicsEngine} graphicsEngine
  * @param {Terrain} terrain
- * @param {function(gridPosition:Vector2,worldPosition:Vector3,normal:Vector3)} callback
+ * @param {(gridPosition: Vector2, worldPosition: Vector3, normal: Vector3) => void} callback
  */
 export function pick(x, y, graphicsEngine, terrain, callback) {
 

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.d.ts

@@ -23,7 +23,9 @@ declare class HeadsUpDisplaySystem extends System<any> {
     shutdown(em: any): Promise<void>;
     startup(em: any): Promise<void>;
     /**
-     * NOTE: for the sake of speed all of the matrix and vector multiplications have been inlined, readability of this method is pretty bad
+     * NOTE: for the sake of speed the projection multiplications have been inlined, readability of this method is pretty bad.
+     * The quaternion rotation is NOT inlined — {@link v3_quaternion_apply} already writes into a caller-supplied
+     * array, so it costs no allocation and there is nothing to gain from a private copy of the expansion.
      * @param {HeadsUpDisplay} hud
      * @param {Transform} transform
      * @param {ViewportPosition} vp

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"HeadsUpDisplaySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js"],"names":[],"mappings":";AAeA;;;;;GAKG;AACH;IASI;;;OAGG;IACH,4BAFW,cAAc,EAqBxB;IA/BD,wCAAgC;IAGhC,2HAGE;IAaE,yBAA8B;IAM9B;;;;OAIG;IACH,+BAAiD;IAGrD,iCAGC;IAED,gCAIC;IAED;;;;;;;OAOG;IACH,sCA6JC;IAED,6BAsBC;CACJ;uBA3PsB,iBAAiB;2BAIb,qBAAqB;uBAFzB,kBAAkB;4CALG,uDAAuD;6BAMtE,iCAAiC;+BAL/B,qCAAqC"}
+{"version":3,"file":"HeadsUpDisplaySystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js"],"names":[],"mappings":";AAsBA;;;;;GAKG;AACH;IASI;;;OAGG;IACH,4BAFW,cAAc,EAqBxB;IA/BD,wCAAgC;IAGhC,2HAGE;IAaE,yBAA8B;IAM9B;;;;OAIG;IACH,+BAAiD;IAGrD,iCAGC;IAED,gCAIC;IAED;;;;;;;;;OASG;IACH,sCAkJC;IAED,6BAsBC;CACJ;uBAxPsB,iBAAiB;2BAIb,qBAAqB;uBAFzB,kBAAkB;4CALG,uDAAuD;6BAMtE,iCAAiC;+BAL/B,qCAAqC"}

package/src/engine/ecs/gui/hud/HeadsUpDisplaySystem.js

@@ -1,4 +1,5 @@
 import { m4_multiply } from "../../../../core/geom/3d/mat4/m4_multiply.js";
+import { v3_quaternion_apply } from "../../../../core/geom/vec3/v3_quaternion_apply.js";
 import { ResourceAccessKind } from "../../../../core/model/ResourceAccessKind.js";
 import { ResourceAccessSpecification } from "../../../../core/model/ResourceAccessSpecification.js";
 import { GraphicsEngine } from "../../../graphics/GraphicsEngine.js";
@@ -12,6 +13,12 @@ import { HeadsUpDisplayFlag } from "./HeadsUpDisplayFlag.js";
 
 const projection = new Float32Array(16);
 
+/**
+ * Destination for {@link v3_quaternion_apply}; the world offset is rotated through here.
+ * @type {Float64Array}
+ */
+const scratch_rotated_offset = new Float64Array(3);
+
 
 /**
  *
@@ -65,7 +72,9 @@ class HeadsUpDisplaySystem extends System {
     }
 
     /**
-     * NOTE: for the sake of speed all of the matrix and vector multiplications have been inlined, readability of this method is pretty bad
+     * NOTE: for the sake of speed the projection multiplications have been inlined, readability of this method is pretty bad.
+     * The quaternion rotation is NOT inlined — {@link v3_quaternion_apply} already writes into a caller-supplied
+     * array, so it costs no allocation and there is nothing to gain from a private copy of the expansion.
      * @param {HeadsUpDisplay} hud
      * @param {Transform} transform
      * @param {ViewportPosition} vp
@@ -89,22 +98,11 @@ class HeadsUpDisplaySystem extends System {
 
             const q = transform.rotation;
 
-            const qx = q.x;
-            const qy = q.y;
-            const qz = q.z;
-            const qw = q.w;
-
-            // calculate quat * vec
-            const ix = qw * x + qy * z - qz * y;
-            const iy = qw * y + qz * x - qx * z;
-            const iz = qw * z + qx * y - qy * x;
-            const iw = -qx * x - qy * y - qz * z;
-
-            // calculate result * inverse quat
-            x = ix * qw + iw * -qx + iy * -qz - iz * -qy;
-            y = iy * qw + iw * -qy + iz * -qx - ix * -qz;
-            z = iz * qw + iw * -qz + ix * -qy - iy * -qx;
+            v3_quaternion_apply(scratch_rotated_offset, 0, x, y, z, q.x, q.y, q.z, q.w);
 
+            x = scratch_rotated_offset[0];
+            y = scratch_rotated_offset[1];
+            z = scratch_rotated_offset[2];
         }
 
         // add transform position to get final world position

package/src/engine/ecs/gui/parallax/GuiElementParallaxSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GuiElementParallaxSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/parallax/GuiElementParallaxSystem.js"],"names":[],"mappings":"AAIA;IAGI;;;;OAIG;IACH,yCAeC;IAtBD,gEAAgD;IAW5C;;;OAGG;IACH,UAFU,OAAK,IAAI,CAEK;IAExB;;;OAGG;IACH,SAFU,gBAAc,IAAI,CAEN;IAG1B;;;;;OAKG;IACH,uBAJW,kBAAkB,WAClB,UAAU,UACV,MAAM,QA2ChB;IAED,6BAWC;CACJ;uBA1FsB,iBAAiB;uBACjB,kBAAkB;mCACN,yBAAyB"}
+{"version":3,"file":"GuiElementParallaxSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/parallax/GuiElementParallaxSystem.js"],"names":[],"mappings":"AAKA;IAGI;;;;OAIG;IACH,yCAeC;IAtBD,gEAAgD;IAW5C;;;OAGG;IACH,UAFU,OAAK,IAAI,CAEK;IAExB;;;OAGG;IACH,SAFU,gBAAc,IAAI,CAEN;IAG1B;;;;;OAKG;IACH,uBAJW,kBAAkB,WAClB,UAAU,UACV,MAAM,QA6BhB;IAED,6BAWC;CACJ;uBA5EsB,iBAAiB;uBACjB,kBAAkB;mCACN,yBAAyB"}

package/src/engine/ecs/gui/parallax/GuiElementParallaxSystem.js

@@ -1,3 +1,4 @@
+import { apply_pointer_tilt_3d } from "../../../ui/apply_pointer_tilt_3d.js";
 import { System } from "../../System.js";
 import GUIElement from "../GUIElement.js";
 import { GuiElementParallax } from "./GuiElementParallax.js";
@@ -37,43 +38,29 @@ export class GuiElementParallaxSystem extends System {
 
         const p = this.pointer.position;
 
-        const pointer_x = p.x;
-        const pointer_y = p.y;
-
         const viewport_side = this.viewport.size;
 
         const view = element.view;
 
+        const el = view.el;
+
         /**
          *
          * @type {ClientRect}
          */
-        const rect = view.el.getBoundingClientRect();
-
-        const center_x = rect.left + rect.width * 0.5;
-        const center_y = rect.top + rect.height * 0.5;
-
-
-        const viewport_center_x = viewport_side.x * 0.5;
-        const viewport_center_y = viewport_side.y * 0.5;
-
-        const delta_x = pointer_x - viewport_center_x;
-        const delta_y = pointer_y - viewport_center_y;
-
-
-        const tilt_x = (delta_y / viewport_center_y);
-        const tilt_y = -(delta_x / viewport_center_x);
-
-        const radius = Math.sqrt(tilt_x * tilt_x + tilt_y * tilt_y);
-
-        const angle = radius * parallax.angle;
-
-
-        const style = view.el.style;
-
-        style.transformOrigin = '50% 50%';
-        style.transform = `rotate3d(${tilt_x},${tilt_y},0,${angle}deg)`;
-        style.transformStyle = 'preserve-3d';
+        const rect = el.getBoundingClientRect();
+
+        apply_pointer_tilt_3d(
+            el,
+            p.x, p.y,
+            rect.left + rect.width * 0.5, rect.top + rect.height * 0.5,
+            viewport_side.x, viewport_side.y,
+            parallax.angle,
+            0
+        );
+
+        // children of a parallaxed element participate in the same 3d space
+        el.style.transformStyle = 'preserve-3d';
     }
 
     update(timeDelta) {

package/src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"OneBoneSurfaceAlignmentSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.js"],"names":[],"mappings":"AAqCA;;GAEG;AACH;IACI,0BA0KC;CACJ;yBA1MwB,eAAe"}
+{"version":3,"file":"OneBoneSurfaceAlignmentSolver.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/ik/OneBoneSurfaceAlignmentSolver.js"],"names":[],"mappings":"AAkCA;;GAEG;AACH;IACI,0BA+GC;CACJ;yBA/IwB,eAAe"}