@woosh/meep-engine 2.169.0 → 2.169.2

package/src/engine/sound/sopra/definition/effect/ReverbEffect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ReverbEffect.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/ReverbEffect.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH;IAcI;;;OAGG;IACH,2CAHW;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,UAAU,CAAC,EAAC,MAAM,CAAA;KAAC,GACxC,YAAY,CASxB;IAvBD;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAED;IA0Cf;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;IAED,eAKC;IAED,sBAEC;IAED;;;MAKC;IAED;;;aAGC;CACJ;;;;oCAhGmC,0BAA0B"}
+{"version":3,"file":"ReverbEffect.d.ts","sourceRoot":"","sources":["../../../../../../../src/engine/sound/sopra/definition/effect/ReverbEffect.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;GAWG;AACH;IAcI;;;OAGG;IACH,2CAHW;QAAC,YAAY,CAAC,EAAC,MAAM,CAAC;QAAC,UAAU,CAAC,EAAC,MAAM,CAAA;KAAC,GACxC,YAAY,CASxB;IAvBD;;;OAGG;IACH,cAFU,MAAM,CAEG;IAEnB;;;OAGG;IACH,YAFU,MAAM,CAED;IAoCf;;;OAGG;IACH,cAHW,YAAY,GACV,OAAO,CAKnB;IAED,eAKC;IAED,sBAEC;IAED;;;MAKC;IAED;;;aAGC;CACJ;;;;oCA1GmC,0BAA0B"}

package/src/engine/sound/sopra/definition/effect/ReverbEffect.js

@@ -1,7 +1,22 @@
 import { combine_hash } from "../../../../../core/collection/array/combine_hash.js";
+import { seededRandom } from "../../../../../core/math/random/seededRandom.js";
 import { computeHashFloat } from "../../../../../core/primitives/numbers/computeHashFloat.js";
+import { reverbImpulseResponse } from "../../../simulation/render/reverbImpulseResponse.js";
 import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
 
+/**
+ * Seed for the procedural impulse response. Fixed (not authorable): the IR is a decaying noise tail whose
+ * audible character comes entirely from `decaySeconds`/`decayPower`, so the noise realisation carries no
+ * design intent — but it must be REPRODUCIBLE. Every other impulse response in the engine is driven by a
+ * seeded RNG (`ProbeReverbRenderer`, `FoaProbeReverbRenderer`); this one used raw `Math.random`, which made
+ * a sopra bus reverb the single non-reproducible piece of audio in a build.
+ * @type {number}
+ */
+const IR_SEED = 1;
+
+// the three equal bands a broadband decay maps onto; reused across builds (read-only to the synthesiser)
+const BROADBAND = new Float32Array(3);
+
 /**
  * Convolution reverb bus insert, backed by a {@link ConvolverNode}. Typically used on a dedicated
  * "reverb" bus that other buses route to via {@link BusDefinition.sends}.
@@ -10,6 +25,9 @@ import { AbstractAudioEffect } from "./AbstractAudioEffect.js";
  * parameterised by {@link decaySeconds} (tail length) and {@link decayPower} (how fast it fades) — so
  * there is no IR-asset dependency and {@link build} stays synchronous. (Loading an authored IR from the
  * BufferProvider is a possible later alternative; it would make build async.)
+ *
+ * Generation is DETERMINISTIC: a fixed seed drives the noise, so two builds of equal effects produce
+ * bit-identical impulse responses.
  */
 export class ReverbEffect extends AbstractAudioEffect {
 
@@ -46,21 +64,15 @@ export class ReverbEffect extends AbstractAudioEffect {
         const convolver = ctx.createConvolver();
         convolver.normalize = true;
 
-        const sampleRate = ctx.sampleRate;
-        const length = Math.max(1, Math.floor(this.decaySeconds * sampleRate));
-        const ir = ctx.createBuffer(2, length, sampleRate);
-
-        for (let channel = 0; channel < ir.numberOfChannels; channel++) {
-            const data = ir.getChannelData(channel);
-
-            for (let i = 0; i < length; i++) {
-                const t = i / length;
-                // white noise shaped by an exponentially-decaying envelope
-                data[i] = (Math.random() * 2 - 1) * Math.pow(1 - t, this.decayPower);
-            }
-        }
+        // A broadband tail is the equal-band case of the acoustic per-band synthesiser: with three equal
+        // RT60s the band split reconstructs the noise and the three envelopes coincide, so this is the same
+        // decaying-noise tail this effect generated inline — now from a SEEDED stream, and sharing one
+        // implementation with the probe-baked reverbs.
+        BROADBAND[0] = this.decaySeconds;
+        BROADBAND[1] = this.decaySeconds;
+        BROADBAND[2] = this.decaySeconds;
 
-        convolver.buffer = ir;
+        convolver.buffer = reverbImpulseResponse(ctx, BROADBAND, this.decayPower, seededRandom(IR_SEED));
 
         return { input: convolver, output: convolver };
     }

package/src/engine/sound/sopra/runtime/BusGraph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BusGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/BusGraph.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,8BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH;IAkBI;;;OAGG;IACH,iBAHW,gBAAgB,eAChB,SAAS,EAKnB;IAvBD;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE;QAAC,UAAU,gBAAgB;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAA;KAAC,CAAC,CAEpE;IAqBlB;;;;OAIG;IACH,mBAFW,eAAe,QAgFzB;IAED;;;OAGG;IACH,QAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;OAIG;IACH,aAHW,MAAM,GACJ,SAAS,CAUrB;IAED;;;;;OAKG;IACH,cAHW,MAAM,GACJ,SAAS,CAUrB;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,MAAM,CAUlB;IAED;;;OAGG;IACH,cAHW,MAAM,UACN,MAAM,QAWhB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,UACN,MAAM,YACN,MAAM,eACN,MAAM,QAWhB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,UACN,MAAM,gBACN,MAAM,QAYhB;;CACJ"}
+{"version":3,"file":"BusGraph.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/runtime/BusGraph.js"],"names":[],"mappings":"AAIA;;;;GAIG;AACH,8BAFU,MAAM,CAEkB;AAElC;;;;;GAKG;AACH;IAkBI;;;OAGG;IACH,iBAHW,gBAAgB,eAChB,SAAS,EAKnB;IAvBD;;;OAGG;IACH,OAFU,IAAI,MAAM,EAAE;QAAC,UAAU,gBAAgB;QAAC,KAAK,EAAE,SAAS,CAAC;QAAC,MAAM,EAAE,QAAQ,CAAA;KAAC,CAAC,CAEpE;IAqBlB;;;;OAIG;IACH,mBAFW,eAAe,QAgFzB;IAED;;;OAGG;IACH,QAHW,MAAM,GACJ,OAAO,CAInB;IAoBD;;;;OAIG;IACH,aAHW,MAAM,GACJ,SAAS,CAIrB;IAED;;;;;OAKG;IACH,cAHW,MAAM,GACJ,SAAS,CAIrB;IAED;;;OAGG;IACH,cAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;OAGG;IACH,cAHW,MAAM,UACN,MAAM,QAOhB;IAED;;;OAGG;IACH,gBAHW,MAAM,GACJ,MAAM,CAIlB;IAED;;;;;;;OAOG;IACH,eALW,MAAM,UACN,MAAM,YACN,MAAM,eACN,MAAM,QAOhB;IAED;;;;;;OAMG;IACH,mBAJW,MAAM,UACN,MAAM,gBACN,MAAM,QAQhB;;CACJ"}

package/src/engine/sound/sopra/runtime/BusGraph.js

@@ -136,18 +136,30 @@ export class BusGraph {
     }
 
     /**
-     * Node that voices/children should connect into for a given bus.
+     * The bus record for `id`, or throw. Every public accessor below addresses a bus by id and an unknown
+     * id is a programming error (a definition set that never declared it), so the lookup-or-throw is
+     * factored here instead of being repeated verbatim in each accessor — one place owns the message and
+     * the "unknown bus is fatal" policy.
      * @param {string} id
-     * @returns {AudioNode}
+     * @returns {{definition: BusDefinition, input: AudioNode, output: GainNode}}
      */
-    getInput(id) {
+    #bus(id) {
         const bus = this.buses.get(id);
 
         if (bus === undefined) {
             throw new Error(`sopra: no bus '${id}'`);
         }
 
-        return bus.input;
+        return bus;
+    }
+
+    /**
+     * Node that voices/children should connect into for a given bus.
+     * @param {string} id
+     * @returns {AudioNode}
+     */
+    getInput(id) {
+        return this.#bus(id).input;
     }
 
     /**
@@ -157,13 +169,7 @@ export class BusGraph {
      * @returns {AudioNode}
      */
     getOutput(id) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
-
-        return bus.output;
+        return this.#bus(id).output;
     }
 
     /**
@@ -171,13 +177,7 @@ export class BusGraph {
      * @returns {number} linear gain
      */
     getVolume(id) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
-
-        return bus.nominal;
+        return this.#bus(id).nominal;
     }
 
     /**
@@ -185,11 +185,7 @@ export class BusGraph {
      * @param {number} linear linear gain
      */
     setVolume(id, linear) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
+        const bus = this.#bus(id);
 
         bus.nominal = linear;
         bus.output.gain.setValueAtTime(linear, 0);
@@ -212,11 +208,7 @@ export class BusGraph {
      * @param {number} [startAfter=0] seconds
      */
     rampVolume(id, linear, duration, startAfter = 0) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
+        const bus = this.#bus(id);
 
         bus.nominal = linear; // a ramp is a nominal fader move; record where it's heading
         rampGain(bus.output.gain, linear, duration, this.#ctx, startAfter);
@@ -230,11 +222,7 @@ export class BusGraph {
      * @param {number} timeConstant seconds
      */
     approachVolume(id, linear, timeConstant) {
-        const bus = this.buses.get(id);
-
-        if (bus === undefined) {
-            throw new Error(`sopra: no bus '${id}'`);
-        }
+        const bus = this.#bus(id);
 
         // NB: a transient modulation (ducking) — deliberately does NOT update `nominal`, so the duck can
         // capture the true fader position at engage and restore to it on release.

package/src/engine/sound/sopra/runtime/EventInstance.js

@@ -31,7 +31,7 @@ const DEFAULT_MAX_LIFETIME_SECONDS = 60;
  * @returns {number}
  */
 function dbTiltToGain(excessDb) {
-    return excessDb <= 0 ? 1 : Math.pow(10, -excessDb / 20);
+    return excessDb <= 0 ? 1 : dB2Volume(-excessDb);
 }
 
 /**

package/src/engine/sound/sopra/util/buildAttenuationCurve.d.ts

@@ -6,10 +6,10 @@
  *
  * @param {number} distanceMin
  * @param {number} distanceMax
- * @param {function(distance:number, min:number, max:number):number} falloff
+ * @param {(distance: number, min: number, max: number) => number} falloff
  * @param {number} [sampleCount] number of keyframes (>= 2)
  * @returns {AnimationCurve}
  */
-export function buildAttenuationCurve(distanceMin: number, distanceMax: number, falloff: any, sampleCount?: number): AnimationCurve;
+export function buildAttenuationCurve(distanceMin: number, distanceMax: number, falloff: (distance: number, min: number, max: number) => number, sampleCount?: number): AnimationCurve;
 import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
 //# sourceMappingURL=buildAttenuationCurve.d.ts.map

package/src/engine/sound/sopra/util/buildAttenuationCurve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"buildAttenuationCurve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/util/buildAttenuationCurve.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,mDANW,MAAM,eACN,MAAM,8BAEN,MAAM,GACJ,cAAc,CA0B1B;+BAvC8B,4CAA4C"}
+{"version":3,"file":"buildAttenuationCurve.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/sound/sopra/util/buildAttenuationCurve.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;GAWG;AACH,mDANW,MAAM,eACN,MAAM,sBACK,MAAM,OAAO,MAAM,OAAO,MAAM,KAAK,MAAM,gBACtD,MAAM,GACJ,cAAc,CA0B1B;+BAvC8B,4CAA4C"}

package/src/engine/sound/sopra/util/buildAttenuationCurve.js

@@ -1,40 +1,40 @@
-import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
-import { Keyframe } from "../../../animation/curve/Keyframe.js";
-
-/**
- * Author a distance→gain attenuation {@link AnimationCurve} by sampling a falloff function at evenly
- * spaced distances between `distanceMin` and `distanceMax`. Lets the physically-based legacy falloffs
- * (`interpolate_irradiance_linear/logarithmic/smith`) be reused to build attenuation presets that
- * match the old engine at the sampled distances (D4), while the runtime just evaluates the curve.
- *
- * @param {number} distanceMin
- * @param {number} distanceMax
- * @param {function(distance:number, min:number, max:number):number} falloff
- * @param {number} [sampleCount] number of keyframes (>= 2)
- * @returns {AnimationCurve}
- */
-export function buildAttenuationCurve(distanceMin, distanceMax, falloff, sampleCount = 8) {
-    // A degenerate range (max <= min) has no falloff region to sample: every keyframe would land at
-    // the same distance, so alignAllTangents would divide by a zero time-delta and emit NaN tangents
-    // (which serialize to JSON null). Fall back to a finite flat-1 (no-attenuation) curve.
-    if (distanceMax <= distanceMin) {
-        return AnimationCurve.constant(0, 1, 1);
-    }
-
-    const n = Math.max(2, sampleCount);
-
-    const curve = new AnimationCurve();
-
-    for (let i = 0; i < n; i++) {
-        const t = i / (n - 1);
-        const distance = distanceMin + (distanceMax - distanceMin) * t;
-        const gain = falloff(distance, distanceMin, distanceMax);
-
-        curve.add(Keyframe.from(distance, gain));
-    }
-
-    // smooth the segments between samples
-    curve.alignAllTangents();
-
-    return curve;
-}
+import { AnimationCurve } from "../../../animation/curve/AnimationCurve.js";
+import { Keyframe } from "../../../animation/curve/Keyframe.js";
+
+/**
+ * Author a distance→gain attenuation {@link AnimationCurve} by sampling a falloff function at evenly
+ * spaced distances between `distanceMin` and `distanceMax`. Lets the physically-based legacy falloffs
+ * (`interpolate_irradiance_linear/logarithmic/smith`) be reused to build attenuation presets that
+ * match the old engine at the sampled distances (D4), while the runtime just evaluates the curve.
+ *
+ * @param {number} distanceMin
+ * @param {number} distanceMax
+ * @param {(distance: number, min: number, max: number) => number} falloff
+ * @param {number} [sampleCount] number of keyframes (>= 2)
+ * @returns {AnimationCurve}
+ */
+export function buildAttenuationCurve(distanceMin, distanceMax, falloff, sampleCount = 8) {
+    // A degenerate range (max <= min) has no falloff region to sample: every keyframe would land at
+    // the same distance, so alignAllTangents would divide by a zero time-delta and emit NaN tangents
+    // (which serialize to JSON null). Fall back to a finite flat-1 (no-attenuation) curve.
+    if (distanceMax <= distanceMin) {
+        return AnimationCurve.constant(0, 1, 1);
+    }
+
+    const n = Math.max(2, sampleCount);
+
+    const curve = new AnimationCurve();
+
+    for (let i = 0; i < n; i++) {
+        const t = i / (n - 1);
+        const distance = distanceMin + (distanceMax - distanceMin) * t;
+        const gain = falloff(distance, distanceMin, distanceMax);
+
+        curve.add(Keyframe.from(distance, gain));
+    }
+
+    // smooth the segments between samples
+    curve.alignAllTangents();
+
+    return curve;
+}

package/src/engine/ui/apply_pointer_tilt_3d.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Write a mouse-parallax 3D tilt onto a DOM element.
+ *
+ * The element is rotated about an axis perpendicular to the pointer's offset from `pivot`, by an
+ * angle proportional to how far the pointer is from that pivot relative to half the viewport. The
+ * result reads as the element leaning away from / toward the cursor.
+ *
+ * This exists because the identical body was carried by both {@link GuiElementParallaxSystem} (ECS)
+ * and {@link DomElementProcessorTilt3D} (DOM binding), and the ECS copy had silently lost its pivot:
+ * it computed the element centre and then took the delta against the viewport centre instead, so
+ * every element tilted identically no matter where on screen it sat. There is one pivot convention
+ * now — the caller always supplies it, and it is always the element centre.
+ *
+ * @param {HTMLElement} el element to write the transform onto
+ * @param {number} pointer_x pointer position in viewport pixels
+ * @param {number} pointer_y
+ * @param {number} pivot_x point the tilt is measured from, in viewport pixels; normally the element centre
+ * @param {number} pivot_y
+ * @param {number} viewport_width used to normalise the pointer offset; must be greater than 0
+ * @param {number} viewport_height must be greater than 0
+ * @param {number} angle maximum tilt in degrees, reached when the pointer offset equals half the viewport
+ * @param {number} depth `translateZ` applied after the rotation, in pixels; 0 for a pure rotation
+ */
+export function apply_pointer_tilt_3d(el: HTMLElement, pointer_x: number, pointer_y: number, pivot_x: number, pivot_y: number, viewport_width: number, viewport_height: number, angle: number, depth: number): void;
+//# sourceMappingURL=apply_pointer_tilt_3d.d.ts.map

package/src/engine/ui/apply_pointer_tilt_3d.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"apply_pointer_tilt_3d.d.ts","sourceRoot":"","sources":["../../../../src/engine/ui/apply_pointer_tilt_3d.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,0CAVW,WAAW,aACX,MAAM,aACN,MAAM,WACN,MAAM,WACN,MAAM,kBACN,MAAM,mBACN,MAAM,SACN,MAAM,SACN,MAAM,QA4BhB"}

package/src/engine/ui/apply_pointer_tilt_3d.js

@@ -0,0 +1,50 @@
+/**
+ * Write a mouse-parallax 3D tilt onto a DOM element.
+ *
+ * The element is rotated about an axis perpendicular to the pointer's offset from `pivot`, by an
+ * angle proportional to how far the pointer is from that pivot relative to half the viewport. The
+ * result reads as the element leaning away from / toward the cursor.
+ *
+ * This exists because the identical body was carried by both {@link GuiElementParallaxSystem} (ECS)
+ * and {@link DomElementProcessorTilt3D} (DOM binding), and the ECS copy had silently lost its pivot:
+ * it computed the element centre and then took the delta against the viewport centre instead, so
+ * every element tilted identically no matter where on screen it sat. There is one pivot convention
+ * now — the caller always supplies it, and it is always the element centre.
+ *
+ * @param {HTMLElement} el element to write the transform onto
+ * @param {number} pointer_x pointer position in viewport pixels
+ * @param {number} pointer_y
+ * @param {number} pivot_x point the tilt is measured from, in viewport pixels; normally the element centre
+ * @param {number} pivot_y
+ * @param {number} viewport_width used to normalise the pointer offset; must be greater than 0
+ * @param {number} viewport_height must be greater than 0
+ * @param {number} angle maximum tilt in degrees, reached when the pointer offset equals half the viewport
+ * @param {number} depth `translateZ` applied after the rotation, in pixels; 0 for a pure rotation
+ */
+export function apply_pointer_tilt_3d(
+    el,
+    pointer_x, pointer_y,
+    pivot_x, pivot_y,
+    viewport_width, viewport_height,
+    angle,
+    depth
+) {
+
+    const viewport_center_x = viewport_width * 0.5;
+    const viewport_center_y = viewport_height * 0.5;
+
+    const delta_x = pointer_x - pivot_x;
+    const delta_y = pointer_y - pivot_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 tilt_angle = radius * angle;
+
+    const style = el.style;
+
+    style.transformOrigin = '50% 50%';
+    style.transform = `rotate3d(${tilt_x},${tilt_y},0,${tilt_angle}deg) translateZ(${depth}px)`;
+}

package/src/engine/ui/bindings/processors/DomElementProcessorTilt3D.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"DomElementProcessorTilt3D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ui/bindings/processors/DomElementProcessorTilt3D.js"],"names":[],"mappings":"AAEA;IAuBI;;;;;OAKG;IACH,+BAJW,MAAM,GAEL,yBAAyB,CAcpC;IArCG;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAAkB;IAuBtB,+BAEC;CAmDJ;oCAlGmC,2BAA2B"}
+{"version":3,"file":"DomElementProcessorTilt3D.d.ts","sourceRoot":"","sources":["../../../../../../src/engine/ui/bindings/processors/DomElementProcessorTilt3D.js"],"names":[],"mappings":"AAGA;IAuBI;;;;;OAKG;IACH,+BAJW,MAAM,GAEL,yBAAyB,CAcpC;IArCG;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,OAFU,MAAM,CAEF;IAEd;;;OAGG;IACH,eAAkB;IAuBtB,+BAEC;CAiCJ;oCAhFmC,2BAA2B"}

package/src/engine/ui/bindings/processors/DomElementProcessorTilt3D.js

@@ -1,3 +1,4 @@
+import { apply_pointer_tilt_3d } from "../../apply_pointer_tilt_3d.js";
 import { DomElementProcessor } from "../DomElementProcessor.js";
 
 export class DomElementProcessorTilt3D extends DomElementProcessor {
@@ -61,9 +62,6 @@ export class DomElementProcessorTilt3D extends DomElementProcessor {
 
         const p = engine.devices.pointer.position;
 
-        const pointer_x = p.x;
-        const pointer_y = p.y;
-
         const viewport_size = engine.gameView.size;
 
         /**
@@ -72,28 +70,13 @@ export class DomElementProcessorTilt3D extends DomElementProcessor {
          */
         const rect = 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_size.x * 0.5;
-        const viewport_center_y = viewport_size.y * 0.5;
-
-        const delta_x = pointer_x - center_x;
-        const delta_y = pointer_y - 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 * this.angle;
-
-
-        const style = el.style;
-
-        style.transformOrigin = '50% 50%';
-        style.transform = `rotate3d(${tilt_x},${tilt_y},0,${angle}deg) translateZ(${this.depth}px)`;
+        apply_pointer_tilt_3d(
+            el,
+            p.x, p.y,
+            rect.left + rect.width * 0.5, rect.top + rect.height * 0.5,
+            viewport_size.x, viewport_size.y,
+            this.angle,
+            this.depth
+        );
     }
 }

package/src/engine/ui/notification/NotificationManager.d.ts

@@ -40,10 +40,10 @@ export class NotificationManager {
     /**
      *
      * @param {string} channel
-     * @param {function(log:NotificationLog):View} initializer
-     * @param {function(timeDelta:number)} [updateFunction]
+     * @param {(log: NotificationLog) => View} initializer
+     * @param {(timeDelta: number) => void} [updateFunction]
      */
-    addDisplay(channel: string, initializer: any, updateFunction: any): void;
+    addDisplay(channel: string, initializer: (log: NotificationLog) => View, updateFunction?: (timeDelta: number) => void): void;
     /**
      *
      * @param {string} channel
@@ -69,8 +69,8 @@ declare class LogDisplay {
     /**
      *
      * @param {NotificationLog} log
-     * @param {function(log:NotificationLog)} initializer
-     * @param {function(timeDelta:number)} [updateFunction]
+     * @param {(log: NotificationLog) => void} initializer
+     * @param {(timeDelta: number) => void} [updateFunction]
      */
     constructor({ log, initializer, updateFunction }: NotificationLog);
     needsUpdate: boolean;

package/src/engine/ui/notification/NotificationManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NotificationManager.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ui/notification/NotificationManager.js"],"names":[],"mappings":"AAqDA;IAEQ;;;OAGG;IACH,UAFU,IAAI,MAAM,EAAE,eAAe,CAAC,CAEb;IAEzB;;;OAGG;IACH,UAFU,KAAK,UAAU,CAAC,CAEA;IAE1B;;;;OAIG;IACH,oBAA4B;IAE5B;;;OAGG;IACH,KAFU,yBAAuB,IAAI,CAEtB;IAGnB;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,UAAU,EAAE,CAMxB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,+CAmBhB;IAED;;;;;OAKG;IACH,2BAJW,MAAM,qDAuFhB;IAED;;;;OAIG;IACH,8BAHW,YAAY,WACZ,MAAM,QAahB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAchB;CACJ;4BApQ2B,iCAAiC;iBAP5C,uCAAuC;AAUxD;IACI;;;;;OAKG;IACH,kDAJW,eAAe,EAsBzB;IAZG,qBAA0C;IAE1C,uBAAuC;IAEvC,SAAc;IACd,iBAA8B;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEE;IAGtB;;;OAGG;IACH,kBAFW,MAAM,QAMhB;IAED,mBAEC;CACJ"}
+{"version":3,"file":"NotificationManager.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ui/notification/NotificationManager.js"],"names":[],"mappings":"AAqDA;IAEQ;;;OAGG;IACH,UAFU,IAAI,MAAM,EAAE,eAAe,CAAC,CAEb;IAEzB;;;OAGG;IACH,UAFU,KAAK,UAAU,CAAC,CAEA;IAE1B;;;;OAIG;IACH,oBAA4B;IAE5B;;;OAGG;IACH,KAFU,yBAAuB,IAAI,CAEtB;IAGnB;;;OAGG;IACH,uBAFW,MAAM,QAchB;IAED;;;;OAIG;IACH,oBAHW,MAAM,GACJ,eAAe,GAAC,SAAS,CAIrC;IAED;;;;OAIG;IACH,qBAHW,MAAM,GACJ,UAAU,EAAE,CAMxB;IAED;;;;;OAKG;IACH,oBAJW,MAAM,qBACA,eAAe,wCACT,MAAM,KAAK,IAAI,QAiBrC;IAED;;;;;OAKG;IACH,2BAJW,MAAM,qDAuFhB;IAED;;;;OAIG;IACH,8BAHW,YAAY,WACZ,MAAM,QAahB;IAED;;;OAGG;IACH,gBAFW,MAAM,QAchB;CACJ;4BApQ2B,iCAAiC;iBAP5C,uCAAuC;AAUxD;IACI;;;;;OAKG;IACH,kDAJW,eAAe,EAsBzB;IAZG,qBAA0C;IAE1C,uBAAuC;IAEvC,SAAc;IACd,iBAA8B;IAE9B;;;OAGG;IACH,WAFU,MAAM,CAEE;IAGtB;;;OAGG;IACH,kBAFW,MAAM,QAMhB;IAED,mBAEC;CACJ"}

package/src/engine/ui/notification/NotificationManager.js

@@ -13,8 +13,8 @@ class LogDisplay {
     /**
      *
      * @param {NotificationLog} log
-     * @param {function(log:NotificationLog)} initializer
-     * @param {function(timeDelta:number)} [updateFunction]
+     * @param {(log: NotificationLog) => void} initializer
+     * @param {(timeDelta: number) => void} [updateFunction]
      */
     constructor({
                     log,
@@ -120,8 +120,8 @@ export class NotificationManager {
     /**
      *
      * @param {string} channel
-     * @param {function(log:NotificationLog):View} initializer
-     * @param {function(timeDelta:number)} [updateFunction]
+     * @param {(log: NotificationLog) => View} initializer
+     * @param {(timeDelta: number) => void} [updateFunction]
      */
     addDisplay(channel, initializer, updateFunction) {
         assert.isString(channel, 'channel');

package/src/engine/ui/tiles2d/TileGrid.d.ts

@@ -57,9 +57,9 @@ declare class TileGrid {
      *
      * @param {number} tileWidth
      * @param {number} tileHeight
-     * @param {function(x:number, y:number):*} visitor
+     * @param {(x: number, y: number) => *} visitor
      */
-    computePossibleTilePositions(tileWidth: number, tileHeight: number, visitor: any): void;
+    computePossibleTilePositions(tileWidth: number, tileHeight: number, visitor: (x: number, y: number) => any): void;
     /**
      *
      * @param {Rectangle} tile

package/src/engine/ui/tiles2d/TileGrid.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TileGrid.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ui/tiles2d/TileGrid.js"],"names":[],"mappings":";AAIA;IACI;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAgBhB;IAXG,cAAsC;IACtC;;;OAGG;IACH,OAFU,eAAe,CAEF;IACvB;;;OAGG;IACH,UAFU,OAAO,CAE0B;IAG/C;;;OAGG;IACH,wBAFY,MAAM,CAgBjB;IAED;;;;OAIG;IACH,sCAFa,gBAAgB,CAQ5B;IAED;;;;;;;;OAQG;IACH,+BAPW,WAAW,KACX,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAuBlB;IAED;;;;OAIG;IACH,2BAFa,OAAO,CAInB;IAED;;;;;;OAMG;IACH,yBALW,OAAO,KACP,MAAM,KACN,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,cACN,MAAM,sBAehB;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,cAFW,gBAAiB,QAI3B;CACJ;oBAlKmB,+BAA+B;iBAFlC,uCAAuC;oBACpC,+BAA+B"}
+{"version":3,"file":"TileGrid.d.ts","sourceRoot":"","sources":["../../../../../src/engine/ui/tiles2d/TileGrid.js"],"names":[],"mappings":";AAIA;IACI;;;;;OAKG;IACH,mBAJW,MAAM,UACN,MAAM,EAgBhB;IAXG,cAAsC;IACtC;;;OAGG;IACH,OAFU,eAAe,CAEF;IACvB;;;OAGG;IACH,UAFU,OAAO,CAE0B;IAG/C;;;OAGG;IACH,wBAFY,MAAM,CAgBjB;IAED;;;;OAIG;IACH,sCAFa,gBAAgB,CAQ5B;IAED;;;;;;;;OAQG;IACH,+BAPW,WAAW,KACX,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAuBlB;IAED;;;;OAIG;IACH,2BAFa,OAAO,CAInB;IAED;;;;;;OAMG;IACH,yBALW,OAAO,KACP,MAAM,KACN,MAAM,GACJ,OAAO,CAsBnB;IAED;;;;;OAKG;IACH,wCAJW,MAAM,cACN,MAAM,eACF,MAAM,KAAK,MAAM,gBAc/B;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,cAFW,gBAAiB,QAI3B;CACJ;oBAlKmB,+BAA+B;iBAFlC,uCAAuC;oBACpC,+BAA+B"}

package/src/engine/ui/tiles2d/TileGrid.js

@@ -131,7 +131,7 @@ class TileGrid {
      *
      * @param {number} tileWidth
      * @param {number} tileHeight
-     * @param {function(x:number, y:number):*} visitor
+     * @param {(x: number, y: number) => *} visitor
      */
     computePossibleTilePositions(tileWidth, tileHeight, visitor) {
 

package/src/generation/filtering/numeric/CellFilterCache.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterCache.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/numeric/CellFilterCache.js"],"names":[],"mappings":"AAIA;IAeI;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,eAAe,CAW3B;IA5BD;;;;OAIG;IACH,gBAAqC;IAErC;;;OAGG;IACH,OAFU,MAAM,CAEN;IAmBV,uCAkCC;CAKJ;yCAzEwC,qCAAqC"}
+{"version":3,"file":"CellFilterCache.d.ts","sourceRoot":"","sources":["../../../../../src/generation/filtering/numeric/CellFilterCache.js"],"names":[],"mappings":"AAKA;IAeI;;;;;OAKG;IACH,wCAHW,MAAM,GACJ,eAAe,CAW3B;IA5BD;;;;OAIG;IACH,gBAAqC;IAErC;;;OAGG;IACH,OAFU,MAAM,CAEN;IAmBV,uCAgBC;CAKJ;yCAxDwC,qCAAqC"}

package/src/generation/filtering/numeric/CellFilterCache.js

@@ -1,6 +1,7 @@
 import { assert } from "../../../core/assert.js";
 import { Sampler2D } from "../../../engine/graphics/texture/sampler/Sampler2D.js";
 import { CellFilterUnaryOperation } from "../core/CellFilterUnaryOperation.js";
+import { write_cell_filter_to_sampler2d } from "./util/write_cell_filter_to_sampler2d.js";
 
 export class CellFilterCache extends CellFilterUnaryOperation {
 
@@ -43,31 +44,13 @@ export class CellFilterCache extends CellFilterUnaryOperation {
         const target_w = this.scale * g_w;
         const target_h = this.scale * g_h;
 
-        const source = this.source;
         const cache = this.__cache;
 
         cache.resize(target_w, target_h);
 
-        const scale_1 = 1 / this.scale;
-
-        // console.time('Cache filter build');
-
-        let x = 0;
-        let y = 0;
-
-        for (y = 0; y < target_h; y++) {
-            const grid_y = y * scale_1;
-
-            for (x = 0; x < target_w; x++) {
-                const grid_x = x * scale_1;
-
-                const sampleValue = source.execute(grid, grid_x, grid_y, 0);
-
-                cache.writeChannel(x, y, 0, sampleValue);
-            }
-        }
-
-        // console.timeEnd('Cache filter build');
+        // the source has already been initialized by `super.initialize`, so this must not go through
+        // `populateSampler2DFromCellFilter` (which would re-initialize it with seed 0)
+        write_cell_filter_to_sampler2d(cache, this.source, grid);
     }
 
     execute(grid, x, y, rotation) {

package/src/generation/filtering/numeric/complex/CellFilterSimplexNoise.d.ts

@@ -19,7 +19,7 @@ export class CellFilterSimplexNoise extends CellFilter {
     static from(scale_x: number, scale_y: number, seed?: number): CellFilterSimplexNoise;
     /**
      * @private
-     * @type {function(x:number,y:number):number}
+     * @type {(x: number, y: number) => number}
      */
     private noise;
     /**

package/src/generation/filtering/numeric/complex/CellFilterSimplexNoise.js

@@ -10,7 +10,7 @@ export class CellFilterSimplexNoise extends CellFilter {
 
         /**
          * @private
-         * @type {function(x:number,y:number):number}
+         * @type {(x: number, y: number) => number}
          */
         noise = null;
 

package/src/generation/filtering/numeric/complex/CellFilterSobel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"CellFilterSobel.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterSobel.js"],"names":[],"mappings":"AAGA;;GAEG;AACH;IAaI;;;;OAIG;IACH,oBAHW,UAAU,GACR,eAAe,CAU3B;IAxBD;;;OAGG;IACH,QAFU,UAAU,CAEN;IAsBd,0DAuBC;CACJ;2BA1D0B,qBAAqB"}
+{"version":3,"file":"CellFilterSobel.d.ts","sourceRoot":"","sources":["../../../../../../src/generation/filtering/numeric/complex/CellFilterSobel.js"],"names":[],"mappings":"AAWA;;GAEG;AACH;IAaI;;;;OAIG;IACH,oBAHW,UAAU,GACR,eAAe,CAU3B;IAxBD;;;OAGG;IACH,QAFU,UAAU,CAEN;IAsBd,0DAMC;CACJ;2BAjD0B,qBAAqB"}

package/src/generation/filtering/numeric/complex/CellFilterSobel.js

@@ -1,5 +1,13 @@
 import { CellFilter } from "../../CellFilter.js";
 import { assert } from "../../../../core/assert.js";
+import { v2_length } from "../../../../core/geom/vec2/v2_length.js";
+import { computeCellFilterSobel } from "../process/computeCellFilterSobel.js";
+
+/**
+ * Scratch for the raw gradient. Read out before returning, so it cannot alias across nested filters.
+ * @type {Float64Array}
+ */
+const scratch_gradient = new Float64Array(2);
 
 /**
  * Sobel edge-detection filter
@@ -33,27 +41,10 @@ export class CellFilterSobel extends CellFilter {
     }
 
     execute(grid, x, y, rotation) {
-        const filter = this.source;
-
-        //read surrounding points
-        const topLeft = filter.execute(grid, x - 1, y - 1, 0);
-        const top = filter.execute(grid, x, y - 1, 0);
-        const topRight = filter.execute(grid, x + 1, y - 1, 0);
-
-        const left = filter.execute(grid, x - 1, y, 0);
-        const right = filter.execute(grid, x + 1, y, 0);
-
-        const bottomLeft = filter.execute(grid, x - 1, y + 1, 0);
-        const bottom = filter.execute(grid, x, y + 1, 0);
-        const bottomRight = filter.execute(grid, x + 1, y + 1, 0);
-
-        // compute gradients
-        const dX = (topRight + 2.0 * right + bottomRight) - (topLeft + 2.0 * left + bottomLeft);
-        const dY = (bottomLeft + 2.0 * bottom + bottomRight) - (topLeft + 2.0 * top + topRight);
 
-        //normalize vector
-        const magnitude = Math.sqrt(dX * dX + dY * dY);
+        computeCellFilterSobel(scratch_gradient, 0, this.source, grid, x, y);
 
-        return magnitude;
+        //edge strength is the gradient magnitude, the direction is discarded
+        return v2_length(scratch_gradient[0], scratch_gradient[1]);
     }
 }