@woosh/meep-engine 3.21.0 → 3.22.0

package/src/shade/device/pipeline/RenderPipelineManager.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler} ShaderModuleCompiler
+ * @typedef {import("./PipelineLayoutManager.js").PipelineLayoutManager} PipelineLayoutManager
+ */
 export class RenderPipelineManager {
     /**
      *
@@ -10,7 +14,7 @@ export class RenderPipelineManager {
      *
      * @returns {PipelineLayoutManager}
      */
-    get layouts(): PipelineLayoutManager;
+    get layouts(): import("./PipelineLayoutManager.js").PipelineLayoutManager;
     /**
      *
      * @param {RenderPipelineDescriptor} descriptor
@@ -20,5 +24,7 @@ export class RenderPipelineManager {
     obtain(descriptor: RenderPipelineDescriptor, actual_color_attachments?: GPUTextureFormat[]): GPURenderPipeline;
     #private;
 }
+export type ShaderModuleCompiler = import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler;
+export type PipelineLayoutManager = import("./PipelineLayoutManager.js").PipelineLayoutManager;
 import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 //# sourceMappingURL=RenderPipelineManager.d.ts.map

package/src/shade/device/pipeline/RenderPipelineManager.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"RenderPipelineManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/RenderPipelineManager.js"],"names":[],"mappings":"AAMA;IA8BI;;;;;OAKG;IACH,8FAYC;IArCD;;;OAGG;IACH,qCAEC;IA2FD;;;;;OAKG;IACH,mBAJW,wBAAwB,6BACxB,kBAAkB,qBAgB5B;;CAEJ;yCArIwC,8DAA8D"}
+{"version":3,"file":"RenderPipelineManager.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/pipeline/RenderPipelineManager.js"],"names":[],"mappings":"AAKA;;;GAGG;AAGH;IA8BI;;;;;OAKG;IACH,wCAHW,qBAAqB,WACrB,oBAAoB,EAc9B;IArCD;;;OAGG;IACH,0EAEC;IA2FD;;;;;OAKG;IACH,mBAJW,wBAAwB,6BACxB,kBAAkB,qBAgB5B;;CAEJ;mCAtIY,OAAO,mCAAmC,EAAE,oBAAoB;oCAChE,OAAO,4BAA4B,EAAE,qBAAqB;yCAL9B,8DAA8D"}

package/src/shade/device/pipeline/RenderPipelineManager.js

@@ -3,6 +3,11 @@ import { HashMap } from "../../../core/collection/map/HashMap.js";
 import { RenderPipelineDescriptor } from "../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
 import { rp_validate_and_rewrite_for_color_attachments } from "./rp_validate_and_rewrite_for_color_attachments.js";
 
+/**
+ * @typedef {import("../shader/ShaderModuleCompiler.js").ShaderModuleCompiler} ShaderModuleCompiler
+ * @typedef {import("./PipelineLayoutManager.js").PipelineLayoutManager} PipelineLayoutManager
+ */
+
 
 export class RenderPipelineManager {
     /**

package/src/shade/device/shader/ShaderModuleCompiler.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("../../descriptor/pipeline/ShaderModuleDescriptor.js").ShaderModuleDescriptor} ShaderModuleDescriptor
+ */
 export class ShaderModuleCompiler {
     /**
      *
@@ -12,4 +15,5 @@ export class ShaderModuleCompiler {
     obtain(descriptor: ShaderModuleDescriptor): GPUShaderModule;
     #private;
 }
+export type ShaderModuleDescriptor = import("../../descriptor/pipeline/ShaderModuleDescriptor.js").ShaderModuleDescriptor;
 //# sourceMappingURL=ShaderModuleCompiler.d.ts.map

package/src/shade/device/shader/ShaderModuleCompiler.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ShaderModuleCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/shader/ShaderModuleCompiler.js"],"names":[],"mappings":"AAGA;IAaI;;;OAGG;IACH,+BAEC;IAwCD;;;;OAIG;IACH,4DAIC;;CAEJ"}
+{"version":3,"file":"ShaderModuleCompiler.d.ts","sourceRoot":"","sources":["../../../../../src/shade/device/shader/ShaderModuleCompiler.js"],"names":[],"mappings":"AAGA;;GAEG;AAEH;IAaI;;;OAGG;IACH,+BAEC;IAwCD;;;;OAIG;IACH,mBAHW,sBAAsB,mBAOhC;;CAEJ;qCAzEY,OAAO,qDAAqD,EAAE,sBAAsB"}

package/src/shade/device/shader/ShaderModuleCompiler.js

@@ -1,6 +1,10 @@
 import LineBuilder from "../../../core/codegen/LineBuilder.js";
 import { HashMap } from "../../../core/collection/map/HashMap.js";
 
+/**
+ * @typedef {import("../../descriptor/pipeline/ShaderModuleDescriptor.js").ShaderModuleDescriptor} ShaderModuleDescriptor
+ */
+
 export class ShaderModuleCompiler {
 
     /**

package/src/shade/device/timing/profile/GPUFrameRecorder.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../GPUTimerArray.js").GPUTimerArray} GPUTimerArray
+ */
 /**
  * Assembles one frame's worth of profile data, and holds the join that nothing else can supply.
  *
@@ -88,6 +92,8 @@ export class GPUFrameRecorder {
     close(cpu_submit_ms: number): GPUProfileFrame;
     #private;
 }
+export type FrameGraph = import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
+export type GPUTimerArray = import("../GPUTimerArray.js").GPUTimerArray;
 import { GPUProfileFrame } from "./GPUProfileFrame.js";
 import { GPUProfileWork } from "./GPUProfileWork.js";
 //# sourceMappingURL=GPUFrameRecorder.d.ts.map

package/src/shade/device/timing/profile/GPUFrameRecorder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUFrameRecorder.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/GPUFrameRecorder.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;GAeG;AACH;IAkFI;;;OAGG;IACH,yBAHW,MAAM,gBACN,MAAM,EAQhB;IAtDD;;;;OAIG;IACH,uBAFa,IAAI,CAIhB;IAqBD;;;;OAIG;IACH,4BAFa,IAAI,CAIhB;IAED;;OAEG;IACH,6BAEC;IAcD;;;;;OAKG;IACH,iCAFa,IAAI,CAiBhB;IAED;;;;;;;;OAQG;IACH,iBAFa,IAAI,CAShB;IAWD;;;;;;;;OAQG;IACH,6BALW,MAAM,WACN,MAAM,GACJ,cAAc,GAAC,IAAI,CAiB/B;IAED;;;;;;;;;OASG;IACH,4CAHW,MAAM,GACJ,IAAI,CAqChB;IAED;;;;;;;;;;OAUG;IACH,qBAHW,MAAM,GACJ,eAAe,CAgD3B;;CACJ;gCAvS+B,sBAAsB;+BAEvB,qBAAqB"}
+{"version":3,"file":"GPUFrameRecorder.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/GPUFrameRecorder.js"],"names":[],"mappings":"AAMA;;;GAGG;AAEH;;;;;;;;;;;;;;;GAeG;AACH;IAkFI;;;OAGG;IACH,yBAHW,MAAM,gBACN,MAAM,EAQhB;IAtDD;;;;OAIG;IACH,uBAFa,IAAI,CAIhB;IAqBD;;;;OAIG;IACH,4BAFa,IAAI,CAIhB;IAED;;OAEG;IACH,6BAEC;IAcD;;;;;OAKG;IACH,oBAHW,UAAU,GACR,IAAI,CAiBhB;IAED;;;;;;;;OAQG;IACH,iBAFa,IAAI,CAShB;IAWD;;;;;;;;OAQG;IACH,6BALW,MAAM,WACN,MAAM,GACJ,cAAc,GAAC,IAAI,CAiB/B;IAED;;;;;;;;;OASG;IACH,eAJW,aAAa,gBACb,MAAM,GACJ,IAAI,CAqChB;IAED;;;;;;;;;;OAUG;IACH,qBAHW,MAAM,GACJ,eAAe,CAgD3B;;CACJ;yBAtSY,OAAO,8DAA8D,EAAE,UAAU;4BACjF,OAAO,qBAAqB,EAAE,aAAa;gCAPxB,sBAAsB;+BAEvB,qBAAqB"}

package/src/shade/device/timing/profile/GPUFrameRecorder.js

@@ -4,6 +4,11 @@ import { GPUProfileSpan } from "./GPUProfileSpan.js";
 import { GPUProfileWork } from "./GPUProfileWork.js";
 import { frame_graph_extract_topology } from "./frame_graph_extract_topology.js";
 
+/**
+ * @typedef {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} FrameGraph
+ * @typedef {import("../GPUTimerArray.js").GPUTimerArray} GPUTimerArray
+ */
+
 /**
  * Assembles one frame's worth of profile data, and holds the join that nothing else can supply.
  *

package/src/shade/device/timing/profile/GPUProfileFrame.d.ts

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("./GPUProfileSpan.js").GPUProfileSpan} GPUProfileSpan
+ * @typedef {import("./GPUProfileTopology.js").GPUProfileTopology} GPUProfileTopology
+ */
 /**
  * One recorded frame.
  *
@@ -70,4 +74,6 @@ export class GPUProfileFrame {
      */
     get gpu_duration_ns(): number;
 }
+export type GPUProfileSpan = import("./GPUProfileSpan.js").GPUProfileSpan;
+export type GPUProfileTopology = import("./GPUProfileTopology.js").GPUProfileTopology;
 //# sourceMappingURL=GPUProfileFrame.d.ts.map

package/src/shade/device/timing/profile/GPUProfileFrame.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProfileFrame.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/GPUProfileFrame.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;;;;OAKG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEE;IAElB;;;;;;;;OAQG;IACH,aAFU,MAAM,CAEC;IAEjB;;;;;;;;OAQG;IACH,UAFU,qBAAmB,IAAI,CAEjB;IAEhB;;OAEG;IACH,OAFU,gBAAgB,CAEf;IAEX;;;;OAIG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,8BAQC;CACJ"}
+{"version":3,"file":"GPUProfileFrame.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/GPUProfileFrame.js"],"names":[],"mappings":"AAAA;;;GAGG;AAEH;;;;;GAKG;AACH;IACI;;;;;OAKG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,cAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,eAFU,MAAM,CAEE;IAElB;;;;;;;;OAQG;IACH,cAFU,MAAM,CAEE;IAElB;;;;;;;;OAQG;IACH,aAFU,MAAM,CAEC;IAEjB;;;;;;;;OAQG;IACH,UAFU,kBAAkB,GAAC,IAAI,CAEjB;IAEhB;;OAEG;IACH,OAFU,cAAc,EAAE,CAEf;IAEX;;;;OAIG;IACH,oBAFU,MAAM,CAEO;IAEvB;;;;;OAKG;IACH,8BAQC;CACJ;6BA3FY,OAAO,qBAAqB,EAAE,cAAc;iCAC5C,OAAO,yBAAyB,EAAE,kBAAkB"}

package/src/shade/device/timing/profile/GPUProfileFrame.js

@@ -1,3 +1,8 @@
+/**
+ * @typedef {import("./GPUProfileSpan.js").GPUProfileSpan} GPUProfileSpan
+ * @typedef {import("./GPUProfileTopology.js").GPUProfileTopology} GPUProfileTopology
+ */
+
 /**
  * One recorded frame.
  *

package/src/shade/device/timing/profile/GPUProfileSession.d.ts

@@ -168,6 +168,7 @@ export class GPUProfileSession {
     get done(): Promise<ArrayBuffer>;
     #private;
 }
+export type GPUProfileFrame = import("./GPUProfileFrame.js").GPUProfileFrame;
 import { GPUProfileMeta } from "./GPUProfileMeta.js";
 import { GPUFrameRecorder } from "./GPUFrameRecorder.js";
 //# sourceMappingURL=GPUProfileSession.d.ts.map

package/src/shade/device/timing/profile/GPUProfileSession.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProfileSession.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/GPUProfileSession.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAqGI;;;;;;OAMG;IACH;QAL4B,KAAK,GAAtB,MAAM;QACW,WAAW,GAA5B,MAAM;QAEW,IAAI,GAArB,MAAM;OAkBhB;IA7DD;;;;;;;OAOG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,aAFU,MAAM,CAEkB;IAElC;;;;;OAKG;IACH,6BAA8B;IAE9B;;;;;;OAMG;IACH,yBAA0B;IA2B1B;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,0BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,SAFa,IAAI,CAqBhB;IAED;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,gBACN,MAAM,GACJ,gBAAgB,GAAC,IAAI,CAkBjC;IAED;;;;;;OAMG;IACH,oBAJW,gBAAgB,iBAChB,MAAM,GACJ,IAAI,CAMhB;IAsCD;;;;;;;;;OASG;IACH,sCAFa,IAAI,CAkEhB;IAED;;;;;;;OAOG;IACH,YAFa,WAAW,CAMvB;IAED;;;;;;;;OAQG;IACH,QAFa,WAAW,CAiBvB;IAOD;;;;OAIG;IACH,iCAaC;;CACJ;+BAjd8B,qBAAqB;iCAFnB,uBAAuB"}
+{"version":3,"file":"GPUProfileSession.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/GPUProfileSession.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AACH;IAqGI;;;;;;OAMG;IACH;QAL4B,KAAK,GAAtB,MAAM;QACW,WAAW,GAA5B,MAAM;QAEW,IAAI,GAArB,MAAM;OAkBhB;IA7DD;;;;;;;OAOG;IACH,6BAEC;IAED;;;;;;OAMG;IACH,aAFU,MAAM,CAEkB;IAElC;;;;;OAKG;IACH,6BAA8B;IAE9B;;;;;;OAMG;IACH,yBAA0B;IA2B1B;;OAEG;IACH,oBAEC;IAED;;OAEG;IACH,0BAEC;IAED;;OAEG;IACH,8BAEC;IAED;;OAEG;IACH,4BAEC;IAED;;;;;OAKG;IACH,2BAEC;IAED;;;;;;OAMG;IACH,SAFa,IAAI,CAqBhB;IAED;;;;;;;;;;;OAWG;IACH,yBAJW,MAAM,gBACN,MAAM,GACJ,gBAAgB,GAAC,IAAI,CAkBjC;IAED;;;;;;OAMG;IACH,oBAJW,gBAAgB,iBAChB,MAAM,GACJ,IAAI,CAMhB;IAsCD;;;;;;;;;OASG;IACH,oBAHW,eAAe,GACb,IAAI,CAkEhB;IAED;;;;;;;OAOG;IACH,YAFa,WAAW,CAMvB;IAED;;;;;;;;OAQG;IACH,QAFa,WAAW,CAiBvB;IAOD;;;;OAIG;IACH,iCAaC;;CACJ;8BAzcY,OAAO,sBAAsB,EAAE,eAAe;+BAZ5B,qBAAqB;iCAFnB,uBAAuB"}

package/src/shade/device/timing/profile/GPUProfileSession.js

@@ -13,6 +13,10 @@ import {
     sgpt_write_topology
 } from "./sgpt_topology_codec.js";
 
+/**
+ * @typedef {import("./GPUProfileFrame.js").GPUProfileFrame} GPUProfileFrame
+ */
+
 /**
  * Default point at which an uncapped session starts saying how much it has accumulated. Does not
  * stop anything — see {@link GPUProfileSession#byte_budget}.

package/src/shade/device/timing/profile/GPUProfileSpan.d.ts

@@ -1,3 +1,6 @@
+/**
+ * @typedef {import("./GPUProfileWork.js").GPUProfileWork} GPUProfileWork
+ */
 /**
  * One GPU pass, as the device timed it.
  *
@@ -57,4 +60,5 @@ export class GPUProfileSpan {
      */
     work: GPUProfileWork | null;
 }
+export type GPUProfileWork = import("./GPUProfileWork.js").GPUProfileWork;
 //# sourceMappingURL=GPUProfileSpan.d.ts.map

package/src/shade/device/timing/profile/GPUProfileSpan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"GPUProfileSpan.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/GPUProfileSpan.js"],"names":[],"mappings":"AAAA;;;;;GAKG;AACH;IACI;;;;;;;;;OASG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,MAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;;;;;OAQG;IACH,MAFU,iBAAe,IAAI,CAEjB;CACf"}
+{"version":3,"file":"GPUProfileSpan.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/device/timing/profile/GPUProfileSpan.js"],"names":[],"mappings":"AAAA;;GAEG;AAEH;;;;;GAKG;AACH;IACI;;;;;;;;;OASG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,MAFU,MAAM,CAEC;IAEjB;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;OAIG;IACH,aAFU,MAAM,CAEA;IAEhB;;;;;OAKG;IACH,cAFU,MAAM,CAEC;IAEjB;;;;;OAKG;IACH,eAFU,MAAM,CAEG;IAEnB;;;;;;;;OAQG;IACH,MAFU,cAAc,GAAC,IAAI,CAEjB;CACf;6BAnEY,OAAO,qBAAqB,EAAE,cAAc"}

package/src/shade/device/timing/profile/GPUProfileSpan.js

@@ -1,3 +1,7 @@
+/**
+ * @typedef {import("./GPUProfileWork.js").GPUProfileWork} GPUProfileWork
+ */
+
 /**
  * One GPU pass, as the device timed it.
  *

package/src/shade/playground/add_random_meshes.d.ts

@@ -12,15 +12,26 @@
  * interval means the same thing whatever size the geometries were authored at, and a mixed list
  * does not scatter one shape at a hundred times the size of another by accident.
  *
- * @param {InstanceBatch} batch
- * @param {MeshletGeometry[]} geometries not plain `Geometry` — see {@link BoxGeometry} and
+ * @param {Object} options
+ * @param {InstanceBatch} options.batch
+ * @param {MeshletGeometry[]} options.geometries not plain `Geometry` — see {@link BoxGeometry} and
  * {@link meshlet_geometry_build_from_geometry}
- * @param {ShadeMaterial[]} [materials]
- * @param {number} [count]
- * @param {NumericInterval} [geometry_scale_range] world-space bounding-box diagonal, in scene units
- * @param {AABB3} [region] where instance origins land
- * @param {function():number} [random] pass one shared generator to keep successive calls from
+ * @param {ShadeMaterial[]} [options.materials]
+ * @param {number} [options.count]
+ * @param {NumericInterval} [options.geometry_scale_range] world-space bounding-box diagonal, in scene units
+ * @param {AABB3} [options.region] where instance origins land
+ * @param {function():number} [options.random] pass one shared generator to keep successive calls from
  * scattering the same instances in the same places
  */
-export function add_random_meshes({ batch, geometries, materials, count, geometry_scale_range, region, random }: InstanceBatch): void;
+export function add_random_meshes({ batch, geometries, materials, count, geometry_scale_range, region, random }: {
+    batch: InstanceBatch;
+    geometries: MeshletGeometry[];
+    materials?: ShadeMaterial[];
+    count?: number;
+    geometry_scale_range?: NumericInterval;
+    region?: AABB3;
+    random?: () => number;
+}): void;
+import { NumericInterval } from "../../core/math/interval/NumericInterval.js";
+import { AABB3 } from "../../core/geom/3d/aabb/AABB3.js";
 //# sourceMappingURL=add_random_meshes.d.ts.map

package/src/shade/playground/add_random_meshes.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"add_random_meshes.d.ts","sourceRoot":"","sources":["../../../../src/shade/playground/add_random_meshes.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,sIAoFC"}
+{"version":3,"file":"add_random_meshes.d.ts","sourceRoot":"","sources":["../../../../src/shade/playground/add_random_meshes.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AACH;IAVkC,KAAK;IACD,UAAU,EAArC,iBAAiB;IAES,SAAS,GAAnC,eAAe;IACE,KAAK,GAAtB,MAAM;IACoB,oBAAoB,GAA9C,eAAe;IACC,MAAM,GAAtB,KAAK;IACuB,MAAM,SAAvB,MAAM;SAuF3B;gCA/H+B,6CAA6C;sBAJvD,kCAAkC"}

package/src/shade/playground/add_random_meshes.js

@@ -35,14 +35,15 @@ const DEFAULT_REGION = new AABB3(-200, -200, -200, 200, 200, 200);
  * interval means the same thing whatever size the geometries were authored at, and a mixed list
  * does not scatter one shape at a hundred times the size of another by accident.
  *
- * @param {InstanceBatch} batch
- * @param {MeshletGeometry[]} geometries not plain `Geometry` — see {@link BoxGeometry} and
+ * @param {Object} options
+ * @param {InstanceBatch} options.batch
+ * @param {MeshletGeometry[]} options.geometries not plain `Geometry` — see {@link BoxGeometry} and
  * {@link meshlet_geometry_build_from_geometry}
- * @param {ShadeMaterial[]} [materials]
- * @param {number} [count]
- * @param {NumericInterval} [geometry_scale_range] world-space bounding-box diagonal, in scene units
- * @param {AABB3} [region] where instance origins land
- * @param {function():number} [random] pass one shared generator to keep successive calls from
+ * @param {ShadeMaterial[]} [options.materials]
+ * @param {number} [options.count]
+ * @param {NumericInterval} [options.geometry_scale_range] world-space bounding-box diagonal, in scene units
+ * @param {AABB3} [options.region] where instance origins land
+ * @param {function():number} [options.random] pass one shared generator to keep successive calls from
  * scattering the same instances in the same places
  */
 export function add_random_meshes({

package/src/shade/playground/ground_seam/capture_scene_color.d.ts

@@ -25,6 +25,10 @@ export class CaptureSceneColor extends RenderExtension {
      * @type {boolean}
      */
     enabled: boolean;
+    /**
+     * @param {FrameContext} frame
+     */
+    record(frame: FrameContext): void;
     /**
      * Luminance of the captured frame, one entry per pixel.
      *

package/src/shade/playground/ground_seam/capture_scene_color.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"capture_scene_color.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ground_seam/capture_scene_color.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;GAcG;AACH;IA2CI;;OAEG;IACH,+BAIC;IAfD;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAuEhB;;;;;;;;OAQG;IACH,kBAFa,QAAQ;QAAC,IAAI,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAwCxE;;CACJ;gCA5N+B,6CAA6C"}
+{"version":3,"file":"capture_scene_color.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/ground_seam/capture_scene_color.js"],"names":[],"mappings":"AA8CA;;;;;;;;;;;;;;GAcG;AACH;IA2CI;;OAEG;IACH,+BAIC;IAfD;;;;;OAKG;IACH,SAFU,OAAO,CAED;IAiDhB;;OAEG;IACH,kCAiBC;IAED;;;;;;;;OAQG;IACH,kBAFa,QAAQ;QAAC,IAAI,EAAE,YAAY,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,MAAM,CAAA;KAAC,CAAC,CAwCxE;;CACJ;gCA5N+B,6CAA6C"}

package/src/shade/playground/particle_ecs/index.html

@@ -293,8 +293,6 @@
         <dd id="stat-alive">—</dd>
         <dt>free</dt>
         <dd id="stat-dead">—</dd>
-        <dt>drawn</dt>
-        <dd id="stat-draw">—</dd>
         <dt>emitters</dt>
         <dd id="stat-emitters">—</dd>
     </dl>

package/src/shade/playground/particle_ecs/main.js

@@ -13,7 +13,6 @@ import { ShadedGeometrySystem } from "../../../engine/graphics3/ShadedGeometrySy
 import { OrbitalCameraController } from "../../renderer/camera/OrbitalCameraController.js";
 import { create_frame_loop } from "../../renderer/create_frame_loop.js";
 import { install_profile_hotkey } from "../profile_hotkey.js";
-import { PARTICLE_COUNTER_COUNT } from "../../renderer/particles/data/PARTICLE_COUNTERS.js";
 import { Scene } from "../../renderer/scene/Scene.js";
 import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
 import { animate_bonfire, build_bonfire_world } from "./bonfire_world.js";
@@ -52,10 +51,6 @@ const STOKE_FLAME = 400;
 /** How often the counters are copied back for the overlay. Display only — nothing sizes a pass. */
 const STATS_INTERVAL_FRAMES = 20;
 
-/** Bytes {@link capture_stats} copies: the particle counters, then the indirect draw args. */
-const STATS_BYTES = 64;
-const STATS_OFFSET_DRAW_ARGS = 48;
-
 const CAMERA = {
     position: new Vector3(2.9, 1.35, 3.7),
     target: new Vector3(0, 1.0, 0),
@@ -372,12 +367,6 @@ async function main() {
 
     // ---- frame loop -----------------------------------------------------------------------------
 
-    const stats_buffer = device.createBuffer({
-        label: "bonfire/stats",
-        size: STATS_BYTES,
-        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-    });
-
     let stats_pending = false;
     let frame_index = 0;
     let time = 0;
@@ -437,31 +426,22 @@ async function main() {
         }
     }
 
-    /** Read the counters back to display them. Submitted on its own, after the frame's own work. */
+    /**
+     * Read the counts back to display them. The system does the copying and the decoding; the page
+     * only decides how often to ask and what to put on screen.
+     */
     function capture_stats() {
         const system = renderer.particles(renderer.scenes.obtain(scene));
-        const buffers = system.buffers;
-        const encoder = device.createCommandEncoder({ label: "bonfire/stats" });
-
-        encoder.copyBufferToBuffer(buffers.counters, 0, stats_buffer, 0, PARTICLE_COUNTER_COUNT * 4);
-        encoder.copyBufferToBuffer(buffers.draw_args, 0, stats_buffer, STATS_OFFSET_DRAW_ARGS, 4 * 4);
-
-        device.queue.submit([encoder.finish()]);
 
         stats_pending = true;
 
-        stats_buffer.mapAsync(GPUMapMode.READ).then(() => {
-            const words = new Uint32Array(stats_buffer.getMappedRange().slice(0));
-
-            stats_buffer.unmap();
+        system.read_stats().then(stats => {
             stats_pending = false;
 
             globalThis.__stats = {
+                ...stats,
                 frame: frame_index,
                 fps,
-                alive: words[0],
-                dead: words[1],
-                draw: words[STATS_OFFSET_DRAW_ARGS / 4 + 1],
                 emitters: particles.emitters.length,
             };
 
@@ -509,9 +489,9 @@ async function main() {
 }
 
 /**
- * @param {{fps: number, alive: number, dead: number, draw: number, emitters: number}} stats
+ * @param {{fps: number, alive: number, dead: number, emitters: number}} stats
  */
-function write_hud({ fps, alive, dead, draw, emitters }) {
+function write_hud({ fps, alive, dead, emitters }) {
     const put = (id, value) => {
         const node = element(id);
 
@@ -523,7 +503,6 @@ function write_hud({ fps, alive, dead, draw, emitters }) {
     put("stat-fps", fps.toFixed(0));
     put("stat-alive", alive.toLocaleString());
     put("stat-dead", dead.toLocaleString());
-    put("stat-draw", draw.toLocaleString());
     put("stat-emitters", String(emitters));
 }
 

package/src/shade/playground/particle_system/main.js

@@ -7,12 +7,9 @@ import { Renderer } from "../../renderer/Renderer.js";
 import { ShadeTransparencyMode } from "../../renderer/ShadeTransparencyMode.js";
 import { load_default_environment } from "../load_default_environment.js";
 import {
-    PARTICLE_STATS_BYTES,
     animate_particle_scene,
     build_particle_scene,
     configure_particles,
-    encode_stats_copy,
-    read_stats,
 } from "./particle_scene.js";
 
 /**
@@ -205,12 +202,6 @@ async function main() {
 
     const device = renderer.graphics.device;
 
-    const stats_buffer = device.createBuffer({
-        label: "particles/stats",
-        size: PARTICLE_STATS_BYTES,
-        usage: GPUBufferUsage.COPY_DST | GPUBufferUsage.MAP_READ,
-    });
-
     let stats_pending = false;
     let frame_index = 0;
     let time = 0;
@@ -241,21 +232,17 @@ async function main() {
         }
     }
 
-    /** Read the counters back to display them. Submitted on its own, after the frame's own work. */
+    /**
+     * Read the counts back to display them. The system does the copying and the decoding; the page
+     * only decides how often to ask and what to put on screen.
+     */
     function capture_stats() {
-        const encoder = device.createCommandEncoder({ label: "particles/stats" });
-
-        encode_stats_copy(system, encoder, stats_buffer);
-        device.queue.submit([encoder.finish()]);
-
         stats_pending = true;
 
-        stats_buffer.mapAsync(GPUMapMode.READ).then(() => {
-            const bytes = stats_buffer.getMappedRange().slice(0);
-            stats_buffer.unmap();
+        system.read_stats().then(stats => {
             stats_pending = false;
 
-            globalThis.__stats = { frame: frame_index, fps, ...read_stats(bytes) };
+            globalThis.__stats = { ...stats, frame: frame_index, fps };
             write_hud(globalThis.__stats);
         }).catch(() => {
             stats_pending = false;
@@ -306,7 +293,7 @@ async function main() {
 }
 
 /** Push one stats snapshot into the overlay. Absent elements are simply skipped. */
-function write_hud({ fps, alive, dead, dispatch, sim_padded }) {
+function write_hud({ fps, alive, dead, sim_workgroups, sim_padded }) {
     const put = (id, value) => {
         const node = element(id);
         if (node !== null) {
@@ -320,7 +307,7 @@ function write_hud({ fps, alive, dead, dispatch, sim_padded }) {
     // Padding rounds each program's run up to a whole workgroup, so this is >= alive; the gap is
     // what wave-coherence costs in lanes.
     put("stat-sim-lanes", sim_padded.toLocaleString());
-    put("stat-dispatch", dispatch[0].toLocaleString());
+    put("stat-dispatch", sim_workgroups.toLocaleString());
 }
 
 function show_message(text) {

package/src/shade/playground/particle_system/particle_prototype.js

@@ -13,15 +13,15 @@ import { ParticleEmitter } from "../../renderer/particles/runtime/ParticleEmitte
 /**
  * Worked examples of authoring particle effects with the node graph + placing them in a scene for a
  * {@link GPUParticleSystem} to run. Demonstrates: distinct per-particle lifecycle (no built-in age — the
- * effect declares it), authored curves over life, flipbook frames, random emission,
+ * effect declares it), authored curves over life, flipbook frames, random emission,
  * additive vs alpha blending, projection modes, soft depth and lighting toggles.
  *
  * These are examples, not engine code, which is why they sit here rather than under
  * `renderer/particles/`: the only thing that opens them is this playground's page, and keeping them
  * on this side of the line means the dependency runs playground -> renderer and never back.
  *
- * `size_curve` / `alpha_curve` are authored curve parameters compiled into arithmetic. Both are
- * optional; omitted curves leave the initial size/colour unchanged.
+ * `size_curve` / `alpha_curve` are authored curve parameters compiled into arithmetic. Both are
+ * optional; omitted curves leave the initial size/colour unchanged.
  */
 
 /**
@@ -29,8 +29,8 @@ import { ParticleEmitter } from "../../renderer/particles/runtime/ParticleEmitte
  * follow curves over their lifetime and whose flipbook advances with age.
  *
  * @param {object} [options]
- * @param {import("../../renderer/particles/graph/particle_ramp.js").ParticleCurveParameter} [options.size_curve] size(normalizedAge)
- * @param {import("../../renderer/particles/graph/particle_ramp.js").ParticleCurveParameter} [options.alpha_curve] alpha(normalizedAge)
+ * @param {import("../../renderer/particles/graph/particle_ramp.js").ParticleCurveParameter} [options.size_curve] size(normalizedAge)
+ * @param {import("../../renderer/particles/graph/particle_ramp.js").ParticleCurveParameter} [options.alpha_curve] alpha(normalizedAge)
  * @param {number} [options.flipbook_frames]
  * @returns {{layout: ParticleLayout, effect: object, emitter: object}}
  */
@@ -109,12 +109,12 @@ export function fire_effect({ size_curve, alpha_curve, flipbook_frames = 16 } =
 
         // size + alpha from curves over life (or constants if no curve provided)
         if (size_curve !== undefined) {
-            const sc = particle_node(update, "curveLiteral", { curve: size_curve }); particle_wire(update, sc, "t", nAge);
+            const sc = particle_node(update, "curveLiteral", { curve: size_curve }); particle_wire(update, sc, "t", nAge);
             particle_wire(update, particle_node(update, "setAttribute", { name: "size" }), "value", sc);
         }
         const color = particle_node(update, "attribute", { name: "color" });
         if (alpha_curve !== undefined) {
-            const ac = particle_node(update, "curveLiteral", { curve: alpha_curve }); particle_wire(update, ac, "t", nAge);
+            const ac = particle_node(update, "curveLiteral", { curve: alpha_curve }); particle_wire(update, ac, "t", nAge);
             // color.rgb unchanged, color.a = ac : rebuild via select on a swizzle mask is overkill;
             // simplest: multiply color by (1,1,1,ac_normalized) — approximate by scaling alpha only.
             const alphaVec = particle_node(update, "mul");
@@ -155,7 +155,7 @@ export function smoke_effect() {
     const emitter = {
         ...effect,
         spawn_rate: 25,
-        flags: { blend: EMITTER_BLEND.ALPHA, projection: EMITTER_PROJECTION.BILLBOARD, soft_depth: true, lighting: true, sort: true },
+        flags: { blend: EMITTER_BLEND.ALPHA, projection: EMITTER_PROJECTION.BILLBOARD, soft_depth: true, lighting: true },
         render: { position: "position", size: "size", color: "color", frame: "frame" },
         flipbook: [1, 1],
     };

package/src/shade/playground/particle_system/particle_scene.d.ts

@@ -56,26 +56,6 @@ export function configure_particles(renderer: import("../../renderer/Renderer.js
  * @param {number} time seconds since start
  */
 export function animate_particle_scene(emitters: ReturnType<typeof create_particle_emitters>, time: number): void;
-/**
- * Copy the counters and simulate's indirect dispatch args into a {@link PARTICLE_STATS_BYTES}-byte
- * MAP_READ destination, for display. Read back to *look at*: nothing here may size a pass.
- *
- * The DRAW args are not here and cannot be: they never leave the frame graph, which allocates them
- * at the build-indirect pass and releases them after the draw. Their instance count is the alive
- * count, which the counters carry anyway.
- *
- * @param {import("../../renderer/particles/GPUParticleSystem.js").GPUParticleSystem} system
- * @param {GPUCommandEncoder} encoder
- * @param {GPUBuffer} destination
- */
-export function encode_stats_copy(system: import("../../renderer/particles/GPUParticleSystem.js").GPUParticleSystem, encoder: GPUCommandEncoder, destination: GPUBuffer): void;
-/**
- * Interpret the bytes {@link encode_stats_copy} wrote.
- *
- * @param {ArrayBuffer} bytes
- * @returns {ParticleSceneStats}
- */
-export function read_stats(bytes: ArrayBuffer): ParticleSceneStats;
 /**
  * A 64x64 radial-falloff sprite (white, alpha falloff) for soft additive and alpha blobs.
  *
@@ -108,19 +88,6 @@ export function make_sprite_texture(device: GPUDevice): GPUTexture;
  *   node that orbits, so a moving emitter is on screen,
  * - a sunlight and (from the page) the default environment, because the meshes are lit.
  */
-/** Bytes {@link encode_stats_copy} writes: 8 counters, then both indirect arg buffers. */
-export const PARTICLE_STATS_BYTES: 64;
-/**
- * @typedef {object} ParticleSceneStats
- * @property {number} alive particles alive at the end of the captured frame
- * @property {number} dead free slots left in the pool
- * @property {number} spawn_budget free slots the frame's emitters left unclaimed
- * @property {number} alive_in the snapshot next frame's simulate reads as its input length — the
- *   PADDED length of the coherence list, so it is `sim_padded` from the captured frame, not `alive`
- * @property {number} sim_padded length of the program-coherent list the coherence pass built this
- *   frame; the gap to `alive` is the lanes padding costs to keep each wave on one VM program
- * @property {number[]} dispatch simulate's indirect dispatch args, `[x, y, z]` workgroups
- */
 /**
  * What each of the four parametric emitters emits, apart from the fire, whose effect is the worked
  * example next door. Exported so the page can show what each emitter is doing.
@@ -138,34 +105,6 @@ export const PARTICLE_EMITTER_MOTION: {
         color: number[];
     };
 };
-export type ParticleSceneStats = {
-    /**
-     * particles alive at the end of the captured frame
-     */
-    alive: number;
-    /**
-     * free slots left in the pool
-     */
-    dead: number;
-    /**
-     * free slots the frame's emitters left unclaimed
-     */
-    spawn_budget: number;
-    /**
-     * the snapshot next frame's simulate reads as its input length — the
-     * PADDED length of the coherence list, so it is `sim_padded` from the captured frame, not `alive`
-     */
-    alive_in: number;
-    /**
-     * length of the program-coherent list the coherence pass built this
-     * frame; the gap to `alive` is the lanes padding costs to keep each wave on one VM program
-     */
-    sim_padded: number;
-    /**
-     * simulate's indirect dispatch args, `[x, y, z]` workgroups
-     */
-    dispatch: number[];
-};
 import { ParticleEmitter } from "../../renderer/particles/runtime/ParticleEmitter.js";
 import { Node3D } from "../../renderer/scene/Node3D.js";
 import { Scene } from "../../renderer/scene/Scene.js";

package/src/shade/playground/particle_system/particle_scene.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_scene.js"],"names":[],"mappings":"AAsFA;;;;;;;;;;;GAWG;AACH,4CAFa;IAAC,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA+DlJ;AAED;;;;;;;GAOG;AACH,wCAFa,QAAQ;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,2CAAoC,CAAC;IAAC,MAAM,EAAE;QAAC,KAAK,EAAE,IAAI,CAAC;QAAC,MAAM,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAC,CAAA;CAAC,CAAC,CAuDjJ;AAED;;;;;;;;;;GAUG;AACH,8CAJW,OAAO,4BAA4B,EAAE,QAAQ,SAC7C,KAAK,GACH,OAAO,+CAA+C,EAAE,iBAAiB,CAmBrF;AAED;;;;;;GAMG;AACH,iDAHW,2CAAoC,QACpC,MAAM,QAWhB;AAED;;;;;;;;;;;GAWG;AACH,0CAJW,OAAO,+CAA+C,EAAE,iBAAiB,4DASnF;AAED;;;;;GAKG;AACH,kCAHW,WAAW,GACT,kBAAkB,CAc9B;AAED;;;;;GAKG;AACH,mEA4BC;AA3TD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH,0FAA0F;AAC1F,sCAAuC;AAIvC;;;;;;;;;;GAUG;AAEH;;;;;GAKG;AACH;QAFiB,MAAM,GAAE;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC;EAOpJ;;;;;WArBY,MAAM;;;;UACN,MAAM;;;;kBACN,MAAM;;;;;cACN,MAAM;;;;;gBAEN,MAAM;;;;cAEN,MAAM,EAAE;;gCA/CU,qDAAqD;uBAE9D,gCAAgC;sBACjC,+BAA+B;qBAFhC,8BAA8B"}
+{"version":3,"file":"particle_scene.d.ts","sourceRoot":"","sources":["../../../../../src/shade/playground/particle_system/particle_scene.js"],"names":[],"mappings":"AAoEA;;;;;;;;;;;GAWG;AACH,4CAFa;IAAC,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,MAAM,EAAE,eAAe,CAAC;IAAC,IAAI,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,eAAe,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA+DlJ;AAED;;;;;;;GAOG;AACH,wCAFa,QAAQ;IAAC,KAAK,EAAE,KAAK,CAAC;IAAC,QAAQ,EAAE,2CAAoC,CAAC;IAAC,MAAM,EAAE;QAAC,KAAK,EAAE,IAAI,CAAC;QAAC,MAAM,EAAE,IAAI,CAAC;QAAC,KAAK,EAAE,IAAI,CAAC;QAAC,IAAI,EAAE,IAAI,CAAA;KAAC,CAAA;CAAC,CAAC,CAuDjJ;AAED;;;;;;;;;;GAUG;AACH,8CAJW,OAAO,4BAA4B,EAAE,QAAQ,SAC7C,KAAK,GACH,OAAO,+CAA+C,EAAE,iBAAiB,CAmBrF;AAED;;;;;;GAMG;AACH,iDAHW,2CAAoC,QACpC,MAAM,QAWhB;AAED;;;;;GAKG;AACH,mEA4BC;AAnQD;;;;;;;;;;;;;;;;;;;;;;;;GAwBG;AAEH;;;;;GAKG;AACH;QAFiB,MAAM,GAAE;QAAC,QAAQ,EAAE,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAC;QAAC,SAAS,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,EAAE,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,EAAE,CAAA;KAAC;EAOpJ;gCA5C8B,qDAAqD;uBAE9D,gCAAgC;sBACjC,+BAA+B;qBAFhC,8BAA8B"}