@woosh/meep-engine 3.49.0 → 3.50.0

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

@@ -47,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.
@@ -202,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;
@@ -222,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":"AAuEA;;;;;;;;;GASG;AACH;IAEI;;;;;;;OAOG;IACH,iCAFW,eAAe,QASzB;IA4JD;;;;OAIG;IACH,sBAHW,eAAe,SACf,KAAK,EAuCf;IApMD;;;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;IAiID;;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;8BAjxBY,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;+BAxBvD,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";
@@ -144,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.
@@ -291,6 +307,8 @@ export class GPUSceneContext {
             scene.volumetrics
         );
 
+        this.#wind = new GPUSceneWind(device);
+
         this.#sky = new GPUSky(graphics);
 
         this.#animation_manager = new GPUAnimationManager(device, `GPUSceneContext[${this.id}]/Animation`, this);
@@ -661,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
@@ -758,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() {
@@ -773,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/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();

package/src/shade/renderer/shader/ComputeShader.d.ts

@@ -126,6 +126,27 @@ export class ComputeShader {
         group_count_y?: number;
         group_count_z?: number;
     }): void;
+    /**
+     * Like {@link dispatch}, into a compute pass the caller has open and ends, so that a run of
+     * dispatches shares one pass. A dispatch sees the writes of the dispatches before it in the
+     * same pass.
+     *
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder the context `pass` was begun on
+     * @param {ShadeGPUComputePassEncoder} options.pass
+     * @param {Object} options.bindings
+     * @param {number} [options.group_count_x]
+     * @param {number} [options.group_count_y]
+     * @param {number} [options.group_count_z]
+     */
+    dispatchInPass({ encoder, pass, bindings, group_count_x, group_count_y, group_count_z, }: {
+        encoder: ShadeGPUCommandContext;
+        pass: ShadeGPUComputePassEncoder;
+        bindings: any;
+        group_count_x?: number;
+        group_count_y?: number;
+        group_count_z?: number;
+    }): void;
     /**
      * Dispatch with the workgroup counts a GPU pass wrote into `command`.
      *

package/src/shade/renderer/shader/ComputeShader.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAUA;IA2JI;;;;;;;;;;OAUG;IACH;QAR4B,KAAK,GAAtB,MAAM;QAC+B,SAAS;QAC3B,IAAI;QACJ,UAAU,GAA7B,MAAM,EAAE;QAGN,aAAa,CAuBzB;IA5DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAjID;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IAQD;;;;;;;;;OASG;IACH,aAHW,eAAe,GACb,aAAa,CAiCzB;IAgED;;;;;;OAMG;IACH;QAJ2C,OAAO;QACvB,QAAQ;mCA8BlC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAP2C,OAAO;QACvB,QAAQ;QACP,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;aAgChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACvB,QAAQ;QACR,aAAa,EAA7B,MAAM;aAsBhB;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACvB,QAAQ;QACP,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aA2ChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACpB,OAAO;QACV,QAAQ;QACP,cAAc,GAA/B,MAAM;aAwChB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;8BAhaY,OAAO,+BAA+B,EAAE,eAAe;0CAJ1B,gEAAgE;iCACzE,uBAAuB"}
+{"version":3,"file":"ComputeShader.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ComputeShader.js"],"names":[],"mappings":"AAUA;IA2JI;;;;;;;;;;OAUG;IACH;QAR4B,KAAK,GAAtB,MAAM;QAC+B,SAAS;QAC3B,IAAI;QACJ,UAAU,GAA7B,MAAM,EAAE;QAGN,aAAa,CAuBzB;IA5DD;;;OAGG;IACH,wBAFW,gBAAgB,EAwB1B;IAjID;;;OAGG;IACH,0CAEC;IAgBD;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,2BAEC;IAED;;;OAGG;IACH,mCAEC;IAQD;;;;;;;;;OASG;IACH,aAHW,eAAe,GACb,aAAa,CAiCzB;IAgED;;;;;;OAMG;IACH;QAJ2C,OAAO;QACvB,QAAQ;mCA8BlC;IAED;;;;;;;;;;;;;;;;OAgBG;IACH;QAP2C,OAAO;QACvB,QAAQ;QACP,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;QACW,cAAc,GAA/B,MAAM;aAgChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACvB,QAAQ;QACR,aAAa,EAA7B,MAAM;aAsBhB;IAED;;;;;;;;OAQG;IACH;QAN2C,OAAO;QACvB,QAAQ;QACP,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aA2ChB;IAED;;;;;;;;;;;;OAYG;IACH;QAP2C,OAAO;QACH,IAAI;QACxB,QAAQ;QACP,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;QACW,aAAa,GAA9B,MAAM;aAyChB;IAED;;;;;;;;;;;;OAYG;IACH;QAL2C,OAAO;QACpB,OAAO;QACV,QAAQ;QACP,cAAc,GAA/B,MAAM;aAwChB;IAGL;;;OAGG;IACH,0BAFU,OAAO,CAEsB;;CANtC;8BAtdY,OAAO,+BAA+B,EAAE,eAAe;0CAJ1B,gEAAgE;iCACzE,uBAAuB"}

package/src/shade/renderer/shader/ComputeShader.js

@@ -367,6 +367,60 @@ export class ComputeShader {
 
     }
 
+    /**
+     * Like {@link dispatch}, into a compute pass the caller has open and ends, so that a run of
+     * dispatches shares one pass. A dispatch sees the writes of the dispatches before it in the
+     * same pass.
+     *
+     * @param {Object} options
+     * @param {ShadeGPUCommandContext} options.encoder the context `pass` was begun on
+     * @param {ShadeGPUComputePassEncoder} options.pass
+     * @param {Object} options.bindings
+     * @param {number} [options.group_count_x]
+     * @param {number} [options.group_count_y]
+     * @param {number} [options.group_count_z]
+     */
+    dispatchInPass({
+                       encoder,
+                       pass,
+                       bindings,
+                       group_count_x = 1,
+                       group_count_y = 1,
+                       group_count_z = 1,
+                   }) {
+
+        assert.defined(encoder, 'encoder');
+        assert.defined(pass, 'pass');
+        assert.defined(bindings, 'bindings');
+
+        assert.isNonNegativeInteger(group_count_x, 'group_count_x');
+        assert.isNonNegativeInteger(group_count_y, 'group_count_y');
+        assert.isNonNegativeInteger(group_count_z, 'group_count_z');
+
+        assert.greaterThanOrEqual(group_count_x, 1, 'must be at least 1');
+        assert.greaterThanOrEqual(group_count_y, 1, 'must be at least 1');
+        assert.greaterThanOrEqual(group_count_z, 1, 'must be at least 1');
+
+        const device = encoder.device;
+
+        if (VALIDATION_ENABLED && device !== this.#validated_device) {
+            this.#descriptor.validate_against_device(device);
+
+            this.#validated_device = device;
+        }
+
+        const resources = this.#descriptor.resources;
+
+        encoder.bindComputePipeline({
+            pass,
+            pipeline: this.#pipeline,
+            bindings: resources.generateBindings(bindings, encoder),
+            immediate: encoder.writeImmediate(resources, bindings),
+        });
+
+        pass.dispatchWorkgroups(group_count_x, group_count_y, group_count_z);
+    }
+
     /**
      * Dispatch with the workgroup counts a GPU pass wrote into `command`.
      *

package/src/shade/renderer/shader/ShaderDescriptor.d.ts

@@ -1,6 +1,3 @@
-/**
- * @typedef {import("./compiler/ShaderSwitch.js").ShaderSwitch} ShaderSwitch
- */
 export class ShaderDescriptor {
     /**
      *
@@ -24,6 +21,13 @@ export class ShaderDescriptor {
      * @return {ShaderResourceSetDescriptor}
      */
     get resources(): ShaderResourceSetDescriptor;
+    /**
+     * The chunk graph this shader links, before its resources' declarations are added at link. It may
+     * still hold choices: `body.specialize(set)` is the graph {@link variant} links for `set`.
+     *
+     * @returns {CodeChunk}
+     */
+    get body(): CodeChunk;
     /**
      *
      * @return {string|GPUFeatureName[]}
@@ -69,8 +73,10 @@ export class ShaderDescriptor {
     validate_gpu_features(device: GPUDevice): boolean;
     #private;
 }
+export type CodeChunkResourceRequirement = import("./compiler/CodeChunk.js").CodeChunkResourceRequirement;
 export type ShaderSwitch = import("./compiler/ShaderSwitch.js").ShaderSwitch;
+export type ShaderResourceDescriptor = import("./resource/ShaderResourceDescriptor.js").ShaderResourceDescriptor;
 import { ShaderResourceSetDescriptor } from "./resource/ShaderResourceSetDescriptor.js";
-import { ShaderSwitchSet } from "./compiler/ShaderSwitchSet.js";
 import { CodeChunk } from "./compiler/CodeChunk.js";
+import { ShaderSwitchSet } from "./compiler/ShaderSwitchSet.js";
 //# sourceMappingURL=ShaderDescriptor.d.ts.map

package/src/shade/renderer/shader/ShaderDescriptor.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ShaderDescriptor.js"],"names":[],"mappings":"AAKA;;GAEG;AAEH;IA+NI;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACgC,SAAS,GAA/C,2BAA2B;QACR,IAAI,EAAvB,SAAS;yBAuBnB;IApPD;;;OAGG;IACH,oBAEC;IAOD;;;OAGG;IACH,6CAEC;IAaD;;;OAGG;IACH,0CAEC;IAQD;;;OAGG;IACH,qBAQC;IAOD;;;;;OAKG;IACH,oEAMC;IASD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,gBAAgB,CA8B5B;IAED;;;OAGG;IACH,WAFY,MAAM,CAiCjB;IAED;;;OAGG;IACH,iDA6BC;IAED;;;;;OAKG;IACH,0CAHa,OAAO,CAenB;;CA+BJ;2BA/PY,OAAO,4BAA4B,EAAE,YAAY;4CAHlB,2CAA2C;gCADvD,+BAA+B;0BADrC,yBAAyB"}
+{"version":3,"file":"ShaderDescriptor.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/shader/ShaderDescriptor.js"],"names":[],"mappings":"AA2EA;IA2OI;;;;;;OAMG;IACH;QAJ4B,KAAK,GAAtB,MAAM;QACgC,SAAS,GAA/C,2BAA2B;QACR,IAAI,EAAvB,SAAS;yBAuBnB;IAhQD;;;OAGG;IACH,oBAEC;IAOD;;;OAGG;IACH,6CAEC;IAOD;;;;;OAKG;IACH,sBAEC;IAQD;;;OAGG;IACH,0CAEC;IAQD;;;OAGG;IACH,qBAQC;IAOD;;;;;OAKG;IACH,oEAMC;IASD;;;;;;;OAOG;IACH,aAHW,eAAe,GACb,gBAAgB,CA8B5B;IAED;;;OAGG;IACH,WAFY,MAAM,CAmCjB;IAED;;;OAGG;IACH,iDA6BC;IAED;;;;;OAKG;IACH,0CAHa,OAAO,CAenB;;CA+BJ;2CA7UY,OAAO,yBAAyB,EAAE,4BAA4B;2BAC9D,OAAO,4BAA4B,EAAE,YAAY;uCACjD,OAAO,wCAAwC,EAAE,wBAAwB;4CAL1C,2CAA2C;0BAF7D,yBAAyB;gCACnB,+BAA+B"}

package/src/shade/renderer/shader/ShaderDescriptor.js

@@ -4,9 +4,75 @@ import { ShaderSwitchSet } from "./compiler/ShaderSwitchSet.js";
 import { ShaderResourceSetDescriptor } from "./resource/ShaderResourceSetDescriptor.js";
 
 /**
+ * @typedef {import("./compiler/CodeChunk.js").CodeChunkResourceRequirement} CodeChunkResourceRequirement
  * @typedef {import("./compiler/ShaderSwitch.js").ShaderSwitch} ShaderSwitch
+ * @typedef {import("./resource/ShaderResourceDescriptor.js").ShaderResourceDescriptor} ShaderResourceDescriptor
  */
 
+/**
+ * A chunk's name for an error: the first thing its text declares, as a reader searching for it would type it.
+ *
+ * @param {CodeChunk} chunk
+ * @returns {string}
+ */
+function chunk_name(chunk) {
+    const match = /\b(?:fn|struct|const|alias|override|var(?:<[^>]*>)?)\s+([A-Za-z_][A-Za-z0-9_]*)/.exec(chunk.text);
+
+    return match === null ? `a chunk beginning '${chunk.text.trim().slice(0, 40)}'` : `'${match[1]}'`;
+}
+
+/**
+ * How a binding reads in WGSL terms, for an error.
+ *
+ * @param {ShaderResourceDescriptor} resource
+ * @returns {string}
+ */
+function describe_resource(resource) {
+    const member = resource.member_descriptor;
+
+    if (resource.buffer_type !== undefined) {
+        return `a ${member.type} buffer of ${resource.buffer_type.wgsl_ref}`;
+    }
+
+    if (member.sampleType !== undefined) {
+        return `a ${member.multisampled ? "multisampled " : ""}${member.viewDimension} ${member.sampleType} texture`;
+    }
+
+    if (member.format !== undefined) {
+        return `a ${member.viewDimension} ${member.format} ${member.access} storage texture`;
+    }
+
+    return `a ${member.type} sampler`;
+}
+
+/**
+ * Throw unless `resources` binds every binding the linked graph declared it reads, each as the declaration
+ * says. A shader's own resources are the one place its bindings are written down, so a chunk that reads
+ * one the shader lacks is the shader's error, named here rather than as an unresolved identifier.
+ *
+ * @param {CodeChunkResourceRequirement[]} required
+ * @param {ShaderResourceSetDescriptor} resources
+ * @param {string} label the shader's
+ */
+function check_required_resources(required, resources, label) {
+    for (let i = 0; i < required.length; i++) {
+        const { resource, chunk } = required[i];
+
+        const bound = resources.getResourceByName(resource.name);
+
+        if (bound === undefined) {
+            throw new Error(`${chunk_name(chunk)} reads '${resource.name}', which '${label}' does not bind`);
+        }
+
+        if (!resource.isSatisfiedBy(bound)) {
+            throw new Error(
+                `${chunk_name(chunk)} reads '${resource.name}' as ${describe_resource(resource)},`
+                + ` which '${label}' binds as ${describe_resource(bound)}`
+            );
+        }
+    }
+}
+
 export class ShaderDescriptor {
     /**
      * Human-readable label
@@ -40,6 +106,16 @@ export class ShaderDescriptor {
      */
     #body;
 
+    /**
+     * The chunk graph this shader links, before its resources' declarations are added at link. It may
+     * still hold choices: `body.specialize(set)` is the graph {@link variant} links for `set`.
+     *
+     * @returns {CodeChunk}
+     */
+    get body() {
+        return this.#body;
+    }
+
     /**
      *
      * @type {string|GPUFeatureName[]}
@@ -149,6 +225,8 @@ export class ShaderDescriptor {
 
         const compiled = chunk.compile();
 
+        check_required_resources(compiled.resources, this.#resources, this.#label);
+
         /**
          *
          * @type {string[]}