@woosh/meep-engine 3.23.0 → 3.25.0

package/src/engine/graphics3/TerrainSystem.js

@@ -11,15 +11,19 @@ import { System } from "../ecs/System.js";
 import Terrain from "../ecs/terrain/ecs/Terrain.js";
 import { TerrainFlags } from "../ecs/terrain/ecs/TerrainFlags.js";
 import { tile_geometry_to_meshlets } from "../ecs/terrain/tiles/tile_geometry_to_meshlets.js";
+import { SerializationMetadata } from "../ecs/components/SerializationMetadata.js";
+import { Name } from "../ecs/name/Name.js";
+import { ParentEntity } from "../ecs/parent/ParentEntity.js";
 import { Transform64 } from "../ecs/transform/Transform64.js";
+import { t64_announce_change } from "../ecs/transform/t64_announce_change.js";
 import { t64_equals_components } from "../ecs/transform/t64_equals_components.js";
+import { ShadedGeometry } from "../graphics/ecs/mesh-v2/ShadedGeometry.js";
 import { sampler2d_ensure_uint8_RGBA } from "../graphics/texture/sampler/sampler2d_ensure_uint8_RGBA.js";
 import { Sampler2D } from "../graphics/texture/sampler/Sampler2D.js";
 import { WHITE_PIXEL_DATA_URL } from "../graphics/WHITE_PIXEL_DATA_URL.js";
 import { FramePhase } from "../../shade/renderer/extension/FramePhase.js";
 import { RenderExtension } from "../../shade/renderer/extension/RenderExtension.js";
 import { StandardShadeMaterial } from "../../shade/renderer/material/StandardShadeMaterial.js";
-import { Mesh } from "../../shade/renderer/scene/Mesh.js";
 import { GPUTerrainSplatRenderer } from "./terrain/GPUTerrainSplatRenderer.js";
 import { pack_terrain_row_table } from "./terrain/pack_terrain_row_table.js";
 
@@ -41,12 +45,22 @@ const WHITE_SPRITE = Sampler2D.uint8(4, 1, 1);
 WHITE_SPRITE.data.fill(255);
 
 /**
- * Draws terrain under Shade: each built tile becomes one meshlet-encoded mesh in the scene, and a
- * pass after the opaque geometry textures the lot.
+ * What a tile entity carries. Registered on the dataset the first time a tile is spawned, which is
+ * idempotent; a terrain may well be the first thing in a level to draw.
+ *
+ * @type {Function[]}
+ */
+const TILE_COMPONENT_TYPES = [Transform64, ShadedGeometry, Name, ParentEntity, SerializationMetadata];
+
+/**
+ * Draws terrain under Shade: each built tile becomes one entity that draws — a `ShadedGeometry`
+ * over the tile's meshlets, standing where the terrain entity stands, owned by it and never saved
+ * — and a pass after the opaque geometry textures the lot. The system that owns primitives puts
+ * the tile in the scene's rows; this one makes and keeps the entity.
  *
  * **The tile is the unit, not the terrain.** Tiles are built on demand as the camera sees them and
  * destroyed as it leaves, which is the streaming the tile manager already does; this system follows
- * that with scene membership rather than deciding anything about it.
+ * that with entities rather than deciding anything about it.
  *
  * **Tile vertices are already in terrain space** — the height-field builder positions each tile
  * within the whole grid rather than at its own origin — so every tile mesh carries the terrain
@@ -76,13 +90,6 @@ export class TerrainSystem extends System {
      */
     #extension = null;
 
-    /**
-     * The scene this system writes into, received rather than created so terrain, meshes and lights
-     * all land in the one the facade draws.
-     *
-     * @type {Scene}
-     */
-    #scene;
 
     /**
      * @type {AssetManager}
@@ -90,15 +97,16 @@ export class TerrainSystem extends System {
     #assetManager;
 
     /**
-     * What each terrain entity has in the scene.
+     * What each terrain entity has spawned.
      *
-     * @type {Map<number, {terrain: Terrain, material: StandardShadeMaterial, meshes: Map<TerrainTile, Mesh>, bindings: SignalBinding[]}>}
+     * @type {Map<number, {terrain: Terrain, material: StandardShadeMaterial, tiles: Map<TerrainTile, number>, bindings: SignalBinding[]}>}
      */
     #entries = new Map();
 
     /**
      * @param {GraphicsEngine} graphics
-     * @param {Scene} scene
+     * @param {Scene} scene the scene the profile draws; a tile is an entity in its rows, put there
+     *        by the system that owns primitives, so this one keeps nothing of the scene itself
      * @param {AssetManager} assetManager
      */
     constructor(graphics, scene, assetManager) {
@@ -109,7 +117,6 @@ export class TerrainSystem extends System {
         assert.defined(assetManager, 'assetManager');
 
         this.#graphics = graphics;
-        this.#scene = scene;
         this.#assetManager = assetManager;
     }
 
@@ -153,7 +160,7 @@ export class TerrainSystem extends System {
              splat shader forced.
              */
             material: new StandardShadeMaterial(),
-            meshes: new Map(),
+            tiles: new Map(),
             bindings: [],
             renderer: new GPUTerrainSplatRenderer(),
             /**
@@ -276,29 +283,63 @@ export class TerrainSystem extends System {
             return;
         }
 
-        if (entry.meshes.has(tile)) {
+        if (entry.tiles.has(tile)) {
             // a rebuilt tile replaces what it had rather than accumulating
             this.#remove_tile(entity, tile);
         }
 
+        const name = `terrain tile ${tile.gridPosition.x},${tile.gridPosition.y}`;
+
         const geometry = tile_geometry_to_meshlets({
             vertices: tile.vertices,
             normals: tile.normals,
             uvs: tile.uvs,
             indices: tile.indices
-        }, `terrain tile ${tile.gridPosition.x},${tile.gridPosition.y}`);
+        }, name);
 
-        const mesh = Mesh.from(geometry, entry.material);
+        const ecd = this.entityManager.dataset;
 
-        entry.meshes.set(tile, mesh);
+        ecd.registerManyComponentTypes(TILE_COMPONENT_TYPES);
 
-        this.#scene.add(mesh);
+        /*
+         The tile stands where the terrain stands: the world pose is copied rather than attached,
+         because a terrain may be linked before it has a transform at all and is placed on a poll
+         ({@link update}) for that reason. Owned by the terrain entity, so a lifetime system takes
+         it down with the terrain; transient, because it is built from the terrain on load.
+        */
+        const tile_entity = ecd.createEntity();
 
-        const ecd = this.entityManager === null ? null : this.entityManager.dataset;
+        const placement = new Transform64();
+        const transform = ecd.getComponent(entity, Transform64);
+
+        if (transform !== undefined) {
+            placement.copy(transform);
+            placement.updateMatrix();
+        }
+
+        ecd.addComponentToEntity(tile_entity, SerializationMetadata.Transient);
+        ecd.addComponentToEntity(tile_entity, ParentEntity.from(entity));
+        ecd.addComponentToEntity(tile_entity, new Name(name));
+        ecd.addComponentToEntity(tile_entity, placement);
+        ecd.addComponentToEntity(tile_entity, ShadedGeometry.from(geometry, entry.material));
+
+        entry.tiles.set(tile, tile_entity);
+    }
+
+    /**
+     * The entities a terrain's built tiles are.
+     *
+     * @param {number} entity the terrain entity
+     * @returns {Int32Array}
+     */
+    tiles_of(entity) {
+        const entry = this.#entries.get(entity);
 
-        if (ecd !== null) {
-            this.#place(entity, ecd.getComponent(entity, Transform64));
+        if (entry === undefined) {
+            return new Int32Array(0);
         }
+
+        return Int32Array.from(entry.tiles.values());
     }
 
     /**
@@ -312,15 +353,19 @@ export class TerrainSystem extends System {
             return;
         }
 
-        const mesh = entry.meshes.get(tile);
+        const tile_entity = entry.tiles.get(tile);
 
-        if (mesh === undefined) {
+        if (tile_entity === undefined) {
             return;
         }
 
-        this.#scene.remove(mesh);
+        entry.tiles.delete(tile);
+
+        const ecd = this.entityManager.dataset;
 
-        entry.meshes.delete(tile);
+        if (ecd.entityExists(tile_entity)) {
+            ecd.removeEntity(tile_entity);
+        }
     }
 
     /**
@@ -338,23 +383,27 @@ export class TerrainSystem extends System {
             return;
         }
 
-        for (const mesh of entry.meshes.values()) {
+        const ecd = this.entityManager.dataset;
+
+        for (const tile_entity of entry.tiles.values()) {
+            const placement = ecd.getComponent(tile_entity, Transform64);
+
             /*
              A tile already standing where it belongs is left alone, and it is the common case:
              {@link update} places on a poll rather than on the entity's transform signals, because a
-             terrain may be linked before it has a `Transform` at all. `updateMatrices` bumps a
-             version whether or not anything moved, and downstream that version is what makes the
-             scene database upload a row and the top-level acceleration structure rebuild itself —
-             a whole-tree treelet optimisation and a fresh GPU buffer, once a frame, for a ground
-             that has not moved since the level loaded (E19).
+             terrain may be linked before it has a `Transform` at all. An announcement is what
+             makes the scene's rows rewrite the tile's row and the top-level acceleration structure
+             refit — once a frame, for a ground that has not moved since the level loaded, is what
+             the poll used to cost before it compared (E19).
             */
-            if (t64_equals_components(mesh.transform_local, transform)) {
+            if (t64_equals_components(placement, transform)) {
                 continue;
             }
 
-            mesh.transform_local.copy(transform);
+            placement.copy(transform);
+            placement.updateMatrix();
 
-            mesh.updateMatrices();
+            t64_announce_change(ecd, tile_entity);
         }
     }
 
@@ -372,10 +421,16 @@ export class TerrainSystem extends System {
             entry.bindings[i].unlink();
         }
 
-        for (const mesh of entry.meshes.values()) {
-            this.#scene.remove(mesh);
+        const ecd = this.entityManager.dataset;
+
+        for (const tile_entity of entry.tiles.values()) {
+            if (ecd.entityExists(tile_entity)) {
+                ecd.removeEntity(tile_entity);
+            }
         }
 
+        entry.tiles.clear();
+
         entry.renderer.destroy();
 
         this.#entries.delete(entity);
@@ -415,30 +470,24 @@ export class TerrainSystem extends System {
     }
 
     /**
-     * Everything the splat pass draws one terrain from, assembled against the scene that will be
-     * asked for the rows. What the pass consumes and what a gate inspects are deliberately the
-     * same object — the same reason `DecalSystem` exposes its packed records.
+     * Everything the splat pass draws one terrain from. What the pass consumes and what a gate
+     * inspects are deliberately the same object — the same reason `DecalSystem` exposes its
+     * packed records.
      *
      * @param {number} entity
-     * @param {GPUSceneContext} scene
-     * @returns {object|null} `null` when this terrain has nothing on screen to texture — no tiles
-     * built, or none of them in the scene database yet
+     * @returns {object|null} `null` when this terrain has nothing to texture — no tiles built
      */
-    splat_frame(entity, scene) {
+    splat_frame(entity) {
         const entry = this.#entries.get(entity);
 
-        if (entry === undefined || entry.meshes.size === 0) {
+        if (entry === undefined || entry.tiles.size === 0) {
             return null;
         }
 
-        const packed = pack_terrain_row_table({ meshes: entry.meshes, scene, table: entry.rows });
+        const packed = pack_terrain_row_table({ tiles: entry.tiles, table: entry.rows });
 
         entry.rows = packed.table;
 
-        if (packed.size === 0) {
-            return null;
-        }
-
         const terrain = entry.terrain;
 
         const invertible = m4_invert(entry.world_to_terrain, terrain.transform);
@@ -519,7 +568,7 @@ export class TerrainSystem extends System {
      */
     record(frame) {
         for (const entity of this.#entries.keys()) {
-            const splat = this.splat_frame(entity, frame.view.scene);
+            const splat = this.splat_frame(entity);
 
             if (splat === null) {
                 // nothing of this terrain on screen; the frame keeps the albedo it already had

package/src/engine/graphics3/TooltipComponentSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"TooltipComponentSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/TooltipComponentSystem.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA0EI;;;;;;;OAOG;IACH;QANmC,QAAQ;QACR,QAAQ;QACT,OAAO;QACR,YAAY;QACX,OAAO;OAgBxC;IA/FD,0CAAkC;IAElC;;;;OAIG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,iBAFU,SAAS,CAEM;IAkFzB;;;;OAIG;IACH,yBAEC;IAED,2CAMC;IAED,4CAMC;IAED;;;OAGG;IACH,gBAHW,gBAAgB,UAChB,MAAM,QAOhB;IAED,8BAyBC;;CAmHJ;uBAnUsB,kBAAkB;iCACR,oCAAoC;sBAL/C,iCAAiC"}
+{"version":3,"file":"TooltipComponentSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/TooltipComponentSystem.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;IA0EI;;;;;;;OAOG;IACH;QANmC,QAAQ;QACR,QAAQ;QACT,OAAO;QACR,YAAY;QACX,OAAO;OAgBxC;IA/FD,0CAAkC;IAElC;;;;OAIG;IACH,eAFU,MAAM,CAEI;IAEpB;;;;;OAKG;IACH,iBAFU,SAAS,CAEM;IAkFzB;;;;OAIG;IACH,yBAEC;IAED,2CAMC;IAED,4CAMC;IAED;;;OAGG;IACH,gBAHW,gBAAgB,UAChB,MAAM,QAOhB;IAED,8BAyBC;;CAgHJ;uBAxTsB,kBAAkB;iCACR,oCAAoC;sBAJ/C,iCAAiC"}

package/src/engine/graphics3/TooltipComponentSystem.js

@@ -1,7 +1,6 @@
 import { assert } from "../../core/assert.js";
 import Rectangle from "../../core/geom/2d/Rectangle.js";
 import { Vector2 } from "../../core/geom/Vector2.js";
-import Vector3 from "../../core/geom/Vector3.js";
 import { VisualTip } from "../../view/tooltip/VisualTip.js";
 import { System } from "../ecs/System.js";
 import { TooltipComponent } from "../ecs/tooltip/TooltipComponent.js";
@@ -13,15 +12,7 @@ import { PickingResult } from "./PickingResult.js";
  */
 const SCRATCH_POINT = new Vector2();
 
-/**
- * @type {Vector3}
- */
-const SCRATCH_ORIGIN = new Vector3();
 
-/**
- * @type {Vector3}
- */
-const SCRATCH_DIRECTION = new Vector3();
 
 /**
  * How far from the pointer, in pixels, the rectangle a tooltip is anchored to sits.
@@ -243,13 +234,10 @@ export class TooltipComponentSystem extends System {
 
         SCRATCH_POINT.set(position.x, position.y);
 
+        // clip space, x right and y up — the pick wants the fraction of the view, from the top left
         graphics.normalizeViewportPoint(SCRATCH_POINT, SCRATCH_POINT);
-        graphics.viewportProjectionRay(
-            SCRATCH_POINT.x, SCRATCH_POINT.y,
-            SCRATCH_ORIGIN, SCRATCH_DIRECTION
-        );
 
-        const query = PickingQuery.from(SCRATCH_ORIGIN, SCRATCH_DIRECTION);
+        const query = PickingQuery.from_viewport((SCRATCH_POINT.x + 1) / 2, (1 - SCRATCH_POINT.y) / 2);
 
         this.#query_in_flight = true;
 

package/src/engine/graphics3/Trail3DSystem.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"Trail3DSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/Trail3DSystem.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA0CI;;OAEG;IACH,sCAMC;IAlDD,sDAAsC;IAgCtC;;;;OAIG;IACH,8BAEC;IAaD,2CAIC;IAED,4CAWC;IAED;;;;OAIG;IACH,YAJW,OAAO,aACP,WAAW,UACX,MAAM,QAkBhB;IAED;;;;OAIG;IACH,cAJW,OAAO,aACP,WAAW,UACX,MAAM,QAiBhB;IAED,6BAYC;IAED;;OAEG;IACH,kCAeC;;CACJ;AAED;;GAEG;AACH;IAUI;;OAEG;IACH,oBAFW,aAAa,EAMvB;IAED,yBAEC;;CACJ;uBAnNsB,kBAAkB;4BACb,iCAAiC;oBAGzC,oCAAoC;iCALvB,gDAAgD;gCAJjD,mDAAmD"}
+{"version":3,"file":"Trail3DSystem.d.ts","sourceRoot":"","sources":["../../../../src/engine/graphics3/Trail3DSystem.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH;IA0CI;;OAEG;IACH,sCAMC;IAlDD,sDAAsC;IAgCtC;;;;OAIG;IACH,8BAEC;IAaD,2CAIC;IAED,4CAWC;IAED;;;;OAIG;IACH,YAJW,OAAO,aACP,WAAW,UACX,MAAM,QAgBhB;IAED;;;;OAIG;IACH,cAJW,OAAO,aACP,WAAW,UACX,MAAM,QAiBhB;IAED,6BAYC;IAED;;OAEG;IACH,kCAeC;;CACJ;AAED;;GAEG;AACH;IAUI;;OAEG;IACH,oBAFW,aAAa,EAMvB;IAED,yBAEC;;CACJ;uBAjNsB,kBAAkB;4BACb,iCAAiC;oBAGzC,oCAAoC;iCALvB,gDAAgD;gCAJjD,mDAAmD"}

package/src/engine/graphics3/Trail3DSystem.js

@@ -123,12 +123,10 @@ export class Trail3DSystem extends System {
             seed_trail_tube(trail, transform);
         }
 
+        // the extrusion produces world-space vertices, and what the draw applies is the mesh's own
+        // transform, identity until moved
         const mesh = DynamicMesh.from(new Geometry());
 
-        // the extrusion produces world-space vertices, so what the draw applies is identity — but a
-        // node's world transform is derived and stays unset until it is asked for
-        mesh.updateMatrices();
-
         trail_tube_write_geometry(mesh.geometry, trail.tube);
 
         this.#batch.add(mesh);

package/src/engine/graphics3/animation/ClipListPlayer.d.ts

@@ -36,9 +36,9 @@ export class ClipListPlayer {
      * The entity's private copy of the model — where the clips named in the list are found, and
      * where their durations come from.
      *
-     * @type {SceneBundleInstance}
+     * @type {PrefabInstance}
      */
-    instance: SceneBundleInstance;
+    instance: PrefabInstance;
     /**
      * One per entry of {@link component}'s list, in the list's own order.
      *
@@ -62,9 +62,9 @@ export class ClipListPlayer {
      *
      * @param {number} entity
      * @param {EntityComponentDataset} ecd
-     * @param {SceneBundleInstance} instance
+     * @param {PrefabInstance} instance
      */
-    bind(entity: number, ecd: EntityComponentDataset, instance: SceneBundleInstance): void;
+    bind(entity: number, ecd: EntityComponentDataset, instance: PrefabInstance): void;
     /**
      * Advance every clock, say so when one runs out, and work out what the list therefore weighs.
      *

package/src/engine/graphics3/animation/ClipListPlayer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ClipListPlayer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/ClipListPlayer.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAqDI;;;OAGG;IACH,uBAHW,SAAS,GACP,cAAc,CAU1B;IAhED;;;;;OAKG;IACH,WAFU,SAAS,CAEF;IAEjB;;;;;OAKG;IACH,8BAAgB;IAEhB;;;;OAIG;IACH,WAFU,YAAY,EAAE,CAET;IAEf;;;;;;;;OAQG;IACH,SAFU,YAAY,CAEQ;IAkC9B;;;;;;;;OAQG;IACH,aAJW,MAAM,oEAgBhB;IAED;;;;;;;OAOG;IACH,yBAFW,MAAM,QAMhB;;CAuHJ;6BArP4B,mBAAmB"}
+{"version":3,"file":"ClipListPlayer.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/animation/ClipListPlayer.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAqDI;;;OAGG;IACH,uBAHW,SAAS,GACP,cAAc,CAU1B;IAhED;;;;;OAKG;IACH,WAFU,SAAS,CAEF;IAEjB;;;;;OAKG;IACH,yBAAgB;IAEhB;;;;OAIG;IACH,WAFU,YAAY,EAAE,CAET;IAEf;;;;;;;;OAQG;IACH,SAFU,YAAY,CAEQ;IAkC9B;;;;;;;;OAQG;IACH,aAJW,MAAM,+DAgBhB;IAED;;;;;;;OAOG;IACH,yBAFW,MAAM,QAMhB;;CAuHJ;6BArP4B,mBAAmB"}

package/src/engine/graphics3/animation/ClipListPlayer.js

@@ -37,7 +37,7 @@ export class ClipListPlayer {
      * The entity's private copy of the model — where the clips named in the list are found, and
      * where their durations come from.
      *
-     * @type {SceneBundleInstance}
+     * @type {PrefabInstance}
      */
     instance = null;
 
@@ -98,7 +98,7 @@ export class ClipListPlayer {
      *
      * @param {number} entity
      * @param {EntityComponentDataset} ecd
-     * @param {SceneBundleInstance} instance
+     * @param {PrefabInstance} instance
      */
     bind(entity, ecd, instance) {
         assert.isNonNegativeInteger(entity, 'entity');

package/src/engine/graphics3/highlight/pack_highlight_table.d.ts

@@ -2,12 +2,12 @@
  * Build the lookup the outline shader reads: one packed colour per mesh row, addressed by the row
  * the visibility buffer writes.
  *
- * **The scene decides the indices, and each entry decides which of them are its own.** A highlight
- * is attached to an entity, and what that entity has in the scene depends on what kind of thing it
- * is — a model is many nodes the mesh system holds, a primitive is the one node its own component
- * carries. Neither is this function's business: an entry arrives already knowing how to walk to its
- * nodes, so the walk here is entry → nodes → rows and there is no kind to switch on. An entity
- * whose model has not loaded walks to nothing and needs no special case.
+ * **Each entry decides which rows are its own.** A highlight is attached to an entity, and what
+ * that entity draws depends on what kind of thing it is — a model is the primitive entities it
+ * spawned, a primitive is its own entity — and a mesh row is its entity plus one. Neither is this
+ * function's business: an entry arrives already knowing how to walk to its rows, so the walk here
+ * is entry → rows and there is no kind to switch on. An entity whose model has not loaded walks to
+ * nothing and needs no special case.
  *
  * **A row holds one colour.** Where two entries reach the same node — a highlighted model and a
  * separately highlighted primitive inside it — the later entry wins, which is link order. Nothing
@@ -19,18 +19,16 @@
  * is.
  *
  * @param {object} args
- * @param {Array<{highlight: Highlight, traverse: function(function(Mesh): void): void}>} args.entries
- * @param {GPUSceneContext} args.scene resolves a node to its row
+ * @param {Array<{highlight: Highlight, rows: function(function(number): void): void}>} args.entries
  * @param {Uint32Array} args.table reused between frames; replaced when it is too small
  * @returns {{table: Uint32Array, size: number}} `size` is one past the highest row written, and is
  * zero when nothing highlighted is in the scene
  */
-export function pack_highlight_table({ entries, scene, table }: {
+export function pack_highlight_table({ entries, table }: {
     entries: Array<{
         highlight: Highlight;
-        traverse: (arg0: (arg0: Mesh) => void) => void;
+        rows: (arg0: (arg0: number) => void) => void;
     }>;
-    scene: GPUSceneContext;
     table: Uint32Array;
 }): {
     table: Uint32Array;

package/src/engine/graphics3/highlight/pack_highlight_table.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"pack_highlight_table.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/highlight/pack_highlight_table.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH;IAN+F,OAAO,EAA3F,MAAM;QAAC,SAAS,EAAE,SAAS,CAAC;QAAC,QAAQ,yBAA2B,IAAI,KAAG,IAAI,CAAA;KAAC,CAAC;IACvD,KAAK;IACT,KAAK,EAAvB,WAAW;IACT;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAqD9C"}
+{"version":3,"file":"pack_highlight_table.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/highlight/pack_highlight_table.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AACH;IAL6F,OAAO,EAAzF,MAAM;QAAC,SAAS,EAAE,SAAS,CAAC;QAAC,IAAI,gBAAoB,MAAM,KAAG,IAAI,KAAG,IAAI,CAAA;KAAC,CAAC;IACzD,KAAK,EAAvB,WAAW;IACT;IAAC,KAAK,EAAE,WAAW,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CA+C9C"}

package/src/engine/graphics3/highlight/pack_highlight_table.js

@@ -4,12 +4,12 @@ import { pack_highlight_color } from "./pack_highlight_color.js";
  * Build the lookup the outline shader reads: one packed colour per mesh row, addressed by the row
  * the visibility buffer writes.
  *
- * **The scene decides the indices, and each entry decides which of them are its own.** A highlight
- * is attached to an entity, and what that entity has in the scene depends on what kind of thing it
- * is — a model is many nodes the mesh system holds, a primitive is the one node its own component
- * carries. Neither is this function's business: an entry arrives already knowing how to walk to its
- * nodes, so the walk here is entry → nodes → rows and there is no kind to switch on. An entity
- * whose model has not loaded walks to nothing and needs no special case.
+ * **Each entry decides which rows are its own.** A highlight is attached to an entity, and what
+ * that entity draws depends on what kind of thing it is — a model is the primitive entities it
+ * spawned, a primitive is its own entity — and a mesh row is its entity plus one. Neither is this
+ * function's business: an entry arrives already knowing how to walk to its rows, so the walk here
+ * is entry → rows and there is no kind to switch on. An entity whose model has not loaded walks to
+ * nothing and needs no special case.
  *
  * **A row holds one colour.** Where two entries reach the same node — a highlighted model and a
  * separately highlighted primitive inside it — the later entry wins, which is link order. Nothing
@@ -21,13 +21,12 @@ import { pack_highlight_color } from "./pack_highlight_color.js";
  * is.
  *
  * @param {object} args
- * @param {Array<{highlight: Highlight, traverse: function(function(Mesh): void): void}>} args.entries
- * @param {GPUSceneContext} args.scene resolves a node to its row
+ * @param {Array<{highlight: Highlight, rows: function(function(number): void): void}>} args.entries
  * @param {Uint32Array} args.table reused between frames; replaced when it is too small
  * @returns {{table: Uint32Array, size: number}} `size` is one past the highest row written, and is
  * zero when nothing highlighted is in the scene
  */
-export function pack_highlight_table({ entries, scene, table }) {
+export function pack_highlight_table({ entries, table }) {
     let highest = -1;
 
     /*
@@ -37,9 +36,7 @@ export function pack_highlight_table({ entries, scene, table }) {
      rather than over the scene.
     */
     for (let i = 0; i < entries.length; i++) {
-        entries[i].traverse(node => {
-            const row = scene.mesh_row_of(node);
-
+        entries[i].rows(row => {
             if (row > highest) {
                 highest = row;
             }
@@ -67,12 +64,8 @@ export function pack_highlight_table({ entries, scene, table }) {
             continue;
         }
 
-        entry.traverse(node => {
-            const row = scene.mesh_row_of(node);
-
-            if (row >= 0) {
-                result[row] = packed;
-            }
+        entry.rows(row => {
+            result[row] = packed;
         });
     }
 

package/src/engine/graphics3/pose/query_entity_node_world_pose.d.ts

@@ -7,9 +7,10 @@
  * so an outcome that depended on it would depend on frame pacing, and determinism and replay would
  * go with it: no GPU readback on a gameplay-affecting path.
  *
- * The pose is {@link pose_evaluate_world} over the clips the animation systems are driving: a pure
- * function of (clip set, time, weights), off the same clock the renderer is written from, which is
- * what keeps a socket on the mesh that is drawn.
+ * The named node is an entity of the model's instance, and the pose is {@link t64_evaluate_world}
+ * over its attachment chain and the clips the animation systems are driving: a pure function of
+ * (hierarchy, clip set, time, weights), off the same clock the renderer is written from, which is
+ * what keeps a socket on the mesh that is drawn — whether or not the GPU owns the joint's row.
  *
  * The result carries both its matrix and its components.
  *

package/src/engine/graphics3/pose/query_entity_node_world_pose.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query_entity_node_world_pose.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/pose/query_entity_node_world_pose.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,yGANW,MAAM,aACN,MAAM,GACJ,OAAO,CAwCnB"}
+{"version":3,"file":"query_entity_node_world_pose.d.ts","sourceRoot":"","sources":["../../../../../src/engine/graphics3/pose/query_entity_node_world_pose.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,yGANW,MAAM,aACN,MAAM,GACJ,OAAO,CAwCnB"}