@woosh/meep-engine 2.169.1 → 2.169.3

package/src/engine/control/first-person/abilities/Mantle.js

@@ -1,35 +1,19 @@
 import { assert } from "../../../../core/assert.js";
+import TransitionFunctions from "../../../animation/TransitionFunctions.js";
 import { FirstPersonPosture } from "../pose/FirstPersonPosture.js";
 import { Ability } from "./Ability.js";
 
-/**
- * Smoothstep-style horizontal interpolation: slow-fast-slow.
- * @param {number} t  [0..1]
- */
-function easeInOutCubic(t) {
-    return t < 0.5
-        ? 4 * t * t * t
-        : 1 - Math.pow(-2 * t + 2, 3) / 2;
-}
+// Smoothstep-style horizontal interpolation: slow-fast-slow.
+const easeInOutCubic = TransitionFunctions.EaseInOutCubic;
 
-/**
- * Front-loaded ease — fast rise then gentle settle. Used for the vertical
- * curve so the body lifts off the ground quickly (matching the hand-grip
- * pull-up dynamic) and decelerates as it approaches the surface top.
- * @param {number} t  [0..1]
- */
-function easeOutCubic(t) {
-    return 1 - Math.pow(1 - t, 3);
-}
+// Front-loaded ease — fast rise then gentle settle. Used for the vertical
+// curve so the body lifts off the ground quickly (matching the hand-grip
+// pull-up dynamic) and decelerates as it approaches the surface top.
+const easeOutCubic = TransitionFunctions.EaseOutCubic;
 
-/**
- * Back-loaded ease — gentle start, accelerating finish. Used for the
- * DESCENDING half of a vault hump (you crest the edge then drop over).
- * @param {number} t  [0..1]
- */
-function easeInCubic(t) {
-    return t * t * t;
-}
+// Back-loaded ease — gentle start, accelerating finish. Used for the
+// DESCENDING half of a vault hump (you crest the edge then drop over).
+const easeInCubic = TransitionFunctions.EaseInCubic;
 
 /**
  * Mantle ability — auto-triggers when the player walks/runs into a

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/gui/GUIElementSystem.d.ts

@@ -15,6 +15,15 @@ declare class GUIElementSystem extends System<any> {
      * @type {Object<View>}
      */
     groups: any;
+    /**
+     * Contexts of {@link handleComponentVisibilityChange}, keyed by entity. Signal handlers are
+     * matched on the handle *and* the context, so the context has to survive until unlink,
+     * otherwise the handler stays subscribed for the lifetime of the component.
+     * @private
+     * @readonly
+     * @type {Map<number, object>}
+     */
+    private readonly visibilityContexts;
     containerView: View;
     /**
      * @type {ModuleRegistry}

package/src/engine/ecs/gui/GUIElementSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GUIElementSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElementSystem.js"],"names":[],"mappings":"AAiCA,gFAAiF;;AAEjF;IAyBI;;;;;OAKG;IACH,2BAJW,IAAI,kBAqCd;IA9DD,gBAaG;IAEH,oCAA4B;IAE5B;;;OAGG;IACH,YAAY;IA2BR,oBAAkC;IAGlC;;OAEG;IACH,8BAA0C;IAE1C;;;OAGG;IACH,eAAoB;IAIxB,gCAGC;IAED,iCAEC;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QA6DhB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QAoBhB;IAED;;;;OAIG;IACH,gBAHW,UAAU,qBAiDpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,qBAiBpB;CACJ;uBAhRsB,cAAc;sBAFf,qCAAqC;uBAGhB,iBAAiB;iBAF3C,uBAAuB"}
+{"version":3,"file":"GUIElementSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ecs/gui/GUIElementSystem.js"],"names":[],"mappings":"AAiCA,gFAAiF;;AAEjF;IAmCI;;;;;OAKG;IACH,2BAJW,IAAI,kBAqCd;IAxED,gBAaG;IAEH,oCAA4B;IAE5B;;;OAGG;IACH,YAAY;IAEZ;;;;;;;OAOG;IACH,oCAA+B;IA2B3B,oBAAkC;IAGlC;;OAEG;IACH,8BAA0C;IAE1C;;;OAGG;IACH,eAAoB;IAIxB,gCAGC;IAED,iCAEC;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QA6DhB;IAED;;;;OAIG;IACH,2BAHW,UAAU,UACV,MAAM,QAoBhB;IAED;;;;OAIG;IACH,gBAHW,UAAU,qBAqDpB;IAED;;;;OAIG;IACH,kBAHW,UAAU,qBAuBpB;CACJ;uBApSsB,cAAc;sBAFf,qCAAqC;uBAGhB,iBAAiB;iBAF3C,uBAAuB"}

package/src/engine/ecs/gui/GUIElementSystem.js

@@ -58,6 +58,16 @@ class GUIElementSystem extends System {
      */
     groups = {};
 
+    /**
+     * Contexts of {@link handleComponentVisibilityChange}, keyed by entity. Signal handlers are
+     * matched on the handle *and* the context, so the context has to survive until unlink,
+     * otherwise the handler stays subscribed for the lifetime of the component.
+     * @private
+     * @readonly
+     * @type {Map<number, object>}
+     */
+    visibilityContexts = new Map();
+
     /**
      *
      * @param {View} containerView
@@ -245,11 +255,15 @@ class GUIElementSystem extends System {
             this.attachComponent(component, entity);
         }
 
-        component.visible.onChanged.add(handleComponentVisibilityChange, {
+        const visibilityContext = {
             el: component,
             system: this,
             entity
-        });
+        };
+
+        this.visibilityContexts.set(entity, visibilityContext);
+
+        component.visible.onChanged.add(handleComponentVisibilityChange, visibilityContext);
     }
 
     /**
@@ -258,7 +272,13 @@ class GUIElementSystem extends System {
      * @param entity
      */
     unlink(component, entity) {
-        component.visible.onChanged.remove(handleComponentVisibilityChange);
+        const visibilityContext = this.visibilityContexts.get(entity);
+
+        if (visibilityContext !== undefined) {
+            this.visibilityContexts.delete(entity);
+
+            component.visible.onChanged.remove(handleComponentVisibilityChange, visibilityContext);
+        }
 
         if (component.visible.getValue()) {
             this.detachComponent(component, entity);

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/gui/position/ViewportPositionSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ViewportPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPositionSystem.js"],"names":[],"mappings":";AAwBA;IACI,+BAoBC;IAjBG,8DAAkD;IAElD,kEAEC;IAED,kBAAgC;IAEhC,yCAME;IAEF,SAAc;IAGlB,2CAEC;IAED,4CAEC;IAED;;;OAGG;IACH,sBAHW,UAAU,MACV,gBAAgB,QAkE1B;IAED;;;;;OAKG;IACH,SAJW,gBAAgB,MAChB,UAAU,qBA8BpB;IAED;;;;;OAKG;IACH,WAJW,gBAAgB,MAChB,UAAU,qBAmBpB;IAgGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CAjGxD;uBAlLsB,iBAAiB;uBACjB,kBAAkB;6BAEZ,uBAAuB;4CAJR,uDAAuD;8BALrE,iDAAiD"}
+{"version":3,"file":"ViewportPositionSystem.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ecs/gui/position/ViewportPositionSystem.js"],"names":[],"mappings":";AAwBA;IACI,+BAoBC;IAjBG,8DAAkD;IAElD,kEAEC;IAED,kBAAgC;IAEhC,yCAME;IAEF,SAAc;IAGlB,2CAEC;IAED,4CAEC;IAED;;;OAGG;IACH,sBAHW,UAAU,MACV,gBAAgB,QAkE1B;IAED;;;;;OAKG;IACH,SAJW,gBAAgB,MAChB,UAAU,qBA8BpB;IAED;;;;;OAKG;IACH,WAJW,gBAAgB,MAChB,UAAU,qBAqBpB;IAgGL;;;OAGG;IACH,mCAFU,OAAO,CAEwC;CAjGxD;uBApLsB,iBAAiB;uBACjB,kBAAkB;6BAEZ,uBAAuB;4CAJR,uDAAuD;8BALrE,iDAAiD"}

package/src/engine/ecs/gui/position/ViewportPositionSystem.js

@@ -175,9 +175,11 @@ class ViewportPositionSystem extends System {
             vp.offset.onChanged.remove(updatePosition, eventContext);
             vp.anchor.onChanged.remove(updatePosition, eventContext);
             vp.enabled.onChanged.remove(updatePosition, eventContext);
-        }
 
-        this.entityManager.dataset.removeEntityEventListener(entity, GUIElementEvent.Initialized, updatePosition, eventContext);
+            el.view.size.onChanged.remove(updatePosition, eventContext);
+
+            this.entityManager.dataset.removeEntityEventListener(entity, GUIElementEvent.Initialized, updatePosition, eventContext);
+        }
 
         el.view.removeClass(CSS_CLASS);
     }

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"}