@woosh/meep-engine 3.28.0 → 3.30.0

package/src/engine/graphics3/FogOfWarSystem.js

@@ -1,10 +1,6 @@
 import { assert } from "../../core/assert.js";
 import { SignalBinding } from "../../core/events/signal/SignalBinding.js";
 import { GPUFogOfWarRenderer } from "../../shade/renderer/fow/GPUFogOfWarRenderer.js";
-import { HighlightExtension } from "./HighlightOutlineSystem.js";
-import { ParticleExtension } from "./ParticleEmitterSystem.js";
-import { PathDisplayExtension } from "./PathDisplaySystem.js";
-import { TrailExtension } from "./Trail3DSystem.js";
 import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
 import { SceneColor } from "../../shade/renderer/extension/SceneColor.js";
@@ -229,21 +225,21 @@ export class FogOfWarSystem extends System {
 }
 
 /**
- * **Last among the content extensions**, because the fog conceals and therefore belongs over
- * everything it is meant to conceal — particles, trails, the path display and the selection
- * highlight all draw before it and are all subject to it. Written down here rather than being a
- * property of where a registration call happened to sit, which is how it came to be wrong.
+ * **Late on the phase**, because the fog conceals and therefore belongs over everything it is meant
+ * to conceal — content drawn at the phase's default order is subject to it. Written down here
+ * rather than being a property of where a registration call happened to sit, which is how it came
+ * to be wrong.
  *
- * The declaration is stated from this side, over the content extensions, so that adding another one
- * is a change to that extension and not to this list. {@link DebugDrawExtension} is the one thing
- * that goes after the fog, and it says so itself.
+ * Nothing is named: a content extension added later is concealed because it sits at the default,
+ * not because a list here was updated. Whatever must not be concealed asks for a later order of its
+ * own.
  */
 export class FogOfWarExtension extends RenderExtension {
     name = "fog of war";
 
     phase = FramePhase.AfterTransparency;
 
-    after = [ParticleExtension, PathDisplayExtension, TrailExtension, HighlightExtension];
+    relative_order = 1;
 
     /**
      * @type {FogOfWarSystem}

package/src/engine/graphics3/prefab/prefab_instantiate.js

@@ -1,230 +1,230 @@
-import { assert } from "../../../core/assert.js";
-import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
-import { ShadeAnimationChannel } from "../../../shade/renderer/animation/ShadeAnimationChannel.js";
-import { ShadeAnimationClip } from "../../../shade/renderer/animation/ShadeAnimationClip.js";
-import { Skin } from "../../../shade/renderer/animation/Skin.js";
-import { SerializationMetadata } from "../../ecs/components/SerializationMetadata.js";
-import { GPUStateAuthority } from "../../ecs/gpu/GPUStateAuthority.js";
-import { Name } from "../../ecs/name/Name.js";
-import { ParentEntity } from "../../ecs/parent/ParentEntity.js";
-import { TransformAttachment } from "../../ecs/transform-attachment/TransformAttachment.js";
-import { Transform64 } from "../../ecs/transform/Transform64.js";
-import { DrawMode } from "../../graphics/ecs/mesh-v2/DrawMode.js";
-import { ShadedGeometry } from "../../graphics/ecs/mesh-v2/ShadedGeometry.js";
-import { ShadedGeometryFlags } from "../../graphics/ecs/mesh-v2/ShadedGeometryFlags.js";
-import { PrefabInstance } from "./PrefabInstance.js";
-
-/**
- * @typedef {import("./Prefab.js").Prefab} Prefab
- * @typedef {import("../../ecs/EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
- */
-
-/**
- * Every component type an instance may attach. Registered once per dataset, before the first
- * entity is built, because registering a type rebuilds the dataset's occupancy and a spawn of
- * thousands of entities must not do that per component.
- *
- * @type {Function[]}
- */
-const COMPONENT_TYPES = [
-    Transform64,
-    TransformAttachment,
-    Name,
-    ShadedGeometry,
-    GPUStateAuthority,
-    ParentEntity,
-    SerializationMetadata,
-];
-
-/**
- * Spawn a prefab as entities under `root`, in bulk.
- *
- * **What a model is in an ECS.** Each node of the prefab becomes an entity: named, attached to
- * its parent's entity by a `TransformAttachment` carrying the node's rest pose, holding a world
- * `Transform64` composed from the root's, drawing through a `ShadedGeometry` where the node
- * carries geometry, and declaring `GPUStateAuthority` — with a zero flags word — where a clip or a
- * skin may later hand the node to the GPU, so that the hand-over is a bit write and never a
- * component add. Node 0 is `root` itself, the caller's entity, whose `Transform64` is the
- * placement.
- *
- * **Parents before children, and the transform last.** Entities are built in the prefab's node
- * order, which puts every parent's entity there before its children's, so
- * `TransformAttachmentSystem` binds each one on the spot rather than parking it. The `Transform64`
- * is the last component added to each entity, so every system whose dependencies include it —
- * and they all do — links once, seeing the entity complete.
- *
- * Every entity is the root's for its lifetime (`ParentEntity`) and, unless told otherwise,
- * transient to serialization: a save holds the model's placement, not sixty joints of derived
- * state.
- *
- * @param {Prefab} prefab
- * @param {EntityComponentDataset} dataset
- * @param {number} root an entity carrying a `Transform64`
- * @param {object} [options]
- * @param {boolean} [options.transient] whether the spawned entities are skipped by serialization;
- * true unless said otherwise
- * @returns {PrefabInstance}
- */
-export function prefab_instantiate(prefab, dataset, root, { transient = true } = {}) {
-    assert.defined(prefab, 'prefab');
-    assert.equal(prefab.isPrefab, true, 'prefab.isPrefab !== true');
-    assert.defined(dataset, 'dataset');
-    assert.equal(dataset.isEntityComponentDataset, true, 'dataset.isEntityComponentDataset !== true');
-    assert.isNonNegativeInteger(root, 'root');
-    assert.ok(dataset.entityExists(root), `root entity ${root} does not exist`);
-
-    dataset.registerManyComponentTypes(COMPONENT_TYPES);
-
-    // Component indices resolved once: an add by index skips the class lookup and the guard that
-    // formats a component into an error message, and there are six or seven adds per entity.
-    const TRANSFORM = dataset.computeComponentTypeIndex(Transform64);
-    const ATTACHMENT = dataset.computeComponentTypeIndex(TransformAttachment);
-    const NAME = dataset.computeComponentTypeIndex(Name);
-    const GEOMETRY = dataset.computeComponentTypeIndex(ShadedGeometry);
-    const AUTHORITY = dataset.computeComponentTypeIndex(GPUStateAuthority);
-    const PARENT = dataset.computeComponentTypeIndex(ParentEntity);
-    const METADATA = dataset.computeComponentTypeIndex(SerializationMetadata);
-
-    const root_transform = dataset.getComponent(root, Transform64);
-
-    assert.defined(root_transform, `root entity ${root} carries no Transform64 to place the model by`);
-
-    const node_count = prefab.node_count;
-
-    const entities = new Int32Array(node_count);
-
-    entities[0] = root;
-
-    // Ids from the dataset's own occupancy, walking forward: `createEntity` scans from bit zero
-    // every time, which is quadratic over a spawn of this size.
-    const occupancy = dataset.entityOccupancy;
-
-    let cursor = 0;
-
-    for (let i = 1; i < node_count; i++) {
-        const entity = occupancy.nextClearBit(cursor);
-
-        dataset.createEntitySpecific(entity);
-
-        entities[i] = entity;
-        cursor = entity + 1;
-    }
-
-    const parent = prefab.parent;
-    const names = prefab.name;
-    const locals = prefab.local;
-    const worlds = prefab.world;
-    const animated = prefab.animated;
-
-    /**
-     * @type {Map<number, import("./Prefab.js").PrefabPrimitive>}
-     */
-    const primitive_of = new Map();
-
-    for (const primitive of prefab.primitives) {
-        primitive_of.set(primitive.node, primitive);
-    }
-
-    // One lifetime component for the whole instance: it names the root and nothing else, it is
-    // immutable while attached, and sixty copies of one number are sixty allocations for nothing.
-    const owner = ParentEntity.from(root);
-
-    for (let i = 1; i < node_count; i++) {
-        const entity = entities[i];
-
-        if (transient) {
-            dataset.addComponentToEntityByIndex(entity, METADATA, SerializationMetadata.Transient);
-        }
-
-        dataset.addComponentToEntityByIndex(entity, PARENT, owner);
-
-        const name = names[i];
-
-        if (name !== "") {
-            dataset.addComponentToEntityByIndex(entity, NAME, new Name(name));
-        }
-
-        if (animated[i] !== 0) {
-            dataset.addComponentToEntityByIndex(entity, AUTHORITY, new GPUStateAuthority());
-        }
-
-        const primitive = primitive_of.get(i);
-
-        if (primitive !== undefined) {
-            const geometry = ShadedGeometry.from(primitive.geometry, primitive.material, DrawMode.Triangles);
-
-            if (primitive.skin !== -1) {
-                geometry.setFlag(ShadedGeometryFlags.Skinned);
-            }
-
-            dataset.addComponentToEntityByIndex(entity, GEOMETRY, geometry);
-        }
-
-        const attachment = new TransformAttachment();
-
-        attachment.parent = entities[parent[i]];
-        attachment.transform.copy(locals[i]);
-
-        // The world is composed below, from the same chain the attachment system would compose
-        // it from, so the system is told not to compose it again at link: a decomposition per
-        // entity, and an announcement nothing is listening for yet. It still follows every move
-        // of the parent from then on.
-        attachment.immediate = false;
-
-        dataset.addComponentToEntityByIndex(entity, ATTACHMENT, attachment);
-
-        // Composed here rather than left to the attachment system, so that a dataset with no
-        // systems — a preview, a spec — holds every world too.
-        const world = new Transform64();
-
-        m4_multiply(world, root_transform, worlds[i]);
-        world.updateComponents();
-
-        dataset.addComponentToEntityByIndex(entity, TRANSFORM, world);
-    }
-
-    const instance = new PrefabInstance();
-
-    instance.prefab = prefab;
-    instance.root = root;
-    instance.entities = entities;
-    instance.mesh_entities = Int32Array.from(prefab.primitives, primitive => entities[primitive.node]);
-
-    instance.skins = prefab.skins.map(skin => Skin.from({
-        name: skin.name,
-        joints: Array.from(skin.joints, joint => entities[joint]),
-        inverse_bind_matrices: skin.inverse_bind_matrices,
-        meshes: Array.from(skin.meshes, mesh => entities[mesh]),
-    }));
-
-    instance.clips = prefab.clips.map(clip => ShadeAnimationClip.from({
-        name: clip.name,
-        channels: clip.channels.map(channel => ShadeAnimationChannel.from({
-            target: entities[channel.target],
-            property: channel.property,
-            curves: channel.curves,
-        })),
-    }));
-
-    return instance;
-}
-
-/**
- * Remove every entity an instance spawned. The root is the caller's and stays.
- *
- * Children before parents, so that no parent's removal has to reach down and detach a child
- * that is about to go anyway.
- *
- * @param {EntityComponentDataset} dataset
- * @param {PrefabInstance} instance
- */
-export function prefab_instance_destroy(dataset, instance) {
-    assert.defined(dataset, 'dataset');
-    assert.defined(instance, 'instance');
-
-    const entities = instance.entities;
-
-    for (let i = entities.length - 1; i >= 1; i--) {
-        dataset.removeEntity(entities[i]);
-    }
-}
+import { assert } from "../../../core/assert.js";
+import { m4_multiply } from "../../../core/geom/3d/mat4/m4_multiply.js";
+import { ShadeAnimationChannel } from "../../../shade/renderer/animation/ShadeAnimationChannel.js";
+import { ShadeAnimationClip } from "../../../shade/renderer/animation/ShadeAnimationClip.js";
+import { Skin } from "../../../shade/renderer/animation/Skin.js";
+import { SerializationMetadata } from "../../ecs/components/SerializationMetadata.js";
+import { GPUStateAuthority } from "../../ecs/gpu/GPUStateAuthority.js";
+import { Name } from "../../ecs/name/Name.js";
+import { ParentEntity } from "../../ecs/parent/ParentEntity.js";
+import { TransformAttachment } from "../../ecs/transform-attachment/TransformAttachment.js";
+import { Transform64 } from "../../ecs/transform/Transform64.js";
+import { DrawMode } from "../../graphics/ecs/mesh-v2/DrawMode.js";
+import { ShadedGeometry } from "../../graphics/ecs/mesh-v2/ShadedGeometry.js";
+import { ShadedGeometryFlags } from "../../graphics/ecs/mesh-v2/ShadedGeometryFlags.js";
+import { PrefabInstance } from "./PrefabInstance.js";
+
+/**
+ * @typedef {import("./Prefab.js").Prefab} Prefab
+ * @typedef {import("../../ecs/EntityComponentDataset.js").EntityComponentDataset} EntityComponentDataset
+ */
+
+/**
+ * Every component type an instance may attach. Registered once per dataset, before the first
+ * entity is built, because registering a type rebuilds the dataset's occupancy and a spawn of
+ * thousands of entities must not do that per component.
+ *
+ * @type {Function[]}
+ */
+const COMPONENT_TYPES = [
+    Transform64,
+    TransformAttachment,
+    Name,
+    ShadedGeometry,
+    GPUStateAuthority,
+    ParentEntity,
+    SerializationMetadata,
+];
+
+/**
+ * Spawn a prefab as entities under `root`, in bulk.
+ *
+ * **What a model is in an ECS.** Each node of the prefab becomes an entity: named, attached to
+ * its parent's entity by a `TransformAttachment` carrying the node's rest pose, holding a world
+ * `Transform64` composed from the root's, drawing through a `ShadedGeometry` where the node
+ * carries geometry, and declaring `GPUStateAuthority` — with a zero flags word — where a clip or a
+ * skin may later hand the node to the GPU, so that the hand-over is a bit write and never a
+ * component add. Node 0 is `root` itself, the caller's entity, whose `Transform64` is the
+ * placement.
+ *
+ * **Parents before children, and the transform last.** Entities are built in the prefab's node
+ * order, which puts every parent's entity there before its children's, so
+ * `TransformAttachmentSystem` binds each one on the spot rather than parking it. The `Transform64`
+ * is the last component added to each entity, so every system whose dependencies include it —
+ * and they all do — links once, seeing the entity complete.
+ *
+ * Every entity is the root's for its lifetime (`ParentEntity`) and, unless told otherwise,
+ * transient to serialization: a save holds the model's placement, not sixty joints of derived
+ * state.
+ *
+ * @param {Prefab} prefab
+ * @param {EntityComponentDataset} dataset
+ * @param {number} root an entity carrying a `Transform64`
+ * @param {object} [options]
+ * @param {boolean} [options.transient] whether the spawned entities are skipped by serialization;
+ * true unless said otherwise
+ * @returns {PrefabInstance}
+ */
+export function prefab_instantiate(prefab, dataset, root, { transient = true } = {}) {
+    assert.defined(prefab, 'prefab');
+    assert.equal(prefab.isPrefab, true, 'prefab.isPrefab !== true');
+    assert.defined(dataset, 'dataset');
+    assert.equal(dataset.isEntityComponentDataset, true, 'dataset.isEntityComponentDataset !== true');
+    assert.isNonNegativeInteger(root, 'root');
+    assert.ok(dataset.entityExists(root), `root entity ${root} does not exist`);
+
+    dataset.registerManyComponentTypes(COMPONENT_TYPES);
+
+    // Component indices resolved once: an add by index skips the class lookup and the guard that
+    // formats a component into an error message, and there are six or seven adds per entity.
+    const TRANSFORM = dataset.computeComponentTypeIndex(Transform64);
+    const ATTACHMENT = dataset.computeComponentTypeIndex(TransformAttachment);
+    const NAME = dataset.computeComponentTypeIndex(Name);
+    const GEOMETRY = dataset.computeComponentTypeIndex(ShadedGeometry);
+    const AUTHORITY = dataset.computeComponentTypeIndex(GPUStateAuthority);
+    const PARENT = dataset.computeComponentTypeIndex(ParentEntity);
+    const METADATA = dataset.computeComponentTypeIndex(SerializationMetadata);
+
+    const root_transform = dataset.getComponent(root, Transform64);
+
+    assert.defined(root_transform, `root entity ${root} carries no Transform64 to place the model by`);
+
+    const node_count = prefab.node_count;
+
+    const entities = new Int32Array(node_count);
+
+    entities[0] = root;
+
+    // Ids from the dataset's own occupancy, walking forward: `createEntity` scans from bit zero
+    // every time, which is quadratic over a spawn of this size.
+    const occupancy = dataset.entityOccupancy;
+
+    let cursor = 0;
+
+    for (let i = 1; i < node_count; i++) {
+        const entity = occupancy.nextClearBit(cursor);
+
+        dataset.createEntitySpecific(entity);
+
+        entities[i] = entity;
+        cursor = entity + 1;
+    }
+
+    const parent = prefab.parent;
+    const names = prefab.name;
+    const locals = prefab.local;
+    const worlds = prefab.world;
+    const animated = prefab.animated;
+
+    /**
+     * @type {Map<number, import("./Prefab.js").PrefabPrimitive>}
+     */
+    const primitive_of = new Map();
+
+    for (const primitive of prefab.primitives) {
+        primitive_of.set(primitive.node, primitive);
+    }
+
+    // One lifetime component for the whole instance: it names the root and nothing else, it is
+    // immutable while attached, and sixty copies of one number are sixty allocations for nothing.
+    const owner = ParentEntity.from(root);
+
+    for (let i = 1; i < node_count; i++) {
+        const entity = entities[i];
+
+        if (transient) {
+            dataset.addComponentToEntityByIndex(entity, METADATA, SerializationMetadata.Transient);
+        }
+
+        dataset.addComponentToEntityByIndex(entity, PARENT, owner);
+
+        const name = names[i];
+
+        if (name !== "") {
+            dataset.addComponentToEntityByIndex(entity, NAME, new Name(name));
+        }
+
+        if (animated[i] !== 0) {
+            dataset.addComponentToEntityByIndex(entity, AUTHORITY, new GPUStateAuthority());
+        }
+
+        const primitive = primitive_of.get(i);
+
+        if (primitive !== undefined) {
+            const geometry = ShadedGeometry.from(primitive.geometry, primitive.material, DrawMode.Triangles);
+
+            if (primitive.skin !== -1) {
+                geometry.setFlag(ShadedGeometryFlags.Skinned);
+            }
+
+            dataset.addComponentToEntityByIndex(entity, GEOMETRY, geometry);
+        }
+
+        const attachment = new TransformAttachment();
+
+        attachment.parent = entities[parent[i]];
+        attachment.transform.copy(locals[i]);
+
+        // The world is composed below, from the same chain the attachment system would compose
+        // it from, so the system is told not to compose it again at link: a decomposition per
+        // entity, and an announcement nothing is listening for yet. It still follows every move
+        // of the parent from then on.
+        attachment.immediate = false;
+
+        dataset.addComponentToEntityByIndex(entity, ATTACHMENT, attachment);
+
+        // Composed here rather than left to the attachment system, so that a dataset with no
+        // systems — a preview, a spec — holds every world too.
+        const world = new Transform64();
+
+        m4_multiply(world, root_transform, worlds[i]);
+        world.updateComponents();
+
+        dataset.addComponentToEntityByIndex(entity, TRANSFORM, world);
+    }
+
+    const instance = new PrefabInstance();
+
+    instance.prefab = prefab;
+    instance.root = root;
+    instance.entities = entities;
+    instance.mesh_entities = Int32Array.from(prefab.primitives, primitive => entities[primitive.node]);
+
+    instance.skins = prefab.skins.map(skin => Skin.from({
+        name: skin.name,
+        joints: Array.from(skin.joints, joint => entities[joint]),
+        inverse_bind_matrices: skin.inverse_bind_matrices,
+        meshes: Array.from(skin.meshes, mesh => entities[mesh]),
+    }));
+
+    instance.clips = prefab.clips.map(clip => ShadeAnimationClip.from({
+        name: clip.name,
+        channels: clip.channels.map(channel => ShadeAnimationChannel.from({
+            target: entities[channel.target],
+            property: channel.property,
+            curves: channel.curves,
+        })),
+    }));
+
+    return instance;
+}
+
+/**
+ * Remove every entity an instance spawned. The root is the caller's and stays.
+ *
+ * Children before parents, so that no parent's removal has to reach down and detach a child
+ * that is about to go anyway.
+ *
+ * @param {EntityComponentDataset} dataset
+ * @param {PrefabInstance} instance
+ */
+export function prefab_instance_destroy(dataset, instance) {
+    assert.defined(dataset, 'dataset');
+    assert.defined(instance, 'instance');
+
+    const entities = instance.entities;
+
+    for (let i = entities.length - 1; i >= 1; i--) {
+        dataset.removeEntity(entities[i]);
+    }
+}

package/src/engine/grid/grid2transform/GridPosition2TransformSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GridPosition2TransformSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/grid/grid2transform/GridPosition2TransformSystem.js"],"names":[],"mappings":"AAWA;IAOI,cASC;IAfD,2FAAmE;IACnE,mEAEE;IACF,YAAU;IAKN,4CAKC;IAGL;;;;;;OAMG;IACH,gBALW,sBAAsB,MACtB,YAAY,aACZ,WAAW,UACX,MAAM,QAgChB;IAED;;;;;;OAMG;IACH,kBALW,sBAAsB,MACtB,YAAY,aACZ,WAAW,UACX,MAAM,QAQhB;IAED,cAeC;CACJ;uBAhGsB,qBAAqB;4BAEhB,oCAAoC;uCAEzB,6BAA6B;yBAD3C,6BAA6B;4CAJV,oDAAoD"}
+{"version":3,"file":"GridPosition2TransformSystem.d.ts","sourceRoot":"","sources":["../../../../../src/engine/grid/grid2transform/GridPosition2TransformSystem.js"],"names":[],"mappings":"AAYA;IAOI,cASC;IAfD,2FAAmE;IACnE,mEAEE;IACF,YAAU;IAKN,4CAKC;IAGL;;;;;;OAMG;IACH,gBALW,sBAAsB,MACtB,YAAY,aACZ,WAAW,UACX,MAAM,QAiChB;IAED;;;;;;OAMG;IACH,kBALW,sBAAsB,MACtB,YAAY,aACZ,WAAW,UACX,MAAM,QAQhB;IAED,cAeC;CACJ;uBAlGsB,qBAAqB;4BAEhB,oCAAoC;uCAGzB,6BAA6B;yBAD3C,6BAA6B;4CALV,oDAAoD"}

package/src/engine/grid/grid2transform/GridPosition2TransformSystem.js

@@ -4,6 +4,7 @@ import { ResourceAccessSpecification } from "../../../core/model/ResourceAccessS
 import { System } from '../../ecs/System.js';
 import { obtainTerrain } from "../../ecs/terrain/util/obtainTerrain.js";
 import { Transform64 } from '../../ecs/transform/Transform64.js';
+import { t64_announce_change } from '../../ecs/transform/t64_announce_change.js';
 import GridPosition from '../position/GridPosition.js';
 import { GridPosition2Transform } from './GridPosition2Transform.js';
 import { GridPosition2TransformFlags } from "./GridPosition2TransformFlags.js";
@@ -36,6 +37,7 @@ export class GridPosition2TransformSystem extends System {
      */
     link(component, gp, transform, entity) {
         const mapPoint = this.mapPoint;
+        const em = this.entityManager;
 
         function sync() {
             const transformOffset = component.offset;
@@ -46,7 +48,7 @@ export class GridPosition2TransformSystem extends System {
             const centerX = x + transformOffset.x;
             const centerY = y + transformOffset.y;
 
-            setTransformFromGrid(mapPoint, centerX, centerY, transform);
+            setTransformFromGrid(mapPoint, centerX, centerY, transform, em.dataset, entity);
         }
 
         sync.clear = function () {
@@ -107,12 +109,29 @@ const v3 = new Vector3();
  * @param {number} x
  * @param {number} y
  * @param {Transform64} transform
+ * @param {EntityComponentDataset} ecd
+ * @param {number} entity
  */
-function setTransformFromGrid(mapPointGrid2world, x, y, transform) {
+function setTransformFromGrid(mapPointGrid2world, x, y, transform, ecd, entity) {
     mapPointGrid2world(x, y, v3);
-    const transformPosition = transform.translation;
+
     //check if positions are different
-    if (v3.x !== transformPosition[0] || v3.z !== transformPosition[2]) {
-        transformPosition.setXZ(v3.x, v3.z);
+    if (v3.x === transform.translation_x && v3.z === transform.translation_z) {
+        return;
     }
+
+    /**
+     * `setTranslation`, not `translation.setXZ`: `translation` is a Float64Array view over the
+     * transform's own buffer — freshly allocated on every access — and `setXZ` is a Vector3 method
+     * that exists nowhere else, so the write used to throw. The exception was swallowed by the
+     * signal dispatch on the `gp.onChanged` path, which left the transform silently never moving.
+     */
+    transform.setTranslation(v3.x, transform.translation_y, v3.z);
+
+    /**
+     * A Transform64 carries no signals, so the write is invisible until it is announced — without
+     * this the render placement, the parent/child sync and the spatial audio refit all keep the old
+     * position. Translation-only, so no `updateMatrix` is owed: it is a column of the matrix.
+     */
+    t64_announce_change(ecd, entity);
 }

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

@@ -29,8 +29,12 @@ export class Interpoland {
      *   decodes the live component to / from a snapshot
      * @param {BinaryInterpolationAdapter} interpolation_adapter blends two
      *   snapshots
+     * @param {(dataset: EntityComponentDataset, entity: number) => void} [announce]
+     *   called after the blended snapshot has been written into the live component. A component
+     *   that carries no signals of its own — {@link Transform64} is the reason this exists — is
+     *   invisible to everything downstream until someone says it changed, and the writer owes that.
      */
-    constructor(type_id: number, component_class: Function, serialization_adapter: BinaryClassSerializationAdapter, interpolation_adapter: BinaryInterpolationAdapter);
+    constructor(type_id: number, component_class: Function, serialization_adapter: BinaryClassSerializationAdapter, interpolation_adapter: BinaryInterpolationAdapter, announce?: (dataset: EntityComponentDataset, entity: number) => void);
     /** @type {number} */
     type_id: number;
     /** @type {Function} */
@@ -39,6 +43,8 @@ export class Interpoland {
     serialization_adapter: BinaryClassSerializationAdapter;
     /** @type {BinaryInterpolationAdapter} */
     interpolation_adapter: BinaryInterpolationAdapter;
+    /** @type {(dataset: EntityComponentDataset, entity: number) => void} */
+    announce: (dataset: EntityComponentDataset, entity: number) => void;
     /**
      * @readonly
      * @type {boolean}

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

@@ -1 +1 @@
-{"version":3,"file":"Interpoland.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/Interpoland.js"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACI;;;;;;;OAOG;IACH,qBAPW,MAAM,wIAgBhB;IARG,qBAAqB;IACrB,SADW,MAAM,CACK;IACtB,uBAAuB;IACvB,0BAAsC;IACtC,8CAA8C;IAC9C,uDAAkD;IAClD,yCAAyC;IACzC,kDAAkD;IAI1D;;;OAGG;IACH,wBAFU,OAAO,CAEkB;CANlC"}
+{"version":3,"file":"Interpoland.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/Interpoland.js"],"names":[],"mappings":"AACA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IACI;;;;;;;;;;;OAWG;IACH,qBAXW,MAAM,mJAMN,CAAC,OAAO,wBAAwB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,EAgBnE;IAVG,qBAAqB;IACrB,SADW,MAAM,CACK;IACtB,uBAAuB;IACvB,0BAAsC;IACtC,8CAA8C;IAC9C,uDAAkD;IAClD,yCAAyC;IACzC,kDAAkD;IAClD,wEAAwE;IACxE,UADW,CAAC,OAAO,wBAAwB,EAAE,MAAM,EAAE,MAAM,KAAK,IAAI,CAC5C;IAIhC;;;OAGG;IACH,wBAFU,OAAO,CAEkB;CANlC"}

package/src/engine/interpolation/Interpoland.js

@@ -1,3 +1,4 @@
+import { noop } from "../../core/function/noop.js";
 /**
  * Descriptor for ONE thing the interpolation system blends for an entity.
  *
@@ -29,8 +30,12 @@ export class Interpoland {
      *   decodes the live component to / from a snapshot
      * @param {BinaryInterpolationAdapter} interpolation_adapter blends two
      *   snapshots
+     * @param {(dataset: EntityComponentDataset, entity: number) => void} [announce]
+     *   called after the blended snapshot has been written into the live component. A component
+     *   that carries no signals of its own — {@link Transform64} is the reason this exists — is
+     *   invisible to everything downstream until someone says it changed, and the writer owes that.
      */
-    constructor(type_id, component_class, serialization_adapter, interpolation_adapter) {
+    constructor(type_id, component_class, serialization_adapter, interpolation_adapter, announce = noop) {
         /** @type {number} */
         this.type_id = type_id;
         /** @type {Function} */
@@ -39,6 +44,8 @@ export class Interpoland {
         this.serialization_adapter = serialization_adapter;
         /** @type {BinaryInterpolationAdapter} */
         this.interpolation_adapter = interpolation_adapter;
+        /** @type {(dataset: EntityComponentDataset, entity: number) => void} */
+        this.announce = announce;
     }
 }
 

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":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAOI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA6CvE;IAnDD,sCAA8B;IAC9B,oEAEE;IAQE;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;;OAKG;IACH,mBAA2B;IAE3B;;;;OAIG;IACH,kBAAmC;IAGnC;;;;;;;OAOG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,yBAAiC;IAGrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAI7D;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAShB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAIhB;IAED,sBA0FC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CANlD;uBAxOsB,kBAAkB;6BAEyC,mBAAmB;4CAHzD,iDAAiD;iCAE5D,uBAAuB"}
+{"version":3,"file":"InterpolationSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/interpolation/InterpolationSystem.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAOI;;OAEG;IACH,0DAFW;QAAE,qBAAqB,CAAC,EAAE,MAAM,CAAC;QAAC,gBAAgB,CAAC,EAAE,MAAM,CAAA;KAAE,EA6CvE;IAnDD,sCAA8B;IAC9B,oEAEE;IAQE;;;;OAIG;IACH,KAFU,gBAAgB,CAEkD;IAE5E;;;;;OAKG;IACH,mBAA2B;IAE3B;;;;OAIG;IACH,kBAAmC;IAGnC;;;;;;;OAOG;IACH,kBAA0B;IAE1B;;;;;OAKG;IACH,yBAAiC;IAGrC;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,OACN,gBAAgB,UAChB,MAAM;QAAE,MAAM,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,CAAC,EAAE,MAAM,CAAA;KAAE,QAI7D;IAED;;;;;OAKG;IACH,2BAHW,MAAM,GACJ,OAAO,CAInB;IAED;;OAEG;IACH,qDAEC;IAED;;;OAGG;IACH,mBAHW,YAAY,UACZ,MAAM,QAShB;IAED;;;OAGG;IACH,qBAHW,YAAY,UACZ,MAAM,QAIhB;IAED,sBA6FC;IAGL;;;OAGG;IACH,gCAFU,OAAO,CAEkC;CANlD;uBA3OsB,kBAAkB;6BAEyC,mBAAmB;4CAHzD,iDAAiD;iCAE5D,uBAAuB"}

package/src/engine/interpolation/InterpolationSystem.js

@@ -230,6 +230,9 @@ export class InterpolationSystem extends System {
 
                 scratch.position = 0;
                 interpoland.serialization_adapter.deserialize(scratch, target);
+
+                // the write is invisible to everything downstream until it is announced
+                interpoland.announce(dataset, entity);
             }
         }
     }