@woosh/meep-engine 3.38.0 → 3.39.0

package/src/engine/graphics3/WaterSystem.js

@@ -1,9 +1,15 @@
 import { assert } from "../../core/assert.js";
 import Water from "../graphics/ecs/water/Water.js";
+import WaterWaves from "../graphics/ecs/water/WaterWaves.js";
 import { WATER_SIZE } from "../graphics/ecs/water/WATER_SIZE.js";
 import { obtainTerrain } from "../ecs/terrain/util/obtainTerrain.js";
 import { System } from "../ecs/System.js";
+import { ResourceAccessKind } from "../../core/model/ResourceAccessKind.js";
+import { ResourceAccessSpecification } from "../../core/model/ResourceAccessSpecification.js";
 import { GPUWaterRenderer } from "../../shade/renderer/water/GPUWaterRenderer.js";
+import { GPUWaterBodies } from "../../shade/renderer/water/medium/GPUWaterBodies.js";
+import { GPUWaterWaveSimulation } from "../../shade/renderer/water/surface/GPUWaterWaveSimulation.js";
+import { WATER_WAVE_IMPULSE_LIMIT } from "../../shade/renderer/water/surface/WATER_WAVE_PARAMETERS_STRUCT.js";
 import { water_height_texture_from_sampler } from "../../shade/renderer/water/water_height_texture_from_sampler.js";
 import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
@@ -21,6 +27,11 @@ import { SceneColor } from "../../shade/renderer/extension/SceneColor.js";
 export class WaterSystem extends System {
     dependencies = [Water];
 
+    components_used = [
+        // optional: drives the surface producer when present, calm water when not
+        ResourceAccessSpecification.from(WaterWaves, ResourceAccessKind.Read),
+    ];
+
     /**
      * @type {GraphicsEngine}
      */
@@ -31,6 +42,22 @@ export class WaterSystem extends System {
      */
     #renderer = new GPUWaterRenderer();
 
+    /**
+     * The surface producer: the primitive wave simulation, behind the surface interface the water
+     * draws read (WATER_OPTICS_PLAN_2026_10_02.md §7.2).
+     *
+     * @type {GPUWaterWaveSimulation}
+     */
+    #waves = new GPUWaterWaveSimulation();
+
+    /**
+     * The frame's water bodies on the GPU: each one's medium and surface optics, read by every pass
+     * that lights water.
+     *
+     * @type {GPUWaterBodies}
+     */
+    #bodies = new GPUWaterBodies();
+
     /**
      * What the pass draws, in link order.
      *
@@ -48,8 +75,18 @@ export class WaterSystem extends System {
      */
     #extension = null;
 
+    /**
+     * Records the surface producer at the head of each frame.
+     *
+     * @type {RenderExtension|null}
+     */
+    #surface_extension = null;
+
     get settings() { return this.#renderer.settings; }
 
+    /** The surface producer, for settings such as its grid resolution. */
+    get waves() { return this.#waves; }
+
     /** The registered channel, for diagnostics such as testing registration order. */
     get transparency_channel() { return this.#renderer; }
 
@@ -94,8 +131,10 @@ export class WaterSystem extends System {
         this.entityManager = entityManager;
 
         this.#renderer.surfaces = this.#surfaces;
+        this.#renderer.bodies = this.#bodies;
         this.#graphics.add_transparency_channel(this.#renderer);
         this.#extension = this.#graphics.add_extension(new WaterExtension(this));
+        this.#surface_extension = this.#graphics.add_extension(new WaterSurfaceExtension(this));
     }
 
     async shutdown(entityManager) {
@@ -106,6 +145,13 @@ export class WaterSystem extends System {
 
             this.#extension = null;
         }
+        if (this.#surface_extension !== null) {
+            this.#graphics.remove_extension(this.#surface_extension);
+
+            this.#surface_extension = null;
+        }
+        this.#waves.dispose();
+        this.#bodies.dispose();
 
         this.#surfaces.length = 0;
         this.#entries.clear();
@@ -119,6 +165,52 @@ export class WaterSystem extends System {
         if (inspection !== undefined) { frame.get(SceneColor).color = inspection; }
     }
 
+    /**
+     * Record the surface producer: this frame's wave steps and the surface interface every water
+     * pass reads. At the head of the frame, so everything that reads it is recorded after.
+     *
+     * @param {FrameContext} frame
+     */
+    record_surface(frame) {
+        const renderer = this.#graphics.renderer;
+
+        if (renderer === null || renderer === undefined) {
+            return;
+        }
+
+        const device = renderer.graphics.device;
+
+        this.#waves.record({ graph: frame.graph, device, surfaces: this.#surfaces });
+        this.#bodies.record({ graph: frame.graph, device, surfaces: this.#surfaces });
+    }
+
+    /**
+     * Kick the surface of an entity's water, as a boat or a splash would: a vertical velocity
+     * `strength` m/s at `position`, falling off over `radius` m. Applied on the next frame that
+     * steps; at most {@link WATER_WAVE_IMPULSE_LIMIT} a frame per body, the rest wait for the
+     * following frames.
+     *
+     * @param {number} entity the entity carrying the {@link Water}
+     * @param {number[]} position world x, y, z; y is ignored
+     * @param {number} radius m
+     * @param {number} strength m/s, positive upwards
+     */
+    splash(entity, position, radius, strength) {
+        assert.isNonNegativeInteger(entity, 'entity');
+        assert.isArrayLike(position, 'position');
+        assert.isFinite(position[0], 'position[0]');
+        assert.isFinite(position[2], 'position[2]');
+        assert.isFinite(radius, 'radius');
+        assert.greaterThan(radius, 0, 'radius');
+        assert.isFinite(strength, 'strength');
+
+        const surface = this.#entries.get(entity);
+
+        assert.defined(surface, 'surface');
+
+        surface.impulses.push([position[0], position[2], radius, strength]);
+    }
+
     /**
      * @param {Water} water
      * @param {number} entity
@@ -128,20 +220,20 @@ export class WaterSystem extends System {
             entity,
             visible: true,
             level: water.level.getValue(),
+            ior: 1,
+            roughness: 0,
+            medium: water.medium,
+            body_index: 0,
             time: this.#time,
             extent: new Float32Array(4),
             height_uv: new Float32Array([0, 0, 1, 1]),
-            color_deep: new Float32Array(3),
-            color_shore: new Float32Array(3),
-            wave_amplitude: water.waveAmplitude.getValue(),
-            wave_speed: water.waveSpeed.getValue(),
-            wave_frequency: water.waveFrequency.getValue(),
-            scattering: water.scattering.getValue(),
-            shore_transition: new Float32Array(2),
-            extinction: new Float32Array(3),
             height_texture: null,
             height_data: null,
             height_version: -1,
+            wind_speed: 0,
+            wind_direction: 0,
+            impulses: [],
+            gpu_surface: undefined,
             component: water
         };
 
@@ -176,6 +268,7 @@ export class WaterSystem extends System {
 
     update(timeDelta) {
         this.#time += timeDelta;
+        this.#waves.advance(timeDelta);
 
         for (const surface of this.#entries.values()) {
             surface.time = this.#time;
@@ -201,26 +294,14 @@ export class WaterSystem extends System {
      */
     #refresh(surface, water) {
         surface.level = water.level.getValue();
-        surface.wave_amplitude = water.waveAmplitude.getValue();
-        surface.wave_speed = water.waveSpeed.getValue();
-        surface.wave_frequency = water.waveFrequency.getValue();
-        surface.scattering = water.scattering.getValue();
         surface.ior = Math.max(1, water.ior.getValue());
-        surface.normal_strength = Math.max(0, water.opticalNormalStrength.getValue());
-        surface.normal_scale = Math.max(0.01, water.opticalNormalScale.getValue());
-        surface.roughness = Math.min(1, Math.max(0, water.reflectionRoughness.getValue()));
-        surface.extinction.set([water.extinction.x, water.extinction.y, water.extinction.z]);
-
-        surface.color_deep[0] = water.color.r;
-        surface.color_deep[1] = water.color.g;
-        surface.color_deep[2] = water.color.b;
+        surface.roughness = Math.min(1, Math.max(0, water.roughness.getValue()));
+        surface.medium = water.medium;
 
-        surface.color_shore[0] = water.shoreColor.r;
-        surface.color_shore[1] = water.shoreColor.g;
-        surface.color_shore[2] = water.shoreColor.b;
+        const waves = this.entityManager.dataset.getComponent(surface.entity, WaterWaves);
 
-        surface.shore_transition[0] = water.shoreDepthTransition.min;
-        surface.shore_transition[1] = water.shoreDepthTransition.max;
+        surface.wind_speed = waves === undefined ? 0 : Math.max(0, waves.windSpeed.getValue());
+        surface.wind_direction = waves === undefined ? 0 : waves.windDirection.getValue();
 
         const terrain = obtainTerrain(this.entityManager.dataset);
 
@@ -312,3 +393,31 @@ export class WaterExtension extends RenderExtension {
         this.#system.record(frame);
     }
 }
+
+/**
+ * Records the water surface producer at {@link FramePhase.FrameStart}, so the surface exists before
+ * anything in the frame reads it.
+ */
+export class WaterSurfaceExtension extends RenderExtension {
+    name = "water surface";
+
+    phase = FramePhase.FrameStart;
+
+    /**
+     * @type {WaterSystem}
+     */
+    #system;
+
+    /**
+     * @param {WaterSystem} system
+     */
+    constructor(system) {
+        super();
+
+        this.#system = system;
+    }
+
+    record(frame) {
+        this.#system.record_surface(frame);
+    }
+}

package/src/engine/interpolation/BinaryInterpolationAdapter.d.ts

@@ -22,7 +22,7 @@ export const InterpolationKind: Readonly<{
 }>;
 /**
  * Per-component-type interpolator: reads two encoded snapshots of one
- * component from `source`, blends by `t`, writes the result to
+ * component from `source`, blends them, writes the result to
  * `out_buffer` in the SAME wire format so the receiver can deserialize
  * directly via the corresponding `BinaryClassSerializationAdapter`.
  *
@@ -45,14 +45,20 @@ export class BinaryInterpolationAdapter {
      *
      * `first_offset === second_offset` is the degenerate "snap to single
      * snapshot" case — implementations don't need to special-case it; the
-     * blend at any `t` reduces to the input.
+     * blend at any fraction reduces to the input.
+     *
+     * The blend fraction arrives in an array, `blend[blend_offset]`, not as a
+     * number: a caller blends every entity of a frame at the same fraction, and
+     * a number handed to a call V8 does not inline is boxed into a new heap
+     * object on every call, where an array is handed over as it is.
      *
      * @param {BinaryBuffer} out_buffer
      * @param {BinaryBuffer} source
      * @param {number} first_offset byte position of snapshot A
      * @param {number} second_offset byte position of snapshot B
-     * @param {number} t blend fraction in [0, 1]; 0 ⇒ A, 1 ⇒ B
+     * @param {Float64Array} blend holds the blend fraction, in [0, 1]; 0 ⇒ A, 1 ⇒ B
+     * @param {number} blend_offset index of the fraction in `blend`
      */
-    interpolate(out_buffer: BinaryBuffer, source: BinaryBuffer, first_offset: number, second_offset: number, t: number): void;
+    interpolate(out_buffer: BinaryBuffer, source: BinaryBuffer, first_offset: number, second_offset: number, blend: Float64Array, blend_offset: number): void;
 }
 //# sourceMappingURL=BinaryInterpolationAdapter.d.ts.map

package/src/engine/interpolation/BinaryInterpolationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"BinaryInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/BinaryInterpolationAdapter.js"],"names":[],"mappings":";;;;;gCAMU,MAAM;AANhB;;;;;;;GAOG;AACH;IACI,gEAAgE;;IAEhE,qEAAqE;;IAErE,+DAA+D;;GAEhE;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAEI,sDAAsD;IACtD,MADW,MAAM,CACe;IAEhC;;;;;;;;;;;;;OAaG;IACH,0EAJW,MAAM,iBACN,MAAM,KACN,MAAM,QAIhB;CACJ"}
+{"version":3,"file":"BinaryInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/BinaryInterpolationAdapter.js"],"names":[],"mappings":";;;;;gCAMU,MAAM;AANhB;;;;;;;GAOG;AACH;IACI,gEAAgE;;IAEhE,qEAAqE;;IAErE,+DAA+D;;GAEhE;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAEI,sDAAsD;IACtD,MADW,MAAM,CACe;IAEhC;;;;;;;;;;;;;;;;;;;OAmBG;IACH,0EALW,MAAM,iBACN,MAAM,SACN,YAAY,gBACZ,MAAM,QAIhB;CACJ"}

package/src/engine/interpolation/BinaryInterpolationAdapter.js

@@ -17,7 +17,7 @@ export const InterpolationKind = Object.freeze({
 
 /**
  * Per-component-type interpolator: reads two encoded snapshots of one
- * component from `source`, blends by `t`, writes the result to
+ * component from `source`, blends them, writes the result to
  * `out_buffer` in the SAME wire format so the receiver can deserialize
  * directly via the corresponding `BinaryClassSerializationAdapter`.
  *
@@ -42,15 +42,21 @@ export class BinaryInterpolationAdapter {
      *
      * `first_offset === second_offset` is the degenerate "snap to single
      * snapshot" case — implementations don't need to special-case it; the
-     * blend at any `t` reduces to the input.
+     * blend at any fraction reduces to the input.
+     *
+     * The blend fraction arrives in an array, `blend[blend_offset]`, not as a
+     * number: a caller blends every entity of a frame at the same fraction, and
+     * a number handed to a call V8 does not inline is boxed into a new heap
+     * object on every call, where an array is handed over as it is.
      *
      * @param {BinaryBuffer} out_buffer
      * @param {BinaryBuffer} source
      * @param {number} first_offset byte position of snapshot A
      * @param {number} second_offset byte position of snapshot B
-     * @param {number} t blend fraction in [0, 1]; 0 ⇒ A, 1 ⇒ B
+     * @param {Float64Array} blend holds the blend fraction, in [0, 1]; 0 ⇒ A, 1 ⇒ B
+     * @param {number} blend_offset index of the fraction in `blend`
      */
-    interpolate(out_buffer, source, first_offset, second_offset, t) {
-        throw new Error('BinaryInterpolationAdapter subclasses must override interpolate(out, src, off_a, off_b, t).');
+    interpolate(out_buffer, source, first_offset, second_offset, blend, blend_offset) {
+        throw new Error('BinaryInterpolationAdapter subclasses must override interpolate(out, src, off_a, off_b, blend, blend_offset).');
     }
 }

package/src/engine/interpolation/InterpolationLog.d.ts

@@ -40,7 +40,8 @@
  *
  * Typical render-time use:
  * ```
- *   const ok = log.interpolate(out_buffer, network_id, type_id, tick_a, tick_b, t, adapter);
+ *   blend[0] = t; // a Float64Array the caller keeps
+ *   const ok = log.interpolate(out_buffer, network_id, type_id, tick_a, tick_b, blend, 0, adapter);
  *   if (ok) { /* deserialize from out_buffer into the live component }
  * ```
  *
@@ -129,21 +130,26 @@ export class InterpolationLog {
      * result to `out_buffer` at its current position.
      *
      * Outcome by available data:
-     *   - Both ticks carry the component → adapter blends them at `t`.
+     *   - Both ticks carry the component → adapter blends them at
+     *     `blend[blend_offset]`.
      *   - Only one carries it → adapter is called with the same offset twice
-     *     (snap to the surviving snapshot; `t` is irrelevant).
+     *     (snap to the surviving snapshot; the fraction is irrelevant).
      *   - Neither carries it → returns false; `out_buffer` is unchanged.
      *
+     * The fraction is passed in an array and handed on to the adapter as it
+     * is: see {@link BinaryInterpolationAdapter#interpolate} for why.
+     *
      * @param {BinaryBuffer} out_buffer
      * @param {number} network_id
      * @param {number} type_id
      * @param {number} tick_a
      * @param {number} tick_b
-     * @param {number} t
+     * @param {Float64Array} blend holds the blend fraction, in [0, 1]; 0 ⇒ `tick_a`, 1 ⇒ `tick_b`
+     * @param {number} blend_offset index of the fraction in `blend`
      * @param {BinaryInterpolationAdapter} adapter
      * @returns {boolean} true if a payload was written; false if neither tick has the component
      */
-    interpolate(out_buffer: BinaryBuffer, network_id: number, type_id: number, tick_a: number, tick_b: number, t: number, adapter: BinaryInterpolationAdapter): boolean;
+    interpolate(out_buffer: BinaryBuffer, network_id: number, type_id: number, tick_a: number, tick_b: number, blend: Float64Array, blend_offset: number, adapter: BinaryInterpolationAdapter): boolean;
     /**
      * Replace one closed record's payload in place, with a payload of the same length.
      *

package/src/engine/interpolation/InterpolationLog.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationLog.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationLog.js"],"names":[],"mappings":"AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IA+CI;;;;;OAKG;IACH,0DALW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EAkDvE;IA9BG,kFAAkF;IAClF,iBADwE,MAAM,CAClC;IAY5C,+EAA+E;IAC/E,kBADqE,MAAM,CACnC;IAkB5C;;;;;;;;OAQG;IACH,iBAFW,MAAM,QAkEhB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAJW,MAAM,WACN,MAAM,GACJ,YAAY,CAmCxB;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;;;OAOG;IACH,iBAeC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,YAPW,MAAM,EAAE,GAAC,WAAW,cACpB,MAAM,QACN,MAAM,cACN,MAAM,WACN,MAAM,GACJ,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;;;;OAkBG;IACH,wBATW,YAAY,cACZ,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,KACN,MAAM,wCAEJ,OAAO,CAuBnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cANW,MAAM,cACN,MAAM,WACN,MAAM,aACN,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC5B,OAAO,CAyBnB;IAED;;;;;;;OAOG;IACH,+BAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBAHW,MAAM,GACJ,OAAO,CAqCnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,cASC;;CACJ;6BAprB4B,mCAAmC"}
+{"version":3,"file":"InterpolationLog.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationLog.js"],"names":[],"mappings":"AAqFA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IA+CI;;;;;OAKG;IACH,0DALW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EAkDvE;IA9BG,kFAAkF;IAClF,iBADwE,MAAM,CAClC;IAY5C,+EAA+E;IAC/E,kBADqE,MAAM,CACnC;IAkB5C;;;;;;;;OAQG;IACH,iBAFW,MAAM,QAkEhB;IAED;;;;;;;;;;;;;OAaG;IACH,yBAJW,MAAM,WACN,MAAM,GACJ,YAAY,CAmCxB;IAED;;;;;OAKG;IACH,mBAsDC;IAED;;;;;;;OAOG;IACH,iBAeC;IAED;;;OAGG;IACH,eAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;;;;;;;OAcG;IACH,YAPW,MAAM,EAAE,GAAC,WAAW,cACpB,MAAM,QACN,MAAM,cACN,MAAM,WACN,MAAM,GACJ,OAAO,CA+BnB;IAED;;;;;;;;;;;;;;;;;;;;;;;OAuBG;IACH,wBAVW,YAAY,cACZ,MAAM,WACN,MAAM,UACN,MAAM,UACN,MAAM,SACN,YAAY,gBACZ,MAAM,wCAEJ,OAAO,CAuBnB;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH,cANW,MAAM,cACN,MAAM,WACN,MAAM,aACN,CAAC,MAAM,EAAE,YAAY,KAAK,IAAI,GAC5B,OAAO,CAyBnB;IAED;;;;;;;OAOG;IACH,+BAHW,MAAM,GACJ,MAAM,CAgBlB;IAED;;;;;;;;;;;;;;;OAeG;IACH,yBAHW,MAAM,GACJ,OAAO,CAqCnB;IAED;;;OAGG;IACH,QAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,eAFa,MAAM,CAIlB;IAED;;;OAGG;IACH,cASC;;CACJ;6BA1rB4B,mCAAmC"}

package/src/engine/interpolation/InterpolationLog.js

@@ -125,7 +125,8 @@ function bloom_contains(table, base, key) {
  *
  * Typical render-time use:
  * ```
- *   const ok = log.interpolate(out_buffer, network_id, type_id, tick_a, tick_b, t, adapter);
+ *   blend[0] = t; // a Float64Array the caller keeps
+ *   const ok = log.interpolate(out_buffer, network_id, type_id, tick_a, tick_b, blend, 0, adapter);
  *   if (ok) { /* deserialize from out_buffer into the live component }
  * ```
  *
@@ -502,21 +503,26 @@ export class InterpolationLog {
      * result to `out_buffer` at its current position.
      *
      * Outcome by available data:
-     *   - Both ticks carry the component → adapter blends them at `t`.
+     *   - Both ticks carry the component → adapter blends them at
+     *     `blend[blend_offset]`.
      *   - Only one carries it → adapter is called with the same offset twice
-     *     (snap to the surviving snapshot; `t` is irrelevant).
+     *     (snap to the surviving snapshot; the fraction is irrelevant).
      *   - Neither carries it → returns false; `out_buffer` is unchanged.
      *
+     * The fraction is passed in an array and handed on to the adapter as it
+     * is: see {@link BinaryInterpolationAdapter#interpolate} for why.
+     *
      * @param {BinaryBuffer} out_buffer
      * @param {number} network_id
      * @param {number} type_id
      * @param {number} tick_a
      * @param {number} tick_b
-     * @param {number} t
+     * @param {Float64Array} blend holds the blend fraction, in [0, 1]; 0 ⇒ `tick_a`, 1 ⇒ `tick_b`
+     * @param {number} blend_offset index of the fraction in `blend`
      * @param {BinaryInterpolationAdapter} adapter
      * @returns {boolean} true if a payload was written; false if neither tick has the component
      */
-    interpolate(out_buffer, network_id, type_id, tick_a, tick_b, t, adapter) {
+    interpolate(out_buffer, network_id, type_id, tick_a, tick_b, blend, blend_offset, adapter) {
         const a = this.locate(scratch_u32, 4, tick_a, network_id, type_id);
         const b = this.locate(scratch_u32, 6, tick_b, network_id, type_id);
 
@@ -533,7 +539,7 @@ export class InterpolationLog {
         // surprised by a moved cursor.
         const buffer = this.#buffer;
         const saved = buffer.position;
-        adapter.interpolate(out_buffer, buffer, first, second, t);
+        adapter.interpolate(out_buffer, buffer, first, second, blend, blend_offset);
         buffer.position = saved;
 
         return true;

package/src/engine/interpolation/InterpolationSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;GAWG;AACH,yCAHW,WAAW,4EACX,YAAY,QAgBtB;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IAoGI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA2BvE;IA9HD,sCAA8B;IAC9B,wHAIE;IAEF;;;;OAIG;IACH,mBAAuB;IAEvB;;;;;;;OAOG;IACH,kBAAsB;IAEtB;;;;;OAKG;IACH,yBAA6B;IA0EzB;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;OAIG;IACH,kBAAmC;IAGnC;;;;OAIG;IACH,gBAAiC;IAIrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAc7D;IAED;;;OAGG;IACH,oBAFa,MAAM,CAOlB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qDAEC;IAED;;OAEG;IACH,sDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAchB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAYC;IAED;;;;;;;;;OASG;IACH,eA6BC;IA2OD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAkCnB;IAuED,sBA0HC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;;CANlD;4BA11B2B,iCAAiC;uBADtC,kBAAkB;6BAIyC,mBAAmB;4CALzD,iDAAiD;iCAI5D,uBAAuB"}
+{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAqBA;;;;;;;;;;;GAWG;AACH,yCAHW,WAAW,4EACX,YAAY,QAgBtB;AAoBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH;IA4GI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA2BvE;IAtID,sCAA8B;IAC9B,wHAIE;IAEF;;;;OAIG;IACH,mBAAuB;IAEvB;;;;;;;OAOG;IACH,kBAAsB;IAEtB;;;;;OAKG;IACH,yBAA6B;IAkFzB;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;OAIG;IACH,kBAAmC;IAGnC;;;;OAIG;IACH,gBAAiC;IAIrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAc7D;IAED;;;OAGG;IACH,oBAFa,MAAM,CAOlB;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qDAEC;IAED;;OAEG;IACH,sDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAchB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAUhB;IAED;;;;OAIG;IACH,gBAcC;IAED;;;;;;;;;OASG;IACH,eAiCC;IAkPD;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,gBAVW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,OACN,MAAM,GACJ,OAAO,CAkCnB;IAuED,sBA8HC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;;CANlD;4BAz3B2B,iCAAiC;uBADtC,kBAAkB;6BAIyC,mBAAmB;4CALzD,iDAAiD;iCAI5D,uBAAuB"}

package/src/engine/interpolation/InterpolationSystem.js

@@ -13,6 +13,12 @@ import { Interpolated, INTERPOLATION_KEY_UNSET, INTERPOLATION_SOURCE_LOCAL } fro
  */
 const LOCAL_HISTORY_TICKS = 8;
 
+/**
+ * A blend fraction of zero, `[0]`, for reading one tick back out of the log unblended. Never written.
+ * @type {Float64Array}
+ */
+const NO_BLEND = new Float64Array(1);
+
 /**
  * Move `t` by `(dx, dy, dz)` and turn it by the unit quaternion `(ex, ey, ez, ew)` in its own
  * frame — on the right, `q' = q * e`.
@@ -195,6 +201,14 @@ export class InterpolationSystem extends System {
     /** @type {Float64Array} */
     #quat_scratch = new Float64Array(4);
 
+    /**
+     * The blend fraction {@link update} hands the log, `[t]`: written before each blend and passed
+     * as an array, since a fraction passed as a number to the log and on to its adapter is boxed
+     * into a heap object on every call V8 does not inline.
+     * @type {Float64Array}
+     */
+    #blend = new Float64Array(1);
+
     /**
      * @param {{ buffer_capacity_bytes?: number, records_capacity?: number }} [options]
      */
@@ -330,8 +344,10 @@ export class InterpolationSystem extends System {
             return;
         }
 
-        for (const [entity, slots] of displaced) {
-            this.#restore_slots(entity, slots, this.__entities.get(entity));
+        // Keys, then a lookup, as every Map walk in this system: destructuring the Map's own entries
+        // builds a [key, value] array for each one, every frame and every step.
+        for (const entity of displaced.keys()) {
+            this.#restore_slots(entity, displaced.get(entity), this.__entities.get(entity));
         }
 
         displaced.clear();
@@ -365,7 +381,11 @@ export class InterpolationSystem extends System {
             this.#record(completed);
         } else if (completed >= 0) {
             // already recorded (by a render update since); a teleport raised after that is not in it
-            for (const [entity, interpolated] of this.__entities) {
+            const entities = this.__entities;
+
+            for (const entity of entities.keys()) {
+                const interpolated = entities.get(entity);
+
                 if (interpolated.snap && interpolated.sourceId === INTERPOLATION_SOURCE_LOCAL) {
                     this.#rewrite_with_live(entity, interpolated, completed);
                 }
@@ -429,9 +449,12 @@ export class InterpolationSystem extends System {
             }
 
             this.#release(slot);
+
+            slots[i] = null;
         }
 
-        slots.length = 0;
+        // Emptied slot by slot, not truncated: `slots.length = 0` drops the backing store, and the
+        // next entity to take this array from the pool allocated a new one on its first push.
         this.#slots_pool.push(slots);
     }
 
@@ -538,7 +561,11 @@ export class InterpolationSystem extends System {
 
         let open = false;
 
-        for (const [entity, interpolated] of this.__entities) {
+        const entities = this.__entities;
+
+        for (const entity of entities.keys()) {
+            const interpolated = entities.get(entity);
+
             if (interpolated.sourceId !== INTERPOLATION_SOURCE_LOCAL) {
                 continue;
             }
@@ -678,7 +705,7 @@ export class InterpolationSystem extends System {
         const scratch = this.__scratch;
 
         scratch.position = 0;
-        if (!log.interpolate(scratch, key, interpoland.type_id, tick, tick, 0, interpoland.interpolation_adapter)) {
+        if (!log.interpolate(scratch, key, interpoland.type_id, tick, tick, NO_BLEND, 0, interpoland.interpolation_adapter)) {
             return;
         }
 
@@ -753,6 +780,7 @@ export class InterpolationSystem extends System {
         this.#record(em.fixedStepTick);
 
         const scratch = this.__scratch;
+        const blend = this.#blend;
 
         // Default (local) timeline: blend the last two completed fixed steps at
         // the sub-step alpha, reading this system's own log.
@@ -767,7 +795,8 @@ export class InterpolationSystem extends System {
 
         this.#decay_offsets(dt);
 
-        for (const [entity, interpolated] of entities) {
+        for (const entity of entities.keys()) {
+            const interpolated = entities.get(entity);
             const key = interpolated.key;
             if (key === INTERPOLATION_KEY_UNSET) {
                 continue;
@@ -832,8 +861,10 @@ export class InterpolationSystem extends System {
                 const interpoland = interpolands[i];
 
                 scratch.position = 0;
+                blend[0] = t;
+
                 const ok = log.interpolate(
-                    scratch, key, interpoland.type_id, tick_a, tick_b, t, interpoland.interpolation_adapter
+                    scratch, key, interpoland.type_id, tick_a, tick_b, blend, 0, interpoland.interpolation_adapter
                 );
                 if (!ok) {
                     // Neither tick carries this interpoland — leave the live

package/src/engine/interpolation/PoseInterpolationAdapter.d.ts

@@ -11,7 +11,7 @@
  */
 export class PoseInterpolationAdapter extends BinaryInterpolationAdapter {
     /** @inheritdoc */
-    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, t: any): void;
+    interpolate(out_buffer: any, source: any, first_offset: any, second_offset: any, blend: any, blend_offset: any): void;
 }
 import { BinaryInterpolationAdapter } from "./BinaryInterpolationAdapter.js";
 //# sourceMappingURL=PoseInterpolationAdapter.d.ts.map

package/src/engine/interpolation/PoseInterpolationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PoseInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/PoseInterpolationAdapter.js"],"names":[],"mappings":"AAEA;;;;;;;;;;GAUG;AACH;IAEI,kBAAkB;IAClB,+FA2CC;CACJ;2CA5D0C,iCAAiC"}
+{"version":3,"file":"PoseInterpolationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/PoseInterpolationAdapter.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AACH;IAEI,kBAAkB;IAClB,sHAuDC;CACJ;2CAzF0C,iCAAiC"}

package/src/engine/interpolation/PoseInterpolationAdapter.js

@@ -1,5 +1,22 @@
 import { BinaryInterpolationAdapter } from "./BinaryInterpolationAdapter.js";
 
+/**
+ * The two snapshots {@link PoseInterpolationAdapter#interpolate} blends, read out of the log as
+ * arrays: `[x, y, z, qx, qy, qz, qw]` of the first, then of the second. Read one number at a time,
+ * the fourteen reads took 574 of the 920 bytes of bytecode V8 will inline into one function, the
+ * last of the seven writes of the blend no longer fitted, and it was called out of line with its
+ * number boxed into a heap object.
+ * @type {Float64Array}
+ */
+const scratch_snapshots = new Float64Array(14);
+
+/**
+ * The blend {@link PoseInterpolationAdapter#interpolate} writes, `[x, y, z, qx, qy, qz, qw]`, handed to
+ * the buffer as one array rather than as seven numbers to seven calls.
+ * @type {Float64Array}
+ */
+const scratch_blend = new Float64Array(7);
+
 /**
  * Linear-blend interpolator matching {@link TransformPoseSerializationAdapter}'s
  * layout (7 × Float64: position xyz + rotation xyzw). Position lerps
@@ -14,24 +31,32 @@ import { BinaryInterpolationAdapter } from "./BinaryInterpolationAdapter.js";
 export class PoseInterpolationAdapter extends BinaryInterpolationAdapter {
 
     /** @inheritdoc */
-    interpolate(out_buffer, source, first_offset, second_offset, t) {
+    interpolate(out_buffer, source, first_offset, second_offset, blend, blend_offset) {
+        const t = blend[blend_offset];
+
+        const s = scratch_snapshots;
+
         source.position = first_offset;
-        const ax = source.readFloat64();
-        const ay = source.readFloat64();
-        const az = source.readFloat64();
-        const aqx = source.readFloat64();
-        const aqy = source.readFloat64();
-        const aqz = source.readFloat64();
-        const aqw = source.readFloat64();
+        source.readFloat64Array(s, 0, 7);
 
         source.position = second_offset;
-        const bx = source.readFloat64();
-        const by = source.readFloat64();
-        const bz = source.readFloat64();
-        let bqx = source.readFloat64();
-        let bqy = source.readFloat64();
-        let bqz = source.readFloat64();
-        let bqw = source.readFloat64();
+        source.readFloat64Array(s, 7, 7);
+
+        const ax = s[0];
+        const ay = s[1];
+        const az = s[2];
+        const aqx = s[3];
+        const aqy = s[4];
+        const aqz = s[5];
+        const aqw = s[6];
+
+        const bx = s[7];
+        const by = s[8];
+        const bz = s[9];
+        let bqx = s[10];
+        let bqy = s[11];
+        let bqz = s[12];
+        let bqw = s[13];
 
         // Position: componentwise lerp.
         const ox = ax + (bx - ax) * t;
@@ -50,12 +75,16 @@ export class PoseInterpolationAdapter extends BinaryInterpolationAdapter {
         const inv = len2 > 0 ? 1 / Math.sqrt(len2) : 1;
         qx *= inv; qy *= inv; qz *= inv; qw *= inv;
 
-        out_buffer.writeFloat64(ox);
-        out_buffer.writeFloat64(oy);
-        out_buffer.writeFloat64(oz);
-        out_buffer.writeFloat64(qx);
-        out_buffer.writeFloat64(qy);
-        out_buffer.writeFloat64(qz);
-        out_buffer.writeFloat64(qw);
+        const o = scratch_blend;
+
+        o[0] = ox;
+        o[1] = oy;
+        o[2] = oz;
+        o[3] = qx;
+        o[4] = qy;
+        o[5] = qz;
+        o[6] = qw;
+
+        out_buffer.writeFloat64Array(o, 0, 7);
     }
 }

package/src/engine/interpolation/TransformPoseSerializationAdapter.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TransformPoseSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/TransformPoseSerializationAdapter.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,0BAAoB;IAGpB;;;OAGG;IACH,2CAFW,WAAW,QAWrB;IAED;;;OAGG;IACH,6CAFW,WAAW,QAqBrB;CACJ;gDAlE+C,0DAA0D;4BAC9E,iCAAiC"}
+{"version":3,"file":"TransformPoseSerializationAdapter.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/TransformPoseSerializationAdapter.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;GAkBG;AACH;;IAEI,0BAAoB;IAGpB;;;OAGG;IACH,2CAFW,WAAW,QAOrB;IAED;;;OAGG;IACH,6CAFW,WAAW,QAgBrB;CACJ;gDA7D+C,0DAA0D;4BAKnG,iCAAiC"}