@woosh/meep-engine 3.57.0 → 3.58.0

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -53,7 +53,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#200@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#209@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_add_hit_irradiance.js

@@ -77,3 +77,4 @@ export const chunk_ssr_add_hit_irradiance = CodeChunkChoice.from(INDIRECT_LIGHTI
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_add_hit_irradiance_none);
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_add_hit_irradiance_none);
 chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_add_hit_irradiance_lpv);
+chunk_ssr_add_hit_irradiance.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_ssr_add_hit_irradiance_none);

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.d.ts

@@ -16,7 +16,8 @@ export const chunk_ssr_sample_radiance_brick4: CodeChunk;
 export const chunk_ssr_sample_radiance_lpv: CodeChunk;
 /**
  * What SSR's resolve falls back to where the trace found nothing on screen, by the renderer's indirect
- * lighting mode ({@link INDIRECT_LIGHTING}):
+ * lighting mode ({@link INDIRECT_LIGHTING}). The probe clipmap falls back to the environment map until
+ * it samples its own probes.
  *
  * ```wgsl
  * fn ssr_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, coord: vec2u) -> vec3f

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ssr_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,4CAFU,SAAS,CAUc;AAEjC;;;;GAIG;AACH,+CAFU,SAAS,CAUoB;AAEvC;;;GAGG;AACH,4CAFU,SAAS,CAUiB;AAEpC;;;;;;;;;GASG;AACH,wCAFU,eAAe,CAEwD;0BAxDvD,uCAAuC;gCACjC,6CAA6C"}
+{"version":3,"file":"chunk_ssr_sample_radiance.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js"],"names":[],"mappings":"AAQA;;;GAGG;AACH,4CAFU,SAAS,CAUc;AAEjC;;;;GAIG;AACH,+CAFU,SAAS,CAUoB;AAEvC;;;GAGG;AACH,4CAFU,SAAS,CAUiB;AAEpC;;;;;;;;;;GAUG;AACH,wCAFU,eAAe,CAEwD;0BAzDvD,uCAAuC;gCACjC,6CAA6C"}

package/src/shade/renderer/postprocess/ssr/resolve/chunk_ssr_sample_radiance.js

@@ -51,7 +51,8 @@ fn ssr_sample_radiance(
 
 /**
  * What SSR's resolve falls back to where the trace found nothing on screen, by the renderer's indirect
- * lighting mode ({@link INDIRECT_LIGHTING}):
+ * lighting mode ({@link INDIRECT_LIGHTING}). The probe clipmap falls back to the environment map until
+ * it samples its own probes.
  *
  * ```wgsl
  * fn ssr_sample_radiance(position_ws, normal_ws, view_direction_ws, roughness, coord: vec2u) -> vec3f
@@ -64,3 +65,4 @@ export const chunk_ssr_sample_radiance = CodeChunkChoice.from(INDIRECT_LIGHTING)
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.IBL, chunk_ssr_sample_radiance_ibl);
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.Brick4, chunk_ssr_sample_radiance_brick4);
 chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.LPV, chunk_ssr_sample_radiance_lpv);
+chunk_ssr_sample_radiance.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_ssr_sample_radiance_ibl);

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.d.ts

@@ -14,6 +14,7 @@
  * - Brick4: the light map's probes ({@link chunk_forward_sample_indirect_brick4});
  * - LPV: the environment map. The probe volume has no forward sampling; transparent surfaces under
  *   LPV are lit as under IBL.
+ * - ProbeClipmap: the environment map, until the mode samples its own probes.
  *
  * A pipeline that links this binds what every mode reads, `tEnvironment`, `brick4` and `view`, and
  * reads only its own mode's.

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_forward_sample_indirect.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,4CAFU,eAAe,CAE4D;gCA1BrD,0CAA0C"}
+{"version":3,"file":"chunk_forward_sample_indirect.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,4CAFU,eAAe,CAE4D;gCA3BrD,0CAA0C"}

package/src/shade/renderer/rasterize/forward/chunk_forward_sample_indirect.js

@@ -20,6 +20,7 @@ import { chunk_forward_sample_indirect_environment } from "./chunk_forward_sampl
  * - Brick4: the light map's probes ({@link chunk_forward_sample_indirect_brick4});
  * - LPV: the environment map. The probe volume has no forward sampling; transparent surfaces under
  *   LPV are lit as under IBL.
+ * - ProbeClipmap: the environment map, until the mode samples its own probes.
  *
  * A pipeline that links this binds what every mode reads, `tEnvironment`, `brick4` and `view`, and
  * reads only its own mode's.
@@ -31,3 +32,4 @@ export const chunk_forward_sample_indirect = CodeChunkChoice.from(INDIRECT_LIGHT
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.IBL, chunk_forward_sample_indirect_environment);
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.Brick4, chunk_forward_sample_indirect_brick4);
 chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.LPV, chunk_forward_sample_indirect_environment);
+chunk_forward_sample_indirect.add(ShadeIndirectLightingMode.ProbeClipmap, chunk_forward_sample_indirect_environment);

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

@@ -205,12 +205,26 @@ export class GPUSceneContext {
      * @param {number} dt_seconds wall-clock seconds since last call
      */
     tick(cmd_ctx: ShadeGPUCommandContext, dt_seconds: number): void;
+    /**
+     * Record this frame's mover list into `graph`: every mesh row whose box, transform, geometry or
+     * material changed since the list was last made, and every skinned mesh whose pose did, with
+     * where each is and was — see {@link graph_scene_movers}. What reads it: the virtual shadow maps'
+     * stale pass, and the probe clipmap's bricks.
+     *
+     * Call it once a frame, after {@link tick}, and hand the handle to every reader. A frame that
+     * has no reader culls the pass.
+     *
+     * @param {FrameGraph} graph
+     * @returns {number} graph handle of the mover list
+     */
+    graph_movers(graph: FrameGraph): number;
     /**
      * 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 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.
+     * its volumetrics, its wind, its sky, its volumetric light map, its animation, its skinning and
+     * the mover pass's memory of its rows: every buffer the context made. Safe to call twice, and on a
+     * context that never enabled virtual geometry.
      */
     destroy(): void;
     /**
@@ -226,6 +240,7 @@ export type GPUGeometryManager = import("../geometry/GPUGeometryManager.js").GPU
 export type GPUMaterialManager = import("../material/GPUMaterialManager.js").GPUMaterialManager;
 export type ShadeMaterial = import("../material/ShadeMaterial.js").ShadeMaterial;
 export type GPURecordWriter = import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter;
+export type FrameGraph = import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
 import { Brick4LightMap } from "../global_illumination/brick4/Brick4LightMap.js";
 import { Scene } from "./Scene.js";
 import { GPUSceneVolumetrics } from "../volumetrics/GPUSceneVolumetrics.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":"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"}
+{"version":3,"file":"GPUSceneContext.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/GPUSceneContext.js"],"names":[],"mappings":"AA2EA;;;;;;;;;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;IAUD;;;;;;;;;;;OAWG;IACH,oBAHW,UAAU,GACR,MAAM,CAQlB;IAoCD;;;;;;;OAOG;IACH,gBAuBC;IAoCL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C;8BAt0BY,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;yBACzE,OAAO,2DAA2D,EAAE,UAAU;+BA5B5D,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;6BAQ3D,wBAAwB;wCADb,mCAAmC;uCAlBpC,wCAAwC"}

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

@@ -22,6 +22,8 @@ import {
     shader_refresh_all_mesh_bounds,
     WORKGROUP_SIZE as REFRESH_ALL_MESH_BOUNDS_WORKGROUP_SIZE
 } from "../object_property/shader_refresh_all_mesh_bounds.js";
+import { graph_scene_movers } from "./movers/graph_scene_movers.js";
+import { SceneMoverTracker } from "./movers/SceneMoverTracker.js";
 import { GPUEntityBoundsReadback } from "./rows/GPUEntityBoundsReadback.js";
 import { GPUSceneRows } from "./rows/GPUSceneRows.js";
 import { generate_record_writer } from "../buffer/table/serde/generate_record_writer.js";
@@ -35,6 +37,7 @@ import { SCENE_DATABASE_SPEC } from "./SCENE_DATABASE_SPEC.js";
  * @typedef {import("../material/GPUMaterialManager.js").GPUMaterialManager} GPUMaterialManager
  * @typedef {import("../material/ShadeMaterial.js").ShadeMaterial} ShadeMaterial
  * @typedef {import("../buffer/table/serde/generate_record_writer.js").GPURecordWriter} GPURecordWriter
+ * @typedef {import("../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
  */
 
 
@@ -739,6 +742,34 @@ export class GPUSceneContext {
         this.#scene_database.readback.encode(cmd_ctx);
     }
 
+    /**
+     * What the mover pass remembers of the rows from one frame to the next. Made on the first frame
+     * anything asks for the list, and kept with the scene.
+     *
+     * @type {SceneMoverTracker|null}
+     */
+    #mover_tracker = null;
+
+    /**
+     * Record this frame's mover list into `graph`: every mesh row whose box, transform, geometry or
+     * material changed since the list was last made, and every skinned mesh whose pose did, with
+     * where each is and was — see {@link graph_scene_movers}. What reads it: the virtual shadow maps'
+     * stale pass, and the probe clipmap's bricks.
+     *
+     * Call it once a frame, after {@link tick}, and hand the handle to every reader. A frame that
+     * has no reader culls the pass.
+     *
+     * @param {FrameGraph} graph
+     * @returns {number} graph handle of the mover list
+     */
+    graph_movers(graph) {
+        if (this.#mover_tracker === null) {
+            this.#mover_tracker = new SceneMoverTracker(this.#graphics.device);
+        }
+
+        return graph_scene_movers({ graph, scene: this, tracker: this.#mover_tracker });
+    }
+
     /**
      * Recompute every mesh row's world bounds from its geometry under its composed `global`.
      * Skipped when there is no mesh row; otherwise one thread per slot of the `meshes` table's
@@ -777,8 +808,9 @@ 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 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.
+     * its volumetrics, its wind, its sky, its volumetric light map, its animation, its skinning and
+     * the mover pass's memory of its rows: every buffer the context made. Safe to call twice, and on a
+     * context that never enabled virtual geometry.
      */
     destroy() {
         this.#destroy_virtual_geometry();
@@ -799,6 +831,10 @@ export class GPUSceneContext {
         if (this.#skinning !== null) {
             this.#skinning.destroy();
         }
+        if (this.#mover_tracker !== null) {
+            this.#mover_tracker.destroy();
+            this.#mover_tracker = null;
+        }
     }
 
     /**

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

@@ -8,5 +8,22 @@
  * `transform_inverse` is computed on demand via `mat4_inverse(node.global)`.
  */
 export const MESH_INSTANCE_METADATA_STRUCT: WebGPUStruct;
+/**
+ * The row is in the SDF world: rays that trace the scene's distance field see it. Its
+ * `ShadedGeometry` carries `ShadedGeometryFlags.SDFWorld`, and its material is not
+ * `TransparencyMode.Transparent`, since glass does not stop a GI ray. A row without it is drawn and
+ * invisible to those rays: it occludes nothing, emits nothing and bounces nothing.
+ *
+ * @type {number}
+ */
+export const MESH_FLAG_SDF_WORLD: number;
+/**
+ * The row draws a per-instance clone that the skinning pass deforms, rather than its source
+ * geometry. Its box follows the pose every frame, so a box that changed with nothing else may have
+ * been moved by the animation alone.
+ *
+ * @type {number}
+ */
+export const MESH_FLAG_SKINNED: number;
 import { WebGPUStruct } from "../shader/type/WebGPUStruct.js";
 //# sourceMappingURL=MESH_INSTANCE_METADATA_STRUCT.d.ts.map

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,yDAe0B;6BA1BG,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,yDAuB0B;AAE1B;;;;;;;GAOG;AACH,kCAFU,MAAM,CAEqB;AAErC;;;;;;GAMG;AACH,gCAFU,MAAM,CAEmB;6BArDN,gCAAgC"}

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

@@ -19,6 +19,14 @@ export const MESH_INSTANCE_METADATA_STRUCT = WebGPUStruct.from({
      * scene-graph node, holding `local`, `global`, and `parent`.
      */
     node: u32,
+    /**
+     * Facts about the row that its readers on the GPU branch on: {@link MESH_FLAG_SDF_WORLD},
+     * {@link MESH_FLAG_SKINNED}. Written with the rest of the record whenever the row is.
+     *
+     * Free: the packed record is 80 bytes with the tail padding this word now occupies, and is 80
+     * bytes with it.
+     */
+    flags: u32,
     bounding_box: WebGPUArray.from(f32, 6),
     bounding_sphere: vec4f,
     /**
@@ -27,3 +35,22 @@ export const MESH_INSTANCE_METADATA_STRUCT = WebGPUStruct.from({
      */
     lightmap_uvs: vec4f,
 }, "MeshMetadata").pack();
+
+/**
+ * The row is in the SDF world: rays that trace the scene's distance field see it. Its
+ * `ShadedGeometry` carries `ShadedGeometryFlags.SDFWorld`, and its material is not
+ * `TransparencyMode.Transparent`, since glass does not stop a GI ray. A row without it is drawn and
+ * invisible to those rays: it occludes nothing, emits nothing and bounces nothing.
+ *
+ * @type {number}
+ */
+export const MESH_FLAG_SDF_WORLD = 1;
+
+/**
+ * The row draws a per-instance clone that the skinning pass deforms, rather than its source
+ * geometry. Its box follows the pose every frame, so a box that changed with nothing else may have
+ * been moved by the animation alone.
+ *
+ * @type {number}
+ */
+export const MESH_FLAG_SKINNED = 2;

package/src/shade/renderer/scene/bvh/StaticSceneBVH.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"StaticSceneBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/bvh/StaticSceneBVH.js"],"names":[],"mappings":"AA6EA;IAEI,kBAAyB;IAEzB;;;OAGG;IACH,cAFU,cAAc,eAAe,CAAC,CAEf;IAEzB,gCAA6B;IAE7B;;;OAGG;IACH;;;;OAIG;IACH,gBAFU,IAAI,MAAM,EAAE,mBAAmB,CAAC,CAEf;IAG3B;;;;;;OAMG;IACH,qBAFW,eAAe,QA4EzB;IAED;;;;;;;OAOG;IACH,qCANW,aAAa,KACb,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAqJnB;IAED;;;;;;;;;OASG;IACH,mCARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmEnB;IAGD;;;;;OAKG;IACH,qBAJW,aAAa,OACb,IAAI,GACF,OAAO,CA2GnB;IAED;;;;;OAKG;IACH,iBAJW;QAAC,GAAG,EAAE,aAAa,CAAC;QAAC,IAAI,OAAM;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,EAAE,OACnD,IAAI,GACH,MAAM,CAmEjB;CAGJ;8BA/hBY,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;;;;;kCAOvD;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAC;oBA7DhG,mCAAmC;gCARV,mDAAmD;8BA0BrD,2CAA2C;qBADpD,sCAAsC"}
+{"version":3,"file":"StaticSceneBVH.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/bvh/StaticSceneBVH.js"],"names":[],"mappings":"AA2EA;IAEI,kBAAyB;IAEzB;;;OAGG;IACH,cAFU,cAAc,eAAe,CAAC,CAEf;IAEzB,gCAA6B;IAE7B;;;OAGG;IACH;;;;OAIG;IACH,gBAFU,IAAI,MAAM,EAAE,mBAAmB,CAAC,CAEf;IAG3B;;;;;;OAMG;IACH,qBAFW,eAAe,QA4EzB;IAED;;;;;;;OAOG;IACH,qCANW,aAAa,KACb,MAAM,KACN,MAAM,KACN,MAAM,GACJ,OAAO,CAqJnB;IAED;;;;;;;;;OASG;IACH,mCARW,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,MACN,MAAM,GACJ,OAAO,CAmEnB;IAGD;;;;;OAKG;IACH,qBAJW,aAAa,OACb,IAAI,GACF,OAAO,CA2GnB;IAED;;;;;OAKG;IACH,iBAJW;QAAC,GAAG,EAAE,aAAa,CAAC;QAAC,IAAI,OAAM;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC,EAAE,OACnD,IAAI,GACH,MAAM,CAmEjB;CAGJ;8BA/hBY,OAAO,uBAAuB,EAAE,eAAe;8BAC/C,OAAO,mCAAmC,EAAE,eAAe;4BAC3D,OAAO,iCAAiC,EAAE,aAAa;;;;;kCAOvD;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,eAAe,CAAC;IAAC,QAAQ,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,YAAY,CAAA;CAAC;oBA3DhG,mCAAmC;gCARV,mDAAmD;8BAwBrD,2CAA2C;qBADpD,sCAAsC"}

package/src/shade/renderer/scene/bvh/StaticSceneBVH.js

@@ -21,10 +21,8 @@ import {
 import {
     aabb3_unsigned_distance_sqr_to_point
 } from "../../../../core/geom/3d/aabb/aabb3_unsigned_distance_sqr_to_point.js";
-import {
-    clipping_volume_matrix4_project
-} from "../../../../core/geom/3d/frustum/clipping_volume_matrix4_project.js";
-import { hexahedron_from_aabb } from "../../../../core/geom/3d/frustum/hexahedron_from_aabb.js";
+import { frustum3_matrix4_project_n } from "../../../../core/geom/3d/frustum/frustum3_matrix4_project_n.js";
+import { frustum3_from_aabb } from "../../../../core/geom/3d/frustum/frustum3_from_aabb.js";
 import { m4_invert } from "../../../../core/geom/3d/mat4/m4_invert.js";
 import { Ray3 } from "../../../../core/geom/3d/ray/Ray3.js";
 import { SurfacePoint3 } from "../../../../core/geom/3d/SurfacePoint3.js";
@@ -376,7 +374,7 @@ export class StaticSceneBVH {
             const geometry_bvh = this.geometry_bvh.get(mesh.geometry);
 
             // Transform aabb into a clipping volume
-            hexahedron_from_aabb(
+            frustum3_from_aabb(
                 scratch_clipping_volume,
                 0,
                 x0, y0, z0,
@@ -387,7 +385,7 @@ export class StaticSceneBVH {
             m4_invert(scratch_transform_inverse, mesh.matrix);
 
             // Transform clipping volume to object space
-            clipping_volume_matrix4_project(
+            frustum3_matrix4_project_n(
                 scratch_clipping_volume, 0,
                 scratch_clipping_volume, 0,
                 6,

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

@@ -0,0 +1,9 @@
+/**
+ * Readers for {@link MESH_INSTANCE_METADATA_STRUCT}'s `flags`. Every consumer of the encoding goes
+ * through here rather than masking the word itself.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_flags: CodeChunk;
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_mesh_flags.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_mesh_flags.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/scene/chunk_mesh_flags.js"],"names":[],"mappings":"AAGA;;;;;GAKG;AACH,+BAFU,SAAS,CAcb;0BArBoB,iCAAiC"}

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

@@ -0,0 +1,22 @@
+import { CodeChunk } from "../shader/compiler/CodeChunk.js";
+import { MESH_FLAG_SKINNED, MESH_INSTANCE_METADATA_STRUCT } from "./MESH_INSTANCE_METADATA_STRUCT.js";
+
+/**
+ * Readers for {@link MESH_INSTANCE_METADATA_STRUCT}'s `flags`. Every consumer of the encoding goes
+ * through here rather than masking the word itself.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_mesh_flags = CodeChunk.from(
+    //language=WGSL
+    `
+/**
+ * Whether the row draws a per-instance clone that the skinning pass deforms, so that its box follows
+ * its pose.
+ */
+fn mesh_is_skinned( mesh: ${MESH_INSTANCE_METADATA_STRUCT.wgsl_ref} ) -> bool{
+    return ( mesh.flags & ${MESH_FLAG_SKINNED}u ) != 0u;
+}
+`, [
+        MESH_INSTANCE_METADATA_STRUCT.declaration_chunk,
+    ])

package/src/shade/renderer/scene/movers/SCENE_MOVER_LAYOUT.d.ts

@@ -0,0 +1,65 @@
+/**
+ * Movers a frame lists at most: mesh rows whose bounds, transform, geometry or material changed since
+ * the last frame, and skinned meshes whose pose did, each with the world box it covers now and covered
+ * then. Past this many the list has overflowed, and a reader takes everything it holds to be stale
+ * for the frame; the overflow is counted.
+ *
+ * @type {number}
+ */
+export const SCENE_MOVER_CAPACITY: number;
+/**
+ * What a mover's first box corner holds in `w` when only animation moved it: a skinned row whose pose
+ * changed its box while its transform, geometry and material stayed as they were. Its `w` is 0
+ * otherwise. Every reader that draws what it sees takes such a box as any other — a shadow follows
+ * the pose — and one that holds the bind pose, which the pose does not move, may skip it.
+ *
+ * @type {number}
+ */
+export const SCENE_MOVER_POSE_ONLY: number;
+/**
+ * The scene's mover list, written by the mover passes and read by whatever the frame has that cares.
+ *
+ * `count` is the atomic the movers appended with, so a count past {@link SCENE_MOVER_CAPACITY} says the
+ * list overflowed. `boxes` holds two vec4s per mover: the world box's min and max corners in `xyz`,
+ * and {@link SCENE_MOVER_POSE_ONLY} or 0 in the min corner's `w`.
+ *
+ * @type {WebGPUStruct}
+ */
+export const SCENE_MOVERS_STRUCT: WebGPUStruct;
+/**
+ * The same buffer as a reader takes it: the count as a plain word.
+ *
+ * @type {WebGPUStruct}
+ */
+export const SCENE_MOVERS_READ_STRUCT: WebGPUStruct;
+/**
+ * Bytes of the mover list at {@link SCENE_MOVER_CAPACITY}.
+ *
+ * @type {number}
+ */
+export const SCENE_MOVERS_BYTE_SIZE: number;
+/**
+ * What a world box holds when it holds nothing: min past max on every axis, so that `min` and `max`
+ * against it return the other box unchanged. The largest finite f32, since WGSL will not fold an
+ * infinity.
+ *
+ * @type {number}
+ */
+export const SCENE_MOVER_EMPTY_BOUND: number;
+/**
+ * Words the mover pass remembers a `meshes` row by, from one frame to the next: the world box it saw
+ * the row with — six f32s, by their bits, empty for a row that held nothing — then the row's
+ * geometry and material, {@link GPU_DATABASE_NULL} for a row that held nothing.
+ *
+ * @type {number}
+ */
+export const SCENE_LAST_SEEN_WORDS: number;
+/**
+ * Where a row's geometry and material sit among its {@link SCENE_LAST_SEEN_WORDS}.
+ *
+ * @type {number}
+ */
+export const SCENE_LAST_SEEN_GEOMETRY: number;
+export const SCENE_LAST_SEEN_MATERIAL: 7;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+//# sourceMappingURL=SCENE_MOVER_LAYOUT.d.ts.map

package/src/shade/renderer/scene/movers/SCENE_MOVER_LAYOUT.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SCENE_MOVER_LAYOUT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/movers/SCENE_MOVER_LAYOUT.js"],"names":[],"mappings":"AAKA;;;;;;;GAOG;AACH,mCAFU,MAAM,CAEyB;AAEzC;;;;;;;GAOG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;;;;;GAQG;AACH,kCAFU,YAAY,CAQJ;AAElB;;;;GAIG;AACH,uCAFU,YAAY,CAQA;AAEtB;;;;GAIG;AACH,qCAFU,MAAM,CAEyD;AAEzE;;;;;;GAMG;AACH,sCAFU,MAAM,CAEmC;AAEnD;;;;;;GAMG;AACH,oCAFU,MAAM,CAEuB;AAEvC;;;;GAIG;AACH,uCAFU,MAAM,CAE0B;AAC1C,yCAA0C;6BAnFb,mCAAmC"}

package/src/shade/renderer/scene/movers/SCENE_MOVER_LAYOUT.js

@@ -0,0 +1,87 @@
+import { FLOAT32_MAX } from "../../../../core/binary/FLOAT32_MAX.js";
+import { atomic_u32, u32, vec4f } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
+
+/**
+ * Movers a frame lists at most: mesh rows whose bounds, transform, geometry or material changed since
+ * the last frame, and skinned meshes whose pose did, each with the world box it covers now and covered
+ * then. Past this many the list has overflowed, and a reader takes everything it holds to be stale
+ * for the frame; the overflow is counted.
+ *
+ * @type {number}
+ */
+export const SCENE_MOVER_CAPACITY = 4096;
+
+/**
+ * What a mover's first box corner holds in `w` when only animation moved it: a skinned row whose pose
+ * changed its box while its transform, geometry and material stayed as they were. Its `w` is 0
+ * otherwise. Every reader that draws what it sees takes such a box as any other — a shadow follows
+ * the pose — and one that holds the bind pose, which the pose does not move, may skip it.
+ *
+ * @type {number}
+ */
+export const SCENE_MOVER_POSE_ONLY = 1;
+
+/**
+ * The scene's mover list, written by the mover passes and read by whatever the frame has that cares.
+ *
+ * `count` is the atomic the movers appended with, so a count past {@link SCENE_MOVER_CAPACITY} says the
+ * list overflowed. `boxes` holds two vec4s per mover: the world box's min and max corners in `xyz`,
+ * and {@link SCENE_MOVER_POSE_ONLY} or 0 in the min corner's `w`.
+ *
+ * @type {WebGPUStruct}
+ */
+export const SCENE_MOVERS_STRUCT = WebGPUStruct.from({
+    count: atomic_u32,
+    pad_0: u32,
+    pad_1: u32,
+    pad_2: u32,
+    boxes: WebGPUArray.from(vec4f),
+}, "SceneMovers");
+
+/**
+ * The same buffer as a reader takes it: the count as a plain word.
+ *
+ * @type {WebGPUStruct}
+ */
+export const SCENE_MOVERS_READ_STRUCT = WebGPUStruct.from({
+    count: u32,
+    pad_0: u32,
+    pad_1: u32,
+    pad_2: u32,
+    boxes: WebGPUArray.from(vec4f),
+}, "SceneMoversRead");
+
+/**
+ * Bytes of the mover list at {@link SCENE_MOVER_CAPACITY}.
+ *
+ * @type {number}
+ */
+export const SCENE_MOVERS_BYTE_SIZE = 16 + SCENE_MOVER_CAPACITY * 2 * 16;
+
+/**
+ * What a world box holds when it holds nothing: min past max on every axis, so that `min` and `max`
+ * against it return the other box unchanged. The largest finite f32, since WGSL will not fold an
+ * infinity.
+ *
+ * @type {number}
+ */
+export const SCENE_MOVER_EMPTY_BOUND = FLOAT32_MAX;
+
+/**
+ * Words the mover pass remembers a `meshes` row by, from one frame to the next: the world box it saw
+ * the row with — six f32s, by their bits, empty for a row that held nothing — then the row's
+ * geometry and material, {@link GPU_DATABASE_NULL} for a row that held nothing.
+ *
+ * @type {number}
+ */
+export const SCENE_LAST_SEEN_WORDS = 8;
+
+/**
+ * Where a row's geometry and material sit among its {@link SCENE_LAST_SEEN_WORDS}.
+ *
+ * @type {number}
+ */
+export const SCENE_LAST_SEEN_GEOMETRY = 6;
+export const SCENE_LAST_SEEN_MATERIAL = 7;

package/src/shade/renderer/scene/movers/SceneMoverTracker.d.ts

@@ -0,0 +1,42 @@
+/**
+ * The scene's memory of where its mesh rows were and what they drew: {@link SCENE_LAST_SEEN_WORDS} per
+ * row of the `meshes` table — the world box {@link shader_scene_movers} saw each row with last frame,
+ * and its geometry and material — empty for a row that held nothing. Comparing against it is how the
+ * mover pass sees a row appear, leave, change shape or change mesh, which no per-row fact of the
+ * scene database says.
+ *
+ * Covers every row the table has ever had — a high-water mark, so a page of rows that was freed
+ * still gets compared once more and what its rows held is listed. Grows by doubling; a grown
+ * buffer starts empty and takes the old one's rows by a copy recorded in the next mover pass, in
+ * order with the rest of the frame.
+ */
+export class SceneMoverTracker {
+    /**
+     * @param {GPUDevice} device
+     */
+    constructor(device: GPUDevice);
+    /**
+     * @returns {GPUBuffer|null}
+     */
+    get buffer(): any;
+    /**
+     * @returns {number} rows the buffer covers
+     */
+    get row_count(): number;
+    /**
+     * Cover at least `rows` rows.
+     *
+     * @param {number} rows
+     */
+    ensure(rows: number): void;
+    /**
+     * Record the copy of the rows the buffer had before it grew, if it did since the last call, and
+     * let the old buffer go once the frame is done with it.
+     *
+     * @param {ShadeGPUCommandContext} encoder
+     */
+    encode_growth(encoder: ShadeGPUCommandContext): void;
+    destroy(): void;
+    #private;
+}
+//# sourceMappingURL=SceneMoverTracker.d.ts.map

package/src/shade/renderer/scene/movers/SceneMoverTracker.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"SceneMoverTracker.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/scene/movers/SceneMoverTracker.js"],"names":[],"mappings":"AASA;;;;;;;;;;;GAWG;AACH;IAwBI;;OAEG;IACH,+BAIC;IAED;;OAEG;IACH,kBAEC;IAED;;OAEG;IACH,wBAEC;IAED;;;;OAIG;IACH,aAFW,MAAM,QA+ChB;IAED;;;;;OAKG;IACH,qDAWC;IAED,gBAYC;;CACJ"}