@woosh/meep-engine 3.47.0 → 3.50.0

package/src/shade/renderer/scene/GPUSceneContext.d.ts

@@ -9,6 +9,15 @@
  * local TRS and the row of its parent, through {@link rows}.
  */
 export class GPUSceneContext {
+    /**
+     * Offer the pipelines every scene is updated with each frame — its database's uploads, the
+     * transform hierarchy, mesh bounds, light poses and environment, and the tree over its instances
+     * — see {@link PipelineEnquiry}. What only some scenes have, virtual geometry, volumes, a light
+     * probe volume, waits for the first frame of a scene that has it.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      *
      * @param {GraphicsContext} graphics
@@ -38,6 +47,13 @@ export class GPUSceneContext {
      */
     get scene(): Scene;
     get volumetrics(): GPUSceneVolumetrics;
+    /**
+     * The scene's published wind field: every GPU consumer of the wind binds it, with or without a
+     * producer. Still air — no cascades, a far field of 0 — until the GPU fluid fills it.
+     *
+     * @returns {GPUSceneWind}
+     */
+    get wind(): GPUSceneWind;
     /**
      * Not necessarily current: a reader calls {@link GPUSky#update} first, which does the work the
      * first time and nothing after.
@@ -193,7 +209,7 @@ export class GPUSceneContext {
      * Release this context's virtual geometry — everything {@link enable_virtual_geometry} built,
      * so that a host tears a scene down by destroying the renderer and nothing of the streaming loop
      * is left for it to find — then its rows, its database, its TLAS, its lights, its probe volume,
-     * its volumetrics, its sky, its volumetric light map, its animation and its skinning: every buffer the
+     * its volumetrics, its wind, its sky, its volumetric light map, its animation and its skinning: every buffer the
      * context made. Safe to call twice, and on a context that never enabled virtual geometry.
      */
     destroy(): void;
@@ -204,6 +220,7 @@ export class GPUSceneContext {
     readonly isGPUSceneContext: boolean;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 export type GPUGeometryManager = import("../geometry/GPUGeometryManager.js").GPUGeometryManager;
 export type GPUMaterialManager = import("../material/GPUMaterialManager.js").GPUMaterialManager;
@@ -212,6 +229,7 @@ export type GPURecordWriter = import("../buffer/table/serde/generate_record_writ
 import { Brick4LightMap } from "../global_illumination/brick4/Brick4LightMap.js";
 import { Scene } from "./Scene.js";
 import { GPUSceneVolumetrics } from "../volumetrics/GPUSceneVolumetrics.js";
+import { GPUSceneWind } from "../wind/GPUSceneWind.js";
 import { GPUSky } from "../atmosphere/GPUSky.js";
 import { GPULightCollection } from "../light/GPULightCollection.js";
 import { GPULightProbeVolume } from "../global_illumination/lpv/GPULightProbeVolume.js";

package/src/shade/renderer/scene/GPUSceneContext.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAsEA;;;;;;;;;GASG;AACH;IA4JI;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAsCf;IAnMD;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAgID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA0BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAkBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BA9vBY,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAvBvD,iDAAiD;sBAK1D,YAAY;oCADE,uCAAuC;uBAFpD,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAKrC,wCAAwC;0CAhBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCAQrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAfpC,wCAAwC"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AAwEA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA2KD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAyCf;IArND;;;OAGG;IACH,aAFU,MAAM,CAEE;IAElB;;OAEG;IACH,YAFU,kBAAkB,CAEjB;IAEX;;OAEG;IACH,WAFU,kBAAkB,CAElB;IAGV;;OAEG;IACH,sBAFU,cAAc,CAEH;IASrB;;;OAGG;IACH,mBAEC;IAOD,uCAEC;IAOD;;;;;OAKG;IACH,yBAEC;IAUD;;;;;OAKG;IACH,kBAEC;IAQD;;;OAGG;IACH,iCAEC;IAOD;;;OAGG;IACH,8CAEC;IAOD;;;OAGG;IACH,8CAEC;IAmID;;OAEG;IACH,kDAEC;IAED;;OAEG;IACH,gDAEC;IAED;;OAEG;IACH,kDAEC;IAED;;;;;;;;;;;;;;;;;;;OAmBG;IACH;QAH0C,SAAS,GAAxC,oBAAoB;QAClB,yBAAyB,CAuDrC;IAED;;OAEG;IACH,6CAEC;IAYD;;;OAGG;IACH,kCAEC;IAED;;;;;OAKG;IACH,uCAEC;IAED;;;;;;;;;;;OAWG;IACH,uCAUC;IAED,+BAUC;IAED;;;;;;;;;;OAUG;IACH,yBAEC;IAED;;;;;OAKG;IACH,sCAMC;IAOD;;;;;;;OAOG;IACH,8EAEC;IA0BD;;;;;OAKG;IACH,cAsEC;IAED;;;OAGG;IACH,YAFW,eAAe,QA2BzB;IAED;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH,cAHW,sBAAsB,cACtB,MAAM,QAuBhB;IAoCD;;;;;;OAMG;IACH,gBAmBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BApyBY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;iCAC/C,OAAO,mCAAmC,EAAE,kBAAkB;iCAC9D,OAAO,mCAAmC,EAAE,kBAAkB;4BAC9D,OAAO,8BAA8B,EAAE,aAAa;8BACpD,OAAO,iDAAiD,EAAE,eAAe;+BAzBvD,iDAAiD;sBAM1D,YAAY;oCAFE,uCAAuC;6BAC9C,yBAAyB;uBAH/B,yBAAyB;mCACb,gCAAgC;oCAF/B,mDAAmD;kDAMrC,wCAAwC;0CAjBhD,0DAA0D;8BAItE,8CAA8C;iCAF3C,iDAAiD;qCAG7C,qDAAqD;oCAGtD,qCAAqC;4BAC7C,gCAAgC;uCASrB,iDAAiD;6BAM3D,wBAAwB;wCADb,mCAAmC;uCAhBpC,wCAAwC"}

package/src/shade/renderer/scene/GPUSceneContext.js

@@ -14,6 +14,7 @@ import { GPULightProbeVolume } from "../global_illumination/lpv/GPULightProbeVol
 import { GPUSky } from "../atmosphere/GPUSky.js";
 import { GPULightCollection } from "../light/GPULightCollection.js";
 import { GPUSceneVolumetrics } from "../volumetrics/GPUSceneVolumetrics.js";
+import { GPUSceneWind } from "../wind/GPUSceneWind.js";
 import { Scene } from "./Scene.js";
 import { GPUInstancesAccelerationStructure } from "./GPUInstancesAccelerationStructure.js";
 import { GPUMeshSkinningContext } from "../animation/skinning/GPUMeshSkinningContext.js";
@@ -28,6 +29,7 @@ import { NODE3D_SCENE_ID, NODE3D_STRUCT } from "./NODE3D_STRUCT.js";
 import { SCENE_DATABASE_SPEC } from "./SCENE_DATABASE_SPEC.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("../geometry/GPUGeometryManager.js").GPUGeometryManager} GPUGeometryManager
  * @typedef {import("../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
@@ -80,6 +82,23 @@ const NO_MATERIALS = Object.freeze([]);
  */
 export class GPUSceneContext {
 
+    /**
+     * Offer the pipelines every scene is updated with each frame — its database's uploads, the
+     * transform hierarchy, mesh bounds, light poses and environment, and the tree over its instances
+     * — see {@link PipelineEnquiry}. What only some scenes have, virtual geometry, volumes, a light
+     * probe volume, waits for the first frame of a scene that has it.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    static enquirePipelines(enquiry) {
+        GPUDatabase.enquirePipelines(enquiry);
+        GPUAnimationManager.enquirePipelines(enquiry);
+        enquiry.compute.push(shader_refresh_all_mesh_bounds.pipeline);
+        GPULightCollection.enquirePipelines(enquiry);
+        GPUInstancesAccelerationStructure.enquirePipelines(enquiry);
+        GPUSceneVolumetrics.enquirePipelines(enquiry);
+    }
+
     /**
      * @readonly
      * @type {number}
@@ -126,6 +145,21 @@ export class GPUSceneContext {
         return this.#volumetrics;
     }
 
+    /**
+     * @type {GPUSceneWind}
+     */
+    #wind;
+
+    /**
+     * The scene's published wind field: every GPU consumer of the wind binds it, with or without a
+     * producer. Still air — no cascades, a far field of 0 — until the GPU fluid fills it.
+     *
+     * @returns {GPUSceneWind}
+     */
+    get wind() {
+        return this.#wind;
+    }
+
     /**
      * The atmosphere's LUTs, built once for the scene and read by every view that needs them. They
      * depend on the atmosphere's constants alone, so no view owns a copy.
@@ -268,10 +302,13 @@ export class GPUSceneContext {
         this.volumetric_light_map = new Brick4LightMap(device);
 
         this.#volumetrics = new GPUSceneVolumetrics(
+            device,
             this.#scene_database.get('participating_media_volumes'),
             scene.volumetrics
         );
 
+        this.#wind = new GPUSceneWind(device);
+
         this.#sky = new GPUSky(graphics);
 
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
@@ -642,6 +679,7 @@ export class GPUSceneContext {
         this.#light_probe_volume.update();
         this.#lights.update(ctx);
         this.#volumetrics.update(ctx, 0);
+        this.#wind.update();
 
         // Per-frame animation database flush — picks up any new clips,
         // tracks, skins, or per-frame `set_time` writes queued since
@@ -739,7 +777,7 @@ export class GPUSceneContext {
      * Release this context's virtual geometry — everything {@link enable_virtual_geometry} built,
      * so that a host tears a scene down by destroying the renderer and nothing of the streaming loop
      * is left for it to find — then its rows, its database, its TLAS, its lights, its probe volume,
-     * its volumetrics, its sky, its volumetric light map, its animation and its skinning: every buffer the
+     * its volumetrics, its wind, its sky, its volumetric light map, its animation and its skinning: every buffer the
      * context made. Safe to call twice, and on a context that never enabled virtual geometry.
      */
     destroy() {
@@ -754,6 +792,7 @@ export class GPUSceneContext {
         this.#lights.destroy();
         this.#light_probe_volume.destroy();
         this.#volumetrics.destroy();
+        this.#wind.destroy();
         this.#sky.destroy();
         this.volumetric_light_map.destroy();
         this.#animation_manager.destroy();

package/src/shade/renderer/scene/MESH_INSTANCE_METADATA_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"MESH_INSTANCE_METADATA_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/MESH_INSTANCE_METADATA_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,yDAU0B;6BArBG,gCAAgC"}
+{"version":3,"file":"MESH_INSTANCE_METADATA_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/MESH_INSTANCE_METADATA_STRUCT.js"],"names":[],"mappings":"AAIA;;;;;;;;GAQG;AACH,yDAe0B;6BA1BG,gCAAgC"}

package/src/shade/renderer/scene/MESH_INSTANCE_METADATA_STRUCT.js

@@ -21,4 +21,9 @@ export const MESH_INSTANCE_METADATA_STRUCT = WebGPUStruct.from({
     node: u32,
     bounding_box: WebGPUArray.from(f32, 6),
     bounding_sphere: vec4f,
+    /**
+     * This mesh's chart in the lightmap atlas, `[u0, v0, u1, v1]`: the lightmap shaders map the
+     * geometry's uv1 square onto it. Nothing packs an atlas yet, so every row's chart is empty.
+     */
+    lightmap_uvs: vec4f,
 }, "MeshMetadata").pack();

package/src/shade/renderer/scene/SCENE_DATABASE_RESOURCE.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The scene database (`SCENE_DATABASE_SPEC`), read through `chunk_scene_database_access`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCENE_DATABASE_RESOURCE: ShaderResourceDescriptor;
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+//# sourceMappingURL=SCENE_DATABASE_RESOURCE.d.ts.map

package/src/shade/renderer/scene/SCENE_DATABASE_RESOURCE.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCENE_DATABASE_RESOURCE.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SCENE_DATABASE_RESOURCE.js"],"names":[],"mappings":"AAGA;;;GAGG;AACH,sCAFU,wBAAwB,CAE+E;yCAPxE,gDAAgD"}

package/src/shade/renderer/scene/SCENE_DATABASE_RESOURCE.js

@@ -0,0 +1,8 @@
+import { ShaderResourceDescriptor } from "../shader/resource/ShaderResourceDescriptor.js";
+import { WebGPUArray } from "../shader/type/WebGPUArray.js";
+
+/**
+ * The scene database (`SCENE_DATABASE_SPEC`), read through `chunk_scene_database_access`.
+ * @type {ShaderResourceDescriptor}
+ */
+export const SCENE_DATABASE_RESOURCE = ShaderResourceDescriptor.storageBuffer("scene_database", WebGPUArray.u32);

package/src/shade/renderer/scene/SceneManager.d.ts

@@ -1,4 +1,5 @@
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("./Scene.js").Scene} Scene
  */
@@ -19,6 +20,13 @@ export class SceneManager {
      * @returns {GPUSceneContext}
      */
     obtain(scene: Scene): GPUSceneContext;
+    /**
+     * Offer the pipelines a scene context is updated with — see {@link GPUSceneContext.enquirePipelines}.
+     * Asked before there is a scene to ask about, so it answers for scenes in general.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry: PipelineEnquiry): void;
     /**
      * Release every scene context this handed out.
      *
@@ -31,6 +39,7 @@ export class SceneManager {
     destroy(): void;
     #private;
 }
+export type PipelineEnquiry = import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 export type GraphicsContext = import("../GraphicsContext.js").GraphicsContext;
 export type Scene = import("./Scene.js").Scene;
 import { GPUSceneContext } from "./GPUSceneContext.js";

package/src/shade/renderer/scene/SceneManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneManager.js"],"names":[],"mappings":"AAEA;;;GAGG;AAEH;IAaI;;;OAGG;IACH,sBAFW,eAAe,EAIzB;IAjBD;;;OAGG;IACH,gBAFU,IAAI,KAAK,EAAC,eAAe,CAAC,CAET;IA6B3B;;;;OAIG;IACH,cAHW,KAAK,GACH,eAAe,CAY3B;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAQhB;;CAEJ;8BAzEY,OAAO,uBAAuB,EAAE,eAAe;oBAC/C,OAAO,YAAY,EAAE,KAAK;gCAJP,sBAAsB"}
+{"version":3,"file":"SceneManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/SceneManager.js"],"names":[],"mappings":"AAEA;;;;GAIG;AAEH;IAaI;;;OAGG;IACH,sBAFW,eAAe,EAIzB;IAjBD;;;OAGG;IACH,gBAFU,IAAI,KAAK,EAAC,eAAe,CAAC,CAET;IA6B3B;;;;OAIG;IACH,cAHW,KAAK,GACH,eAAe,CAY3B;IAED;;;;;OAKG;IACH,0BAFW,eAAe,QAIzB;IAED;;;;;;;;OAQG;IACH,WAFa,IAAI,CAQhB;;CAEJ;8BApFY,OAAO,0CAA0C,EAAE,eAAe;8BAClE,OAAO,uBAAuB,EAAE,eAAe;oBAC/C,OAAO,YAAY,EAAE,KAAK;gCALP,sBAAsB"}

package/src/shade/renderer/scene/SceneManager.js

@@ -1,6 +1,7 @@
 import { GPUSceneContext } from "./GPUSceneContext.js";
 
 /**
+ * @typedef {import("../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
  * @typedef {import("../GraphicsContext.js").GraphicsContext} GraphicsContext
  * @typedef {import("./Scene.js").Scene} Scene
  */
@@ -57,6 +58,16 @@ export class SceneManager {
         return ctx;
     }
 
+    /**
+     * Offer the pipelines a scene context is updated with — see {@link GPUSceneContext.enquirePipelines}.
+     * Asked before there is a scene to ask about, so it answers for scenes in general.
+     *
+     * @param {PipelineEnquiry} enquiry
+     */
+    enquirePipelines(enquiry) {
+        GPUSceneContext.enquirePipelines(enquiry);
+    }
+
     /**
      * Release every scene context this handed out.
      *

package/src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.d.ts

@@ -1,3 +1,13 @@
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+/**
+ * Offer the pipelines {@link graph_nodes_update_transform_hierarchy} dispatches — see
+ * {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_nodes_update_transform_hierarchy_pipelines(enquiry: PipelineEnquiry): void;
 /**
  * FrameGraph harness for the CSDLDF-style scene-graph hierarchy update.
  *
@@ -46,4 +56,5 @@ export function graph_nodes_update_transform_hierarchy({ graph, input, scene_dat
 }): {
     scene_database: number;
 };
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 //# sourceMappingURL=graph_nodes_update_transform_hierarchy.d.ts.map

package/src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_nodes_update_transform_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAR6B,KAAK;IACL,KAAK,EAAvB,MAAM;IACY,cAAc,EAAhC,MAAM;IACY,aAAa,EAA/B,MAAM;IACY,iBAAiB,GAAnC,MAAM;IAEJ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAqJtC"}
+{"version":3,"file":"graph_nodes_update_transform_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.js"],"names":[],"mappings":"AAcA;;GAEG;AAEH;;;;;GAKG;AACH,4EAFW,eAAe,QAMzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IAR6B,KAAK;IACL,KAAK,EAAvB,MAAM;IACY,cAAc,EAAhC,MAAM;IACY,aAAa,EAA/B,MAAM;IACY,iBAAiB,GAAnC,MAAM;IAEJ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAqJtC;8BAzMY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/scene/hierarchy/graph_nodes_update_transform_hierarchy.js

@@ -5,12 +5,29 @@ import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDe
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import {
     build_indirect_compute_dispatch_command,
+    indirect_compute_dispatch_command_pipeline,
     INDIRECT_COMPUTE_COMMAND_DESCRIPTOR
 } from "../../gpu_primitive/indirect/IndirectComputeCommandBuildPass.js";
 import { shader_nodes_record_input_positions } from "./shader_nodes_record_input_positions.js";
 import { shader_nodes_update_transform_hierarchy } from "./shader_nodes_update_transform_hierarchy.js";
 import { TRANSFORM_HIERARCHY_PARTITION_SIZE } from "./TRANSFORM_HIERARCHY_PARTITION_SIZE.js";
 
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+/**
+ * Offer the pipelines {@link graph_nodes_update_transform_hierarchy} dispatches — see
+ * {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_nodes_update_transform_hierarchy_pipelines(enquiry) {
+    enquiry.compute.push(indirect_compute_dispatch_command_pipeline(enquiry.device, TRANSFORM_HIERARCHY_PARTITION_SIZE, false));
+    enquiry.compute.push(shader_nodes_record_input_positions.pipeline);
+    enquiry.compute.push(shader_nodes_update_transform_hierarchy.pipeline);
+}
+
 /**
  * FrameGraph harness for the CSDLDF-style scene-graph hierarchy update.
  *

package/src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.d.ts

@@ -1,3 +1,13 @@
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+/**
+ * Offer the pipelines {@link graph_scene_update_transform_hierarchy} dispatches — see
+ * {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_scene_update_transform_hierarchy_pipelines(enquiry: PipelineEnquiry): void;
 /**
  * High-level wrapper: refresh `node.global` for *every* node in the
  * scene this frame.
@@ -43,4 +53,5 @@ export function graph_scene_update_transform_hierarchy({ graph, scene, scene_dat
 }): {
     scene_database: number;
 };
+export type PipelineEnquiry = import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry;
 //# sourceMappingURL=graph_scene_update_transform_hierarchy.d.ts.map

package/src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_scene_update_transform_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAZqC,KAAK;IACL,KAAK;IACL,cAAc,GAAxC,MAAM;IAOJ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAwFtC"}
+{"version":3,"file":"graph_scene_update_transform_hierarchy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.js"],"names":[],"mappings":"AAUA;;GAEG;AAEH;;;;;GAKG;AACH,4EAFW,eAAe,QAIzB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAqCG;AACH;IAZqC,KAAK;IACL,KAAK;IACL,cAAc,GAAxC,MAAM;IAOJ;IAAE,cAAc,EAAE,MAAM,CAAA;CAAE,CAwFtC;8BAxIY,OAAO,6CAA6C,EAAE,eAAe"}

package/src/shade/renderer/scene/hierarchy/graph_scene_update_transform_hierarchy.js

@@ -3,7 +3,24 @@ import { round_up } from "../../../../core/math/round_up.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
-import { graph_nodes_update_transform_hierarchy } from "./graph_nodes_update_transform_hierarchy.js";
+import {
+    enquire_nodes_update_transform_hierarchy_pipelines,
+    graph_nodes_update_transform_hierarchy
+} from "./graph_nodes_update_transform_hierarchy.js";
+
+/**
+ * @typedef {import("../../../device/pipeline/PipelineEnquiry.js").PipelineEnquiry} PipelineEnquiry
+ */
+
+/**
+ * Offer the pipelines {@link graph_scene_update_transform_hierarchy} dispatches — see
+ * {@link PipelineEnquiry}.
+ *
+ * @param {PipelineEnquiry} enquiry
+ */
+export function enquire_scene_update_transform_hierarchy_pipelines(enquiry) {
+    enquire_nodes_update_transform_hierarchy_pipelines(enquiry);
+}
 
 /**
  * High-level wrapper: refresh `node.global` for *every* node in the

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts

@@ -48,6 +48,13 @@ export function entity_of_row(row: number): number;
  * unchanged, and the GPU composes the rest. That is what stops a root's move from costing a row
  * per descendant.
  *
+ * **A placement is the one event the rows follow themselves.** `TRANSFORM64_EVENT_PLACED` says a
+ * pose was teleported rather than moved, and is the same fact for every holder of the row, so the
+ * rows listen for it on every acquired entity rather than asking each placing system to. The next
+ * flush writes the row the way its first write did, `prev_global` seeded to `global` at the new
+ * pose, so motion vectors — TAA's, a wake's — read no motion for the teleport rather than one
+ * frame's jump across the world.
+ *
  * **Render bounds are never written from this side.** They are derived on the GPU every tick from
  * the composed world matrix, because the CPU does not hold that matrix for a subtree the GPU
  * drives; a row is written with them underived, and the bounds pass has filled them in before
@@ -137,6 +144,9 @@ export class GPUSceneRows {
      * Children already holding rows are re-marked on the first hold, so that they point at this
      * one from the next flush instead of carrying their world pose under the scene root.
      *
+     * The first hold also starts following the entity's placements, until the last
+     * {@link release}.
+     *
      * @param {number} entity
      */
     acquire(entity: number): void;
@@ -240,6 +250,10 @@ export class GPUSceneRows {
      * next — so no row is given back to them one at a time, which cost about 2 µs a row and took a
      * scene of millions seconds to leave. What outlives the context is not the rows' to give back:
      * the skinned clones go back to the shared geometry manager with the skinning context.
+     *
+     * The placement listeners are the exception, being the dataset's, which outlives the context:
+     * each acquired entity's is taken off, or a restart would leave every entity calling into rows
+     * that are gone.
      */
     destroy(): void;
     #private;

package/src/shade/renderer/scene/rows/GPUSceneRows.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAcA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AA0ID;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;OAUG;IACH,gBAFW,MAAM,QAuChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA0BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;;OAaG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IA0MD;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;OAKG;IACH,gBAUC;;CACJ;qCAppCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}
+{"version":3,"file":"GPUSceneRows.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/rows/GPUSceneRows.js"],"names":[],"mappings":"AAeA;;;;;;;;;;GAUG;AAEH;;;;;;;;;GASG;AACH,sCAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AA+KD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IA2II;;;;;;;;;OASG;IACH;QAR2C,OAAO,EAAvC,sBAAsB;QACC,UAAU;QACV,MAAM;QACD,UAAU,EAAtC,kBAAkB;QACU,SAAS,EAArC,kBAAkB;QACyB,IAAI,EAA/C,iCAAiC;QACW,QAAQ,QAAxC,sBAAsB;OAmB5C;IAED;;OAEG;IACH,iGAEC;IAED;;;;;OAKG;IACH,gCAEC;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;;OAQG;IACH,oBAA8B;IAE9B;;;;;OAKG;IACH,iBAHW,MAAM,GACJ,OAAO,CAInB;IAED;;;;;;;OAOG;IACH,8BAHoB,MAAM,QAAE,eAAe,QAAE,aAAa,QAAE,OAAO,KAAG,IAAI,QASzE;IAED;;;;;;;;;OASG;IACH,6BAHW,KAAK,GACH,OAAO,CAyBnB;IAED;;;;;;;;;;;;;OAaG;IACH,gBAFW,MAAM,QA0ChB;IAED;;;;;;;;OAQG;IACH,gBAFW,MAAM,QA4BhB;IAED;;;;OAIG;IACH,mBAFW,MAAM,QAIhB;IAED;;;;;;;;;;;;;OAaG;IACH,sBAFW,MAAM,QAIhB;IAED;;;;;OAKG;IACH,mBAFW,MAAM,QAIhB;IA4BD;;;;;OAKG;IACH,2EAOC;IAED;;;;OAIG;IACH,gCAEC;IAqCD;;;;;;;;;;;;;;OAcG;IACH,oBALW,MAAM,YACN,eAAe,YACf,aAAa,YACb,OAAO,QAgDjB;IAED;;;;;OAKG;IACH,oBAFW,MAAM,QAUhB;IAwCD;;;;OAIG;IACH,SAFa,MAAM,CAsDlB;IAyND;;;;OAIG;IACH;;;;;;;;OAQG;IACH,4BAHW,MAAM,kBACG,MAAM,KAAG,IAAI,QAiBhC;IAyGD;;;;;;;;;OASG;IACH,gBAgBC;;CACJ;qCA3vCY,OAAO,kDAAkD,EAAE,sBAAsB;;iCAEjF,OAAO,sCAAsC,EAAE,kBAAkB;iCACjE,OAAO,sCAAsC,EAAE,kBAAkB;gDACjE,OAAO,yCAAyC,EAAE,iCAAiC;qCACnF,OAAO,oDAAoD,EAAE,sBAAsB;8BACnF,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;oBACvD,OAAO,wCAAwC,EAAE,KAAK"}

package/src/shade/renderer/scene/rows/GPUSceneRows.js

@@ -7,6 +7,7 @@ import { TransformAttachment } from "../../../../engine/ecs/transform-attachment
 import { aabb3_matrix4_project } from "../../../../core/geom/3d/aabb/aabb3_matrix4_project.js";
 import { m4_linear_determinant } from "../../../../core/geom/3d/mat4/m4_linear_determinant.js";
 import { Transform64 } from "../../../../engine/ecs/transform/Transform64.js";
+import { TRANSFORM64_EVENT_PLACED } from "../../../../engine/ecs/transform/TRANSFORM64_EVENT_PLACED.js";
 import { generate_record_writer } from "../../buffer/table/serde/generate_record_writer.js";
 import { MESH_INSTANCE_METADATA_STRUCT } from "../MESH_INSTANCE_METADATA_STRUCT.js";
 import { NODE3D_GLOBAL_FLAG_MIRRORED, NODE3D_SCENE_ID, NODE3D_STRUCT } from "../NODE3D_STRUCT.js";
@@ -63,9 +64,15 @@ const MARK_MESH = 4;
  */
 const MARK_HANDOVER = 8;
 
+/**
+ * The entity was placed — `TRANSFORM64_EVENT_PLACED`, a teleport: its world matrices are seeded to
+ * the new pose as on the row's first write. Always carried with {@link MARK_WORLD}.
+ */
+const MARK_PLACED = 16;
+
 /**
  * Staging for one `transforms` row, reused across every write. `global` and `prev_global` are read
- * only on a row's first write.
+ * only on a row's first write and on a placement.
  */
 const TRANSFORM_RECORD = {
     local_translation: new Float32Array(3),
@@ -93,6 +100,14 @@ const UNDERIVED_BOUNDING_BOX = new Float32Array(6);
  */
 const UNDERIVED_BOUNDING_SPHERE = new Float32Array(4);
 
+/**
+ * A `meshes` row's lightmap chart. Nothing packs a lightmap atlas, so every row is written with an
+ * empty one, and a row taken over from a released entity does not keep that entity's chart.
+ *
+ * @type {Float32Array}
+ */
+const EMPTY_LIGHTMAP_CHART = new Float32Array(4);
+
 /**
  * One mesh entry's geometry box under its entity's world matrix, for
  * {@link GPUSceneRows.compute_world_bounds}.
@@ -110,12 +125,14 @@ const MESH_RECORD = {
     node: NODE3D_SCENE_ID,
     bounding_box: UNDERIVED_BOUNDING_BOX,
     bounding_sphere: UNDERIVED_BOUNDING_SPHERE,
+    lightmap_uvs: EMPTY_LIGHTMAP_CHART,
 };
 
 /**
  * The fields of a row this side owns: its local TRS and the row of its parent. `global` and
  * `prev_global` are composed by the hierarchy pass every frame for every row, whoever owns the TRS
- * — see `GPUSceneContext` for why writing them here would be wrong as well as wasteful.
+ * — see `GPUSceneContext` for why writing them here would be wrong as well as wasteful. The
+ * exceptions are the seeding writes: a row's first, and a placement's.
  *
  * @type {GPURecordWriter}
  */
@@ -136,12 +153,33 @@ const TRANSFORM_PARENT_WRITER = generate_record_writer(NODE3D_STRUCT, ['parent']
 
 /**
  * The whole row, for its first write: `global` and `prev_global` are seeded to the entity's world
- * matrix so its first frame reports no motion instead of a jump from the origin.
+ * matrix so its first frame reports no motion instead of a jump from the origin. And for a
+ * placement, so a teleport reports none instead of a jump from where it was.
+ *
+ * The seed survives the hierarchy pass because of what the pass does with it: it copies the row's
+ * `global` into `prev_global`, then composes `global` from the TRS. With `global` seeded to the new
+ * pose and the TRS composing the same one, both come out equal.
  *
  * @type {GPURecordWriter}
  */
 const TRANSFORM_RECORD_WRITER = generate_record_writer(NODE3D_STRUCT);
 
+/**
+ * The seeded world matrices and the parent row, without the TRS: a placement of a row whose local
+ * offset the GPU writes (`GPUStateAuthority`). The matrices are seeded from the entity's CPU world,
+ * which for a subtree the GPU drives is the twin's — a frame behind at most, where the unseeded row
+ * would have reported the whole teleport as one frame's motion. One range: the four fields are
+ * adjacent.
+ *
+ * @type {GPURecordWriter}
+ */
+const TRANSFORM_SEED_WRITER = generate_record_writer(NODE3D_STRUCT, [
+    'global',
+    'prev_global',
+    'parent',
+    'global_flags',
+]);
+
 /**
  * @type {GPURecordWriter}
  */
@@ -205,6 +243,13 @@ class MeshEntry {
  * unchanged, and the GPU composes the rest. That is what stops a root's move from costing a row
  * per descendant.
  *
+ * **A placement is the one event the rows follow themselves.** `TRANSFORM64_EVENT_PLACED` says a
+ * pose was teleported rather than moved, and is the same fact for every holder of the row, so the
+ * rows listen for it on every acquired entity rather than asking each placing system to. The next
+ * flush writes the row the way its first write did, `prev_global` seeded to `global` at the new
+ * pose, so motion vectors — TAA's, a wake's — read no motion for the teleport rather than one
+ * frame's jump across the world.
+ *
  * **Render bounds are never written from this side.** They are derived on the GPU every tick from
  * the composed world matrix, because the CPU does not hold that matrix for a subtree the GPU
  * drives; a row is written with them underived, and the bounds pass has filled them in before
@@ -486,6 +531,9 @@ export class GPUSceneRows {
      * Children already holding rows are re-marked on the first hold, so that they point at this
      * one from the next flush instead of carrying their world pose under the scene root.
      *
+     * The first hold also starts following the entity's placements, until the last
+     * {@link release}.
+     *
      * @param {number} entity
      */
     acquire(entity) {
@@ -505,13 +553,16 @@ export class GPUSceneRows {
 
         this.#parent_entity[entity] = -1;
 
+        const dataset = this.#dataset;
+
+        dataset.addEntityEventListener(entity, TRANSFORM64_EVENT_PLACED, this.#placed, this);
+
         /*
          Indexed under its attachment's parent from the start rather than at the first flush: the
          animation manager walks the rows below a joint the moment a clip binds to it, which is
          the same update the rows were acquired in. The flush re-registers, so a parent that
          changes later is still followed.
         */
-        const dataset = this.#dataset;
         const attachment_index = dataset.computeComponentTypeIndex(TransformAttachment);
 
         if (attachment_index !== -1) {
@@ -547,6 +598,8 @@ export class GPUSceneRows {
             return;
         }
 
+        this.#unfollow(entity);
+
         this.#free_mesh(entity);
 
         if (this.#written.get(entity)) {
@@ -599,6 +652,32 @@ export class GPUSceneRows {
         this.#mark(entity, MARK_WORLD);
     }
 
+    /**
+     * `TRANSFORM64_EVENT_PLACED` on an acquired entity.
+     *
+     * @param {*} event
+     * @param {number} entity
+     */
+    #placed(event, entity) {
+        this.#mark(entity, MARK_WORLD | MARK_PLACED);
+    }
+
+    /**
+     * Stop following the entity's placements.
+     *
+     * @param {number} entity
+     */
+    #unfollow(entity) {
+        const dataset = this.#dataset;
+
+        if (!dataset.entityExists(entity)) {
+            // its listeners went with it
+            return;
+        }
+
+        dataset.removeEntityEventListener(entity, TRANSFORM64_EVENT_PLACED, this.#placed, this);
+    }
+
     /**
      * Every material some written mesh row draws with, each once. The array is reused until the set
      * changes — compare {@link materials_version} to know whether it did.
@@ -858,8 +937,16 @@ export class GPUSceneRows {
         const local = parent_has_row ? attachment.transform : world;
 
         const first = !this.#written.get(entity);
+        const placed = (why & MARK_PLACED) !== 0;
 
-        if (first) {
+        // The GPU writes this row's TRS — a clip, a pose the CPU never sees — and a CPU that wrote
+        // it too would race what the animation just resolved. A hand-over is the one write past the
+        // bit: the offset as the GPU takes it.
+        const gpu_writes_offset = (flags & GPUStateAuthorityFlags.TransformAttachment) !== 0
+            && (why & MARK_HANDOVER) === 0;
+
+        if (first || (placed && !gpu_writes_offset)) {
+            // the seeding write: the whole row, both world matrices at the entity's pose
             this.#transforms.set_record(row, this.#seed_record(local, parent_row, world), TRANSFORM_RECORD_WRITER);
 
             this.#written.set(entity, true);
@@ -870,11 +957,18 @@ export class GPUSceneRows {
 
         const parent_changed = this.#parent_row[entity] !== parent_row;
 
-        if ((flags & GPUStateAuthorityFlags.TransformAttachment) !== 0 && (why & MARK_HANDOVER) === 0) {
-            // The GPU writes this row's TRS — a clip, a pose the CPU never sees — and a CPU that
-            // wrote it too would race what the animation just resolved. The parent row is still
-            // this side's, and changes only when the parent's own row comes or goes. A hand-over
-            // is the one write past the bit: the offset as the GPU takes it.
+        if (gpu_writes_offset) {
+            if (placed) {
+                // seeded all the same, around the offset the GPU owns
+                this.#transforms.set_fields(row, this.#seed_record(local, parent_row, world), TRANSFORM_SEED_WRITER);
+
+                this.#parent_row[entity] = parent_row;
+
+                return 1;
+            }
+
+            // The parent row is still this side's, and changes only when the parent's own row comes
+            // or goes.
             if (!parent_changed) {
                 return 0;
             }
@@ -1173,8 +1267,18 @@ export class GPUSceneRows {
      * next — so no row is given back to them one at a time, which cost about 2 µs a row and took a
      * scene of millions seconds to leave. What outlives the context is not the rows' to give back:
      * the skinned clones go back to the shared geometry manager with the skinning context.
+     *
+     * The placement listeners are the exception, being the dataset's, which outlives the context:
+     * each acquired entity's is taken off, or a restart would leave every entity calling into rows
+     * that are gone.
      */
     destroy() {
+        const acquired = this.#acquired;
+
+        for (let entity = acquired.nextSetBit(0); entity !== -1; entity = acquired.nextSetBit(entity + 1)) {
+            this.#unfollow(entity);
+        }
+
         this.#mesh_entries.clear();
 
         this.#acquired.reset();