@woosh/meep-engine 3.20.0 → 3.22.0

package/src/shade/renderer/particles/ParticleConstants.js

@@ -129,15 +129,6 @@ export const PARTICLE_PROGRAM_HEADER_WORDS = 4;
  */
 export const PARTICLE_PROGRAM_CODE_BASE_WORD = 0;
 
-/**
- * Bins the render-order depth sort quantises view depth into. More bins is a finer back-to-front
- * order at the cost of a longer histogram; particles that land in one bin draw in an order the
- * scatter's atomics decide.
- *
- * @type {number}
- */
-export const PARTICLE_SORT_BUCKET_COUNT = 1024;
-
 /**
  * First word index available for user-defined attributes.
  * @type {number}
@@ -286,10 +277,12 @@ export const PARTICLE_SIM_PAD_SLOT = 0xffffffff;
  * View-space distance, in world units, over which a soft-depth particle fades out as it approaches
  * the opaque surface behind it.
  *
- * Read by the two passes that have to agree on a fragment's coverage: the AVBOIT draw, which weights
- * the accumulators by it, and the AVBOIT splat, which records the extinction the volume then hands
- * to everything behind. A fade in one and not the other is a surface that is invisible and still
- * occludes.
+ * Above all it is what the two passes that have to agree on a fragment's coverage agree on: the
+ * AVBOIT draw, which weights the accumulators by it, and the AVBOIT splat, which records the
+ * extinction the volume then hands to everything behind. A fade in one and not the other is a
+ * surface that is invisible and still occludes. The blended billboard pipeline
+ * (`shaders/shader_particle_render.js`) reads it too, so a particle fades over the same distance
+ * whichever pipeline draws it.
  *
  * @type {number}
  */

package/src/shade/renderer/particles/coherence/graph_particle_bucket.d.ts

@@ -10,10 +10,10 @@
  * ({@link PARTICLE_COUNTER.SIM_PADDED}) and turns it into next frame's dispatch args and bound.
  *
  * Six passes, the middle one being `graph_prefix_scan_csdldf` reused unchanged — the same scan the
- * radix sort runs its spine through. Reusing it is deliberate: it is the one prefix scan in this
- * codebase whose only cross-workgroup wait is CSDLDF's own bounded-spin-then-fallback, so the pass
- * makes progress on a scheduler that offers no fairness guarantee. A hand-rolled scan here would be
- * a second place to get that wrong.
+ * engine's radix sort runs its spine through. Reusing it is deliberate: it is the one prefix scan
+ * in this codebase whose only cross-workgroup wait is CSDLDF's own bounded-spin-then-fallback, so
+ * the pass makes progress on a scheduler that offers no fairness guarantee. A hand-rolled scan here
+ * would be a second place to get that wrong.
  *
  * Nothing on this path reads back to the CPU. The only host-supplied number is `bucket_count`, and
  * that is static topology — it changes when the emitter set does, never as particles are born and
@@ -21,15 +21,22 @@
  * consumed entirely on the GPU, including the dispatch size of the two per-particle passes, which
  * the reset pass writes into `sim_dispatch_args` from the GPU's own alive count.
  *
+ * ## The list is the feature's, the scratch is the graph's
+ *
+ * `sim_list` is the one thing here that crosses the frame boundary — this frame writes it, next
+ * frame's simulate reads it — so the feature owns it and hands it in. Everything else (the keys,
+ * the bins, the cursors, the dispatch args) is produced and consumed inside this call, so the pass
+ * that first writes each one declares it with a {@link BufferResourceDescriptor} in place of a
+ * handle, and the graph allocates and releases it around the passes that use it. `keys` is a word
+ * per particle: at the renderer's default capacity, 2 MiB the feature no longer reserves.
+ *
+ * None of them asks for a clear. The reset pass covers the histogram (header, padding and the bins
+ * up to the whole `vec4` the last one lands in), the cursors and all three dispatch words; `keys`
+ * is written by the same indirect dispatch that later reads it, and `bucket_counts` by the same
+ * `bucket_count` threads.
+ *
  * @param {object} params
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {object} params.gpu persistent buffers owned by the feature (GPUBuffer instances)
- * @param {GPUBuffer} params.gpu.sim_list the padded, program-coherent index list this produces
- * @param {GPUBuffer} params.gpu.sim_keys per-alive-entry program id
- * @param {GPUBuffer} params.gpu.sim_histogram `{count, elements}` bins for the CSDLDF scan
- * @param {GPUBuffer} params.gpu.sim_bucket_counts raw (unpadded) per-bucket counts
- * @param {GPUBuffer} params.gpu.sim_cursor per-bucket scatter cursor
- * @param {GPUBuffer} params.gpu.sim_dispatch_args indirect args for the two per-particle passes
  * @param {number} params.emitter_database graph handle of the emitter database buffer
  * @param {number} params.pool graph handle of the particle pool
  * @param {number} params.alive graph handle of this frame's compacted alive list
@@ -38,25 +45,19 @@
  *   imported here because the simulate pass reads it earlier in the same frame: importing the same
  *   GPUBuffer twice makes two resource entries the graph cannot see are the same memory, so the read
  *   and the write end up on separate dependency chains
+ * @param {number} params.capacity pool capacity in particles — the length of the key list
  * @param {number} params.bucket_count number of distinct compiled programs
  * @param {ParticleBucketScratch} [params.scratch] latest handles when bucketing again in this graph
  * @returns {{counters: number, sim_list: number, dispatch_args: number, scratch: ParticleBucketScratch}} the threaded handles downstream passes must read
  */
-export function graph_particle_bucket({ graph, gpu, emitter_database, pool, alive, counters, sim_list, bucket_count, scratch }: {
+export function graph_particle_bucket({ graph, emitter_database, pool, alive, counters, sim_list, capacity, bucket_count, scratch }: {
     graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-    gpu: {
-        sim_list: GPUBuffer;
-        sim_keys: GPUBuffer;
-        sim_histogram: GPUBuffer;
-        sim_bucket_counts: GPUBuffer;
-        sim_cursor: GPUBuffer;
-        sim_dispatch_args: GPUBuffer;
-    };
     emitter_database: number;
     pool: number;
     alive: number;
     counters: number;
     sim_list: number;
+    capacity: number;
     bucket_count: number;
     scratch?: ParticleBucketScratch;
 }): {

package/src/shade/renderer/particles/coherence/graph_particle_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particle_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/coherence/graph_particle_bucket.js"],"names":[],"mappings":"AAkBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IApBqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,GAAG;QACI,QAAQ;QACR,QAAQ;QACR,aAAa;QACb,iBAAiB;QACjB,UAAU;QACV,iBAAiB;;IACxB,gBAAgB,EAA/B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,QAAQ,EAAvB,MAAM;IAIS,YAAY,EAA3B,MAAM;IACyB,OAAO,GAAtC,qBAAqB;;cACR,MAAM;cAAY,MAAM;mBAAiB,MAAM;aAAW,qBAAqB;EAyGtG;oCAnJY;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC"}
+{"version":3,"file":"graph_particle_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/coherence/graph_particle_bucket.js"],"names":[],"mappings":"AAoBA;;GAEG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgDG;AACH;IAdqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,gBAAgB,EAA/B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,QAAQ,EAAvB,MAAM;IAIS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IACyB,OAAO,GAAtC,qBAAqB;IACnB;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,qBAAqB,CAAA;CAAC,CA4GvG;oCA9JY;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAA;CAAC"}

package/src/shade/renderer/particles/coherence/graph_particle_bucket.js

@@ -1,8 +1,8 @@
 import { assert } from "../../../../core/assert.js";
 import { align_4 } from "../../../../core/binary/align_4.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { graph_compute_indirect_pass } from "../../shader/graph/compute/graph_compute_indirect_pass.js";
 import { graph_compute_pass } from "../../shader/graph/compute/graph_compute_pass.js";
-import { graph_import_buffer } from "../../shader/graph/graph_import_buffer.js";
 import {
     PREFIX_SCAN_CSDLDF_HEADER_WORDS,
 } from "../../gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.js";
@@ -16,6 +16,8 @@ import {
     shader_particle_bucket_scatter,
 } from "./shader_particle_bucket.js";
 
+const WORD = Uint32Array.BYTES_PER_ELEMENT;
+
 /**
  * @typedef {{keys: number, histogram: number, cursor: number, bucket_counts: number, dispatch_args: number}} ParticleBucketScratch
  */
@@ -29,10 +31,10 @@ import {
  * ({@link PARTICLE_COUNTER.SIM_PADDED}) and turns it into next frame's dispatch args and bound.
  *
  * Six passes, the middle one being `graph_prefix_scan_csdldf` reused unchanged — the same scan the
- * radix sort runs its spine through. Reusing it is deliberate: it is the one prefix scan in this
- * codebase whose only cross-workgroup wait is CSDLDF's own bounded-spin-then-fallback, so the pass
- * makes progress on a scheduler that offers no fairness guarantee. A hand-rolled scan here would be
- * a second place to get that wrong.
+ * engine's radix sort runs its spine through. Reusing it is deliberate: it is the one prefix scan
+ * in this codebase whose only cross-workgroup wait is CSDLDF's own bounded-spin-then-fallback, so
+ * the pass makes progress on a scheduler that offers no fairness guarantee. A hand-rolled scan here
+ * would be a second place to get that wrong.
  *
  * Nothing on this path reads back to the CPU. The only host-supplied number is `bucket_count`, and
  * that is static topology — it changes when the emitter set does, never as particles are born and
@@ -40,15 +42,22 @@ import {
  * consumed entirely on the GPU, including the dispatch size of the two per-particle passes, which
  * the reset pass writes into `sim_dispatch_args` from the GPU's own alive count.
  *
+ * ## The list is the feature's, the scratch is the graph's
+ *
+ * `sim_list` is the one thing here that crosses the frame boundary — this frame writes it, next
+ * frame's simulate reads it — so the feature owns it and hands it in. Everything else (the keys,
+ * the bins, the cursors, the dispatch args) is produced and consumed inside this call, so the pass
+ * that first writes each one declares it with a {@link BufferResourceDescriptor} in place of a
+ * handle, and the graph allocates and releases it around the passes that use it. `keys` is a word
+ * per particle: at the renderer's default capacity, 2 MiB the feature no longer reserves.
+ *
+ * None of them asks for a clear. The reset pass covers the histogram (header, padding and the bins
+ * up to the whole `vec4` the last one lands in), the cursors and all three dispatch words; `keys`
+ * is written by the same indirect dispatch that later reads it, and `bucket_counts` by the same
+ * `bucket_count` threads.
+ *
  * @param {object} params
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {object} params.gpu persistent buffers owned by the feature (GPUBuffer instances)
- * @param {GPUBuffer} params.gpu.sim_list the padded, program-coherent index list this produces
- * @param {GPUBuffer} params.gpu.sim_keys per-alive-entry program id
- * @param {GPUBuffer} params.gpu.sim_histogram `{count, elements}` bins for the CSDLDF scan
- * @param {GPUBuffer} params.gpu.sim_bucket_counts raw (unpadded) per-bucket counts
- * @param {GPUBuffer} params.gpu.sim_cursor per-bucket scatter cursor
- * @param {GPUBuffer} params.gpu.sim_dispatch_args indirect args for the two per-particle passes
  * @param {number} params.emitter_database graph handle of the emitter database buffer
  * @param {number} params.pool graph handle of the particle pool
  * @param {number} params.alive graph handle of this frame's compacted alive list
@@ -57,34 +66,38 @@ import {
  *   imported here because the simulate pass reads it earlier in the same frame: importing the same
  *   GPUBuffer twice makes two resource entries the graph cannot see are the same memory, so the read
  *   and the write end up on separate dependency chains
+ * @param {number} params.capacity pool capacity in particles — the length of the key list
  * @param {number} params.bucket_count number of distinct compiled programs
  * @param {ParticleBucketScratch} [params.scratch] latest handles when bucketing again in this graph
  * @returns {{counters: number, sim_list: number, dispatch_args: number, scratch: ParticleBucketScratch}} the threaded handles downstream passes must read
  */
-export function graph_particle_bucket({ graph, gpu, emitter_database, pool, alive, counters, sim_list, bucket_count, scratch }) {
+export function graph_particle_bucket({ graph, emitter_database, pool, alive, counters, sim_list, capacity, bucket_count, scratch }) {
     assert.defined(graph, "graph");
+    assert.isPositiveInteger(capacity, "capacity");
     assert.isPositiveInteger(bucket_count, "bucket_count");
     assert.isNonNegativeInteger(sim_list, "sim_list");
 
-    // Sized from the bucket count, which only changes when the emitter set does — so a caller that
-    // added an emitter and did not reallocate gets told here rather than scattering out of bounds.
-    // Aligned up because the scan reads whole `vec4`s, so the last bin's tail is part of the buffer.
+    // Sized from the bucket count, which only changes when the emitter set does. Aligned up because
+    // the scan reads whole `vec4`s, so the last bin's tail is part of the buffer.
     const bin_words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(bucket_count);
-    assert.greaterThanOrEqual(gpu.sim_histogram.size, bin_words * Uint32Array.BYTES_PER_ELEMENT, "sim_histogram is too small for the bucket count");
-    assert.greaterThanOrEqual(gpu.sim_cursor.size, bucket_count * Uint32Array.BYTES_PER_ELEMENT, "sim_cursor is too small for the bucket count");
-    assert.greaterThanOrEqual(gpu.sim_bucket_counts.size, bucket_count * Uint32Array.BYTES_PER_ELEMENT, "sim_bucket_counts is too small for the bucket count");
 
     // Every buffer a pass WRITES must be THREADED: the write returns a renamed (versioned) handle
-    // and the next pass must read THAT one. Reading the original import instead leaves the ordering
+    // and the next pass must read THAT one. Reading the original handle instead leaves the ordering
     // between the two passes unexpressed — the graph's own validator rejects it, because both
     // versions name one piece of memory and the stale-looking read silently returns the new
     // contents.
-    // An edit frame buckets twice. Reuse the latest handles so both runs share one dependency chain.
-    let keys = scratch?.keys ?? graph_import_buffer(graph, gpu.sim_keys, "particles/sim_keys");
-    let histogram = scratch?.histogram ?? graph_import_buffer(graph, gpu.sim_histogram, "particles/sim_histogram");
-    let cursor = scratch?.cursor ?? graph_import_buffer(graph, gpu.sim_cursor, "particles/sim_cursor");
-    let bucket_counts = scratch?.bucket_counts ?? graph_import_buffer(graph, gpu.sim_bucket_counts, "particles/sim_bucket_counts");
-    let dispatch_args = scratch?.dispatch_args ?? graph_import_buffer(graph, gpu.sim_dispatch_args, "particles/sim_dispatch_args");
+    // An edit frame buckets twice. The second run is handed the first's handles, so the transients
+    // are created once and both runs share one dependency chain.
+    let keys = scratch?.keys ?? BufferResourceDescriptor.from(capacity * WORD, GPUBufferUsage.STORAGE);
+    let histogram = scratch?.histogram ?? BufferResourceDescriptor.from(bin_words * WORD, GPUBufferUsage.STORAGE);
+    let cursor = scratch?.cursor ?? BufferResourceDescriptor.from(bucket_count * WORD, GPUBufferUsage.STORAGE);
+    let bucket_counts = scratch?.bucket_counts ?? BufferResourceDescriptor.from(bucket_count * WORD, GPUBufferUsage.STORAGE);
+    // Indirect args this pass writes and the two per-particle passes below consume, along with the
+    // bounds pass — hence INDIRECT on top of STORAGE.
+    let dispatch_args = scratch?.dispatch_args ?? BufferResourceDescriptor.from(
+        3 * WORD,
+        GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+    );
 
     // 0. Clear the bins and cursors, write the scan's {count} header, and size the two per-particle
     //    passes below from the GPU's own alive count.
@@ -162,7 +175,7 @@ export function graph_particle_bucket({ graph, gpu, emitter_database, pool, aliv
     }
 
     // `dispatch_args` goes back too: it holds one workgroup per live particle, written from the
-    // GPU's own alive count, which is exactly the shape the depth sort's per-particle passes need.
+    // GPU's own alive count, which is the shape every per-particle pass after this one needs.
     return { counters, sim_list, dispatch_args, scratch: { keys, histogram: scanned, cursor, bucket_counts, dispatch_args } };
 }
 

package/src/shade/renderer/particles/coherence/particle_program_buckets.d.ts

@@ -18,7 +18,8 @@ export function particle_bucket_round_up(value: number): number;
 /**
  * Bucket sizes and start offsets, exactly as the GPU derives them: an atomic histogram, a round-up
  * of each bin to a whole workgroup, and an exclusive prefix sum of the *padded* bins (the GPU takes
- * that sum from `graph_prefix_scan_csdldf`, the same scan the radix sort runs its spine through).
+ * that sum from `graph_prefix_scan_csdldf`, the same scan the engine's radix sort runs its spine
+ * through).
  *
  * A program with no particles contributes nothing: `round_up(0)` is 0, so empty buckets neither
  * consume a workgroup nor shift the offsets of the buckets after them.

package/src/shade/renderer/particles/coherence/particle_program_buckets.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_program_buckets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/coherence/particle_program_buckets.js"],"names":[],"mappings":"AAwCA;;;;;;;;GAQG;AACH,gDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AAEH;;;;;;;;;;;GAWG;AACH,yDAJW,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ,2BAA2B,CAkBvC;AAED;;;;;;;;;;;;GAYG;AACH,oDALW,UAAU,MAAM,CAAC,YACjB,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ,MAAM,EAAE,CAapB;;;;;YA5Da,MAAM,EAAE;;;;mBACR,MAAM,EAAE;;;;aACR,MAAM,EAAE;;;;WACR,MAAM"}
+{"version":3,"file":"particle_program_buckets.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/coherence/particle_program_buckets.js"],"names":[],"mappings":"AAqCA;;;;;;;;GAQG;AACH,gDAHW,MAAM,GACJ,MAAM,CAIlB;AAED;;;;;;GAMG;AAEH;;;;;;;;;;;;GAYG;AACH,yDAJW,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ,2BAA2B,CAkBvC;AAED;;;;;;;;;;;;GAYG;AACH,oDALW,UAAU,MAAM,CAAC,YACjB,UAAU,MAAM,CAAC,iBACjB,MAAM,GACJ,MAAM,EAAE,CAapB;;;;;YA7Da,MAAM,EAAE;;;;mBACR,MAAM,EAAE;;;;aACR,MAAM,EAAE;;;;WACR,MAAM"}

package/src/shade/renderer/particles/coherence/particle_program_buckets.js

@@ -2,8 +2,7 @@ import { PARTICLE_SIMULATE_WORKGROUP_SIZE, PARTICLE_SIM_PAD_SLOT } from "../Part
 
 /**
  * CPU reference for the simulation-order bucketing — the readable statement of the answer the GPU
- * passes in {@link ./shader_particle_bucket.js} have to produce, the same role
- * {@link ../sort/particle_counting_sort.js} plays for the render-order depth sort.
+ * passes in {@link ./shader_particle_bucket.js} have to produce.
  *
  * ## What it is for
  *
@@ -22,11 +21,9 @@ import { PARTICLE_SIMULATE_WORKGROUP_SIZE, PARTICLE_SIM_PAD_SLOT } from "../Part
  *
  * ## What it is NOT
  *
- * This is the *simulation* order: camera-independent, changing only when emitters and their
- * programs change. It is a different ordering from the *render* order in `../sort/`, which is
- * back-to-front by view depth and exists so premultiplied transparency composites correctly. The
- * two must stay in separate buffers and separate passes — reordering the render list for coherence
- * breaks transparency, and depth-sorting the simulation list destroys the coherence.
+ * This is the *simulation* list, and nothing else reads it. The draws walk the alive list, which is
+ * compacted and unpadded; this one is permuted and padded with sentinels, and drawing it would draw
+ * them. The two stay in separate buffers, with separate counter slots, for that reason.
  *
  * ## Indirection only
  *
@@ -62,7 +59,8 @@ export function particle_bucket_round_up(value) {
 /**
  * Bucket sizes and start offsets, exactly as the GPU derives them: an atomic histogram, a round-up
  * of each bin to a whole workgroup, and an exclusive prefix sum of the *padded* bins (the GPU takes
- * that sum from `graph_prefix_scan_csdldf`, the same scan the radix sort runs its spine through).
+ * that sum from `graph_prefix_scan_csdldf`, the same scan the engine's radix sort runs its spine
+ * through).
  *
  * A program with no particles contributes nothing: `round_up(0)` is 0, so empty buckets neither
  * consume a workgroup nor shift the offsets of the buckets after them.

package/src/shade/renderer/particles/coherence/shader_particle_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/coherence/shader_particle_bucket.js"],"names":[],"mappings":"AA+GA;;;;;;;GAOG;AACH,2CAFU,aAAa,CAyCpB;AAcH;;;;;;;;;;GAUG;AACH,+CAFU,aAAa,CAuBpB;AAYH;;;;;;;;;;GAUG;AACH,yCAFU,aAAa,CAmBpB;AAeH;;;;;;;;GAQG;AACH,6CAFU,aAAa,CAwBpB;AAcH;;;;;;;;;;;;GAYG;AACH,0CAFU,aAAa,CAiCpB;8BA1V2B,+BAA+B"}
+{"version":3,"file":"shader_particle_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/coherence/shader_particle_bucket.js"],"names":[],"mappings":"AAgHA;;;;;;;GAOG;AACH,2CAFU,aAAa,CAyCpB;AAcH;;;;;;;;;;GAUG;AACH,+CAFU,aAAa,CAuBpB;AAYH;;;;;;;;;;GAUG;AACH,yCAFU,aAAa,CAmBpB;AAeH;;;;;;;;GAQG;AACH,6CAFU,aAAa,CAwBpB;AAcH;;;;;;;;;;;;GAYG;AACH,0CAFU,aAAa,CAiCpB;8BA3V2B,+BAA+B"}

package/src/shade/renderer/particles/coherence/shader_particle_bucket.js

@@ -35,7 +35,7 @@ import { chunk_particle_header } from "../data/particle_header.js";
  *
  * ## Shape
  *
- * The same three-phase shape the depth sort uses, with two small passes added for the padding:
+ * A counting sort in three phases, with two small passes added for the padding:
  *
  *   reset -> histogram -> pad -> graph_prefix_scan_csdldf -> scatter -> fill
  *
@@ -62,8 +62,9 @@ import { chunk_particle_header } from "../data/particle_header.js";
  * - **No CPU readback.** Only the bucket COUNT is host-known, and that is static topology (it
  *   changes when the emitter set does, not per frame). Every per-frame quantity — the alive count,
  *   the bin sizes, the padded total — is produced and consumed on the GPU.
- * - **This is not the render order.** `../sort/` produces the camera-dependent back-to-front list
- *   the billboard draw consumes. Separate buffers, separate passes, separate counter slots.
+ * - **This is not the draw list.** The draws walk the compacted, unpadded alive list; this one is
+ *   permuted and padded with sentinels, and an instance per sentinel would read a garbage record.
+ *   Separate buffers, separate passes, separate counter slots.
  *
  * @see ./particle_program_buckets.js for the CPU statement of the same answer.
  */

package/src/shade/renderer/particles/data/PARTICLE_COUNTERS.d.ts

@@ -38,14 +38,6 @@ export const PARTICLE_COUNTER: Readonly<{
      * the end of the frame is the headroom the frame had.
      */
     SPAWN_BUDGET: 2;
-    /**
-     * Length of the depth-sorted index list — the RENDER order (`../sort/`), back-to-front by view
-     * depth so premultiplied transparency composites correctly. Belongs to the camera-dependent
-     * ordering and to nothing else; the simulation order has its own slot, {@link SIM_PADDED}.
-     * Sharing one slot between the two would silently couple a camera-driven ordering to a
-     * program-driven one.
-     */
-    SORTED: 3;
     /**
      * The exact length of the index list the simulate pass consumes this frame — the padded,
      * program-coherent list the coherence pass built at the end of last frame, so this is
@@ -58,19 +50,23 @@ export const PARTICLE_COUNTER: Readonly<{
      * GPU-driven (no CPU readback can be trusted for dispatch sizing: a stale count orphans or
      * double-simulates slots).
      */
-    ALIVE_IN: 4;
+    ALIVE_IN: 3;
     /**
      * Length of the padded, program-coherent simulate input list the coherence pass (`../coherence/`)
-     * produced this frame — the SIMULATION order. Camera-independent; it changes only when the
-     * emitter/program set does. Read by the build-indirect pass, which turns it into next frame's
-     * {@link ALIVE_IN} and dispatch args.
+     * produced this frame — longer than {@link ALIVE}, because padding each program's run out to a
+     * whole workgroup adds sentinels. Read by the build-indirect pass, which turns it into next
+     * frame's {@link ALIVE_IN} and dispatch args.
      *
      * Zeroed by the reset pass: if the coherence passes are ever left out of a frame, simulate then
      * reads a length of zero and does nothing, rather than re-running last frame's stale list.
      */
-    SIM_PADDED: 5;
+    SIM_PADDED: 4;
 }>;
-/** Number of `u32` atomic slots the counters themselves occupy — the head of the buffer. */
+/**
+ * `u32` atomic slots reserved for the counters at the head of the buffer — more than
+ * {@link PARTICLE_COUNTER} names, so a counter can be added without moving the bounds section that
+ * starts right after them.
+ */
 export const PARTICLE_COUNTER_COUNT: 8;
 /**
  * First word of the per-emitter bounds accumulator, which occupies the rest of the counters buffer:

package/src/shade/renderer/particles/data/PARTICLE_COUNTERS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PARTICLE_COUNTERS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/data/PARTICLE_COUNTERS.js"],"names":[],"mappings":"AAqFA;;;;;;GAMG;AACH,+DAHW,MAAM,GACJ,MAAM,CAIlB;AAQD;;;;;;;;;;GAUG;AACH,uDAHW,MAAM,GACJ,WAAW,CAevB;AA9HD;;;;;;;GAOG;AACH;IACI,mDAAmD;;IAEnD,qCAAqC;;IAErC;;;;;OAKG;;IAEH;;;;;;OAMG;;IAEH;;;;;;;;;;;OAWG;;IAEH;;;;;;;;OAQG;;GAEJ;AAEH,4FAA4F;AAC5F,uCAAwC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAFU,MAAM,CAE2C;AAE3D;;;;;;GAMG;AACH,oCAFU,MAAM,CAEuB;AAavC,0EAA0E;AAC1E,kDAAmD;AAEnD,0EAA0E;AAC1E,mDAAoD"}
+{"version":3,"file":"PARTICLE_COUNTERS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/data/PARTICLE_COUNTERS.js"],"names":[],"mappings":"AAiFA;;;;;;GAMG;AACH,+DAHW,MAAM,GACJ,MAAM,CAIlB;AAQD;;;;;;;;;;GAUG;AACH,uDAHW,MAAM,GACJ,WAAW,CAevB;AA1HD;;;;;;;GAOG;AACH;IACI,mDAAmD;;IAEnD,qCAAqC;;IAErC;;;;;OAKG;;IAEH;;;;;;;;;;;OAWG;;IAEH;;;;;;;;OAQG;;GAEJ;AAEH;;;;GAIG;AACH,uCAAwC;AAExC;;;;;;;;;;;;;;;;;GAiBG;AACH,mCAFU,MAAM,CAE2C;AAE3D;;;;;;GAMG;AACH,oCAFU,MAAM,CAEuB;AAavC,0EAA0E;AAC1E,kDAAmD;AAEnD,0EAA0E;AAC1E,mDAAoD"}

package/src/shade/renderer/particles/data/PARTICLE_COUNTERS.js

@@ -18,14 +18,6 @@ export const PARTICLE_COUNTER = Object.freeze({
      * the end of the frame is the headroom the frame had.
      */
     SPAWN_BUDGET: 2,
-    /**
-     * Length of the depth-sorted index list — the RENDER order (`../sort/`), back-to-front by view
-     * depth so premultiplied transparency composites correctly. Belongs to the camera-dependent
-     * ordering and to nothing else; the simulation order has its own slot, {@link SIM_PADDED}.
-     * Sharing one slot between the two would silently couple a camera-driven ordering to a
-     * program-driven one.
-     */
-    SORTED: 3,
     /**
      * The exact length of the index list the simulate pass consumes this frame — the padded,
      * program-coherent list the coherence pass built at the end of last frame, so this is
@@ -38,20 +30,24 @@ export const PARTICLE_COUNTER = Object.freeze({
      * GPU-driven (no CPU readback can be trusted for dispatch sizing: a stale count orphans or
      * double-simulates slots).
      */
-    ALIVE_IN: 4,
+    ALIVE_IN: 3,
     /**
      * Length of the padded, program-coherent simulate input list the coherence pass (`../coherence/`)
-     * produced this frame — the SIMULATION order. Camera-independent; it changes only when the
-     * emitter/program set does. Read by the build-indirect pass, which turns it into next frame's
-     * {@link ALIVE_IN} and dispatch args.
+     * produced this frame — longer than {@link ALIVE}, because padding each program's run out to a
+     * whole workgroup adds sentinels. Read by the build-indirect pass, which turns it into next
+     * frame's {@link ALIVE_IN} and dispatch args.
      *
      * Zeroed by the reset pass: if the coherence passes are ever left out of a frame, simulate then
      * reads a length of zero and does nothing, rather than re-running last frame's stale list.
      */
-    SIM_PADDED: 5,
+    SIM_PADDED: 4,
 });
 
-/** Number of `u32` atomic slots the counters themselves occupy — the head of the buffer. */
+/**
+ * `u32` atomic slots reserved for the counters at the head of the buffer — more than
+ * {@link PARTICLE_COUNTER} names, so a counter can be added without moving the bounds section that
+ * starts right after them.
+ */
 export const PARTICLE_COUNTER_COUNT = 8;
 
 /**

package/src/shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.d.ts

@@ -3,16 +3,14 @@
  * @param {object} options
  * @param {boolean} [options.lighting]
  * @param {boolean} [options.soft_depth]
- * @param {boolean} [options.sort]
  * @param {boolean} [options.cull]
  * @param {number} [options.blend] see {@link EMITTER_BLEND}
  * @param {number} [options.projection] see {@link EMITTER_PROJECTION}
  * @returns {number}
  */
-export function make_emitter_flags({ lighting, soft_depth, sort, cull, blend, projection }?: {
+export function make_emitter_flags({ lighting, soft_depth, cull, blend, projection }?: {
     lighting?: boolean;
     soft_depth?: boolean;
-    sort?: boolean;
     cull?: boolean;
     blend?: number;
     projection?: number;
@@ -24,7 +22,7 @@ export function emitter_flags_projection(flags: number): number;
 /**
  * One emitter's GPU record: which compiled program it runs and where that program's code and
  * constants sit in the {@link ../runtime/ProgramArena.js} buffers, plus the instance parameters the
- * tick / emit / simulate / sort / render passes read — the scene node it hangs off, spawn rate,
+ * tick / emit / simulate / render passes read — the scene node it hangs off, spawn rate,
  * feature flags, render-attribute bindings, atlas region and flipbook grid.
  *
  * There is no transform here. An emitter is a scene node, and its world matrix is the `global` of
@@ -53,11 +51,14 @@ export const PARTICLE_EMITTER_STRUCT: WebGPUStruct;
 export const EMITTER_ATTRIBUTE_ABSENT: 4294967295;
 /**
  * Emitter flag bits. Blend mode occupies bits [4,6), projection mode bits [6,9).
+ *
+ * Bit 2 is unassigned and stays that way. The whole word is written to saved data verbatim by
+ * {@link ../../../../engine/graphics/ecs/particles/ParticleEffectSerializationAdapter.js}, so a bit
+ * a retired feature gave back cannot be handed to a new one without changing what old data means.
  */
 export const EMITTER_FLAG: Readonly<{
     LIGHTING: number;
     SOFT_DEPTH: number;
-    SORT: number;
     CULL: number;
 }>;
 /** Blend modes (stored in flag bits [4,6)). All expressed by one premultiplied blend pipeline. */

package/src/shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"PARTICLE_EMITTER_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.js"],"names":[],"mappings":"AAgIA;;;;;;;;;;GAUG;AACH;IAR6B,QAAQ,GAA1B,OAAO;IACW,UAAU,GAA5B,OAAO;IACW,IAAI,GAAtB,OAAO;IACW,IAAI,GAAtB,OAAO;IACU,KAAK,GAAtB,MAAM;IACW,UAAU,GAA3B,MAAM;IACJ,MAAM,CAWlB;AAED,6DAA6D;AAC7D,2CADY,MAAM,GAAkB,MAAM,CAGzC;AAED,kEAAkE;AAClE,gDADY,MAAM,GAAkB,MAAM,CAGzC;AA3JD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,sCAFU,YAAY,CA+DO;AAE7B,uDAAuD;AACvD,kDAAmD;AAEnD;;GAEG;AACH;;;;;GAKG;AAEH,kGAAkG;AAClG;;;;GAIG;AAKH,kEAAkE;AAClE;;;;;;GAMG;AAqCH,uEAAuE;AACvE;;;;;GAEG;6BAlK0B,mCAAmC"}
+{"version":3,"file":"PARTICLE_EMITTER_STRUCT.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.js"],"names":[],"mappings":"AAmIA;;;;;;;;;GASG;AACH;IAP6B,QAAQ,GAA1B,OAAO;IACW,UAAU,GAA5B,OAAO;IACW,IAAI,GAAtB,OAAO;IACU,KAAK,GAAtB,MAAM;IACW,UAAU,GAA3B,MAAM;IACJ,MAAM,CAUlB;AAED,6DAA6D;AAC7D,2CADY,MAAM,GAAkB,MAAM,CAGzC;AAED,kEAAkE;AAClE,gDADY,MAAM,GAAkB,MAAM,CAGzC;AA5JD;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AACH,sCAFU,YAAY,CA+DO;AAE7B,uDAAuD;AACvD,kDAAmD;AAEnD;;;;;;GAMG;AACH;;;;GAIG;AAEH,kGAAkG;AAClG;;;;GAIG;AAKH,kEAAkE;AAClE;;;;;;GAMG;AAmCH,uEAAuE;AACvE;;;;;GAEG;6BAnK0B,mCAAmC"}

package/src/shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.js

@@ -4,7 +4,7 @@ import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 /**
  * One emitter's GPU record: which compiled program it runs and where that program's code and
  * constants sit in the {@link ../runtime/ProgramArena.js} buffers, plus the instance parameters the
- * tick / emit / simulate / sort / render passes read — the scene node it hangs off, spawn rate,
+ * tick / emit / simulate / render passes read — the scene node it hangs off, spawn rate,
  * feature flags, render-attribute bindings, atlas region and flipbook grid.
  *
  * There is no transform here. An emitter is a scene node, and its world matrix is the `global` of
@@ -96,11 +96,14 @@ export const EMITTER_ATTRIBUTE_ABSENT = 0xffffffff;
 
 /**
  * Emitter flag bits. Blend mode occupies bits [4,6), projection mode bits [6,9).
+ *
+ * Bit 2 is unassigned and stays that way. The whole word is written to saved data verbatim by
+ * {@link ../../../../engine/graphics/ecs/particles/ParticleEffectSerializationAdapter.js}, so a bit
+ * a retired feature gave back cannot be handed to a new one without changing what old data means.
  */
 export const EMITTER_FLAG = Object.freeze({
     LIGHTING: 1 << 0,      // forward-shade billboards with scene lighting
     SOFT_DEPTH: 1 << 1,    // fade against scene depth
-    SORT: 1 << 2,          // depth-sort this emitter's particles for correct transparency
     CULL: 1 << 3,          // frustum + occlusion simulation culling (sleep when culled)
 });
 
@@ -131,17 +134,15 @@ const PROJECTION_MASK = 0b111 << PROJECTION_SHIFT;
  * @param {object} options
  * @param {boolean} [options.lighting]
  * @param {boolean} [options.soft_depth]
- * @param {boolean} [options.sort]
  * @param {boolean} [options.cull]
  * @param {number} [options.blend] see {@link EMITTER_BLEND}
  * @param {number} [options.projection] see {@link EMITTER_PROJECTION}
  * @returns {number}
  */
-export function make_emitter_flags({ lighting = false, soft_depth = false, sort = false, cull = false, blend = EMITTER_BLEND.ALPHA, projection = EMITTER_PROJECTION.BILLBOARD } = {}) {
+export function make_emitter_flags({ lighting = false, soft_depth = false, cull = false, blend = EMITTER_BLEND.ALPHA, projection = EMITTER_PROJECTION.BILLBOARD } = {}) {
     let flags = 0;
     if (lighting) flags |= EMITTER_FLAG.LIGHTING;
     if (soft_depth) flags |= EMITTER_FLAG.SOFT_DEPTH;
-    if (sort) flags |= EMITTER_FLAG.SORT;
     if (cull) flags |= EMITTER_FLAG.CULL;
     flags |= (blend << BLEND_SHIFT) & BLEND_MASK;
     flags |= (projection << PROJECTION_SHIFT) & PROJECTION_MASK;

package/src/shade/renderer/particles/graph/ParticleGroupBuilder.d.ts

@@ -58,10 +58,10 @@ export class ParticleGroupBuilder {
      * @param {object} [parameters] overrides on top of the type's defaults
      * @returns {{node: NodeInstance, port: Port}} the node's `out` port
      */
-    op(type: string, args?: (number | {
+    op(type: string, args?: Array<{
         node: NodeInstance;
         port: Port;
-    })[], parameters?: object): {
+    } | number>, parameters?: object): {
         node: NodeInstance;
         port: Port;
     };
@@ -76,10 +76,10 @@ export class ParticleGroupBuilder {
      * @returns {Object<string, {node: NodeInstance, port: Port}>} a reference per output port name
      */
     call(group: ParticleNodeGroup, args?: {
-        [x: string]: number | {
+        [x: string]: {
             node: NodeInstance;
             port: Port;
-        };
+        } | number;
     }): {
         [x: string]: {
             node: NodeInstance;
@@ -159,10 +159,10 @@ export class ParticleGroupBuilder {
      * @param {{node: NodeInstance, port: Port}|number} value
      * @returns {void}
      */
-    out(name: string, value: number | {
+    out(name: string, value: {
         node: NodeInstance;
         port: Port;
-    }): void;
+    } | number): void;
     /**
      * Finish the group, having checked that it is one.
      *

package/src/shade/renderer/particles/graph/ParticleGroupBuilder.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleGroupBuilder.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleGroupBuilder.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAaI;;OAEG;IACH,qBAFW,MAAM,EAoBhB;IAjCD;;;OAGG;IACH,OAFU,iBAAiB,CAErB;IAEN;;;OAGG;IACH;YAFiB,MAAM,GAAE;YAAC,IAAI,eAAe;YAAC,IAAI,OAAM;SAAC;MAEjD;IAyBR;;;;;;;;;;;OAWG;IACH,SALW,MAAM;;;uBAEN,MAAM;;;MAoBhB;IAED;;;;;;;;;OASG;IACH,YAJW,iBAAiB;;;;;;;;;;MA0B3B;IAED;;;;;OAKG;IACH,iBAHc,MAAM,KACP;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAI5C;IAED;;;;;;OAMG;IACH,WAJW;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,WACvC,MAAM,GACJ;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAU5C;IAED,qGAAqG;IACrG,KADY;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GAAc;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAGhG;IAED,qGAAqG;IACrG,KADY;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GAAc;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAGhG;IAED,qGAAqG;IACrG,KADY;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GAAc;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAGhG;IAED,qGAAqG;IACrG,KADY;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GAAc;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAGhG;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAI5C;IAED;;;;;;OAMG;IACH,UAJW,MAAM;;;QAEJ,IAAI,CAehB;IAED;;;;;;;;OAQG;IACH,SAFa,iBAAiB,CA+B7B;;CAgDJ;kCA7SiC,wBAAwB"}
+{"version":3,"file":"ParticleGroupBuilder.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleGroupBuilder.js"],"names":[],"mappings":"AAQA;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAaI;;OAEG;IACH,qBAFW,MAAM,EAoBhB;IAjCD;;;OAGG;IACH,OAFU,iBAAiB,CAErB;IAEN;;;OAGG;IACH;YAFiB,MAAM,GAAE;YAAC,IAAI,eAAe;YAAC,IAAI,OAAM;SAAC;MAEjD;IAyBR;;;;;;;;;;;OAWG;IACH,SALW,MAAM,SACN,MAAM;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,CAAC,eAC9C,MAAM,GACJ;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAmB5C;IAED;;;;;;;;;OASG;IACH,YAJW,iBAAiB;YACV,MAAM,GAAE;YAAC,IAAI,eAAe;YAAC,IAAI,OAAM;SAAC,GAAC,MAAM;;YAC7C,MAAM,GAAE;YAAC,IAAI,eAAe;YAAC,IAAI,OAAM;SAAC;MAwB3D;IAED;;;;;OAKG;IACH,iBAHc,MAAM,KACP;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAI5C;IAED;;;;;;OAMG;IACH,WAJW;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,WACvC,MAAM,GACJ;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAU5C;IAED,qGAAqG;IACrG,KADY;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GAAc;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAGhG;IAED,qGAAqG;IACrG,KADY;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GAAc;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAGhG;IAED,qGAAqG;IACrG,KADY;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GAAc;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAGhG;IAED,qGAAqG;IACrG,KADY;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GAAc;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAGhG;IAED;;;;;OAKG;IACH,YAHW,MAAM,GACJ;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,CAI5C;IAED;;;;;;OAMG;IACH,UAJW,MAAM,SACN;QAAC,IAAI,eAAe;QAAC,IAAI,OAAM;KAAC,GAAC,MAAM,GACrC,IAAI,CAehB;IAED;;;;;;;;OAQG;IACH,SAFa,iBAAiB,CA+B7B;;CAgDJ;kCA7SiC,wBAAwB"}

package/src/shade/renderer/particles/graph/ParticleNodeGroup.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleNodeGroup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeGroup.js"],"names":[],"mappings":"AAiWA;;;;;GAKG;AACH,6CAHW,YAAY,GACV,OAAO,CAInB;AAED;;;;;GAKG;AACH,iDAHW,YAAY,GACV,OAAO,CAInB;AAED;;;;;;;;;;GAUG;AACH,6EAFa,OAAO,CAKnB;AA3XD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;;;GASG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;GAEG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH;IA2EI;;;;;;;;;;;;;;;OAeG;IACH;QAT2B,IAAI,EAApB,MAAM;QACW,KAAK,GAAtB,MAAM;QACW,IAAI,GAArB,MAAM;QACW,IAAI,GAArB,MAAM;QACY,MAAM,GAAxB,OAAO;QACmF,MAAM,GAAhG,MAAM;YAAC,MAAM,MAAM,CAAC;YAAC,IAAI,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,CAAA;SAAC,CAAC;QACW,OAAO,GAAjG,MAAM;YAAC,MAAM,MAAM,CAAC;YAAC,IAAI,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,CAAA;SAAC,CAAC;QAC7E,iBAAiB,CA2B7B;IAnHD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,OAAO,CAEH;IAEd;;;;OAIG;IACH,QAFU,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,IAAI,CAAA;KAAC,CAAC,CAElF;IAEZ;;;OAGG;IACH,SAFU,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,IAAI,CAAA;KAAC,CAAC,CAEjF;IAEb;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;OAGG;IACH,QAFU,mBAAmB,CAEM;IAEnC;;;OAGG;IACH,aAFU,4BAA4B,CAEnB;IAEnB;;;OAGG;IACH,WAFU,YAAY,CAEL;IAEjB;;;OAGG;IACH,YAFU,YAAY,CAEJ;IA6ClB;;;;;;OAMG;IACH,oBAJW,MAAM,aACN,aAAa,GACX,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,IAAI,CAMnE;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;AAQD;;;;;;;GAOG;AACH;IACI;;OAEG;IACH,mBAFW,iBAAiB,EAwD3B;IAnDG;;;OAGG;IACH,gBAFU,iBAAiB,CAET;IAwBlB;;;;;;;;;;MAeC;IAED,kBAKC;IAIT;;;OAGG;IACH,yCAFU,OAAO,CAEoD;CANpE;AAQD;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,mBAHW,iBAAiB,QACjB,MAAM,EAqDhB;IAhDG;;;OAGG;IACH,gBAFU,iBAAiB,CAET;IAElB;;;;OAIG;IACH,eAFU,MAAM,CAEA;IAoBhB;;;;;;;;;;;;MASM;IAEN,kBAKC;IAIT;;;OAGG;IACH,6CAFU,OAAO,CAE4D;CAN5E;6BAxV4B,wDAAwD;0BAD3D,gDAAgD;oCAGtC,iEAAiE;8BADvE,yDAAyD;wCAE/C,8BAA8B"}
+{"version":3,"file":"ParticleNodeGroup.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeGroup.js"],"names":[],"mappings":"AAiWA;;;;;GAKG;AACH,6CAHW,YAAY,GACV,OAAO,CAInB;AAED;;;;;GAKG;AACH,iDAHW,YAAY,GACV,OAAO,CAInB;AAED;;;;;;;;;;GAUG;AACH,6EAFa,OAAO,CAKnB;AA3XD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;;;;;;;GASG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;GAEG;AACH,yCAFU,MAAM,CAE4B;AAE5C;;;GAGG;AACH;IA2EI;;;;;;;;;;;;;;;OAeG;IACH;QAT2B,IAAI,EAApB,MAAM;QACW,KAAK,GAAtB,MAAM;QACW,IAAI,GAArB,MAAM;QACW,IAAI,GAArB,MAAM;QACY,MAAM,GAAxB,OAAO;QACmF,MAAM,GAAhG,MAAM;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,CAAA;SAAC,CAAC;QACW,OAAO,GAAjG,MAAM;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,CAAA;SAAC,CAAC;QAC7E,iBAAiB,CA2B7B;IAnHD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,OAFU,MAAM,CAEL;IAEX;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,MAFU,MAAM,CAEN;IAEV;;;OAGG;IACH,QAFU,OAAO,CAEH;IAEd;;;;OAIG;IACH,QAFU,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,IAAI,CAAA;KAAC,CAAC,CAElF;IAEZ;;;OAGG;IACH,SAFU,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,IAAI,CAAA;KAAC,CAAC,CAEjF;IAEb;;;OAGG;IACH,OAFU,SAAS,CAEK;IAExB;;;OAGG;IACH,QAFU,mBAAmB,CAEM;IAEnC;;;OAGG;IACH,aAFU,4BAA4B,CAEnB;IAEnB;;;OAGG;IACH,WAFU,YAAY,CAEL;IAEjB;;;OAGG;IACH,YAFU,YAAY,CAEJ;IA6ClB;;;;;;OAMG;IACH,oBAJW,MAAM,aACN,aAAa,GACX,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,IAAI,CAMnE;IAGL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;AAQD;;;;;;;GAOG;AACH;IACI;;OAEG;IACH,mBAFW,iBAAiB,EAwD3B;IAnDG;;;OAGG;IACH,gBAFU,iBAAiB,CAET;IAwBlB;;;;;;;;;;MAeC;IAED,kBAKC;IAIT;;;OAGG;IACH,yCAFU,OAAO,CAEoD;CANpE;AAQD;;;;;;;GAOG;AACH;IACI;;;OAGG;IACH,mBAHW,iBAAiB,QACjB,MAAM,EAqDhB;IAhDG;;;OAGG;IACH,gBAFU,iBAAiB,CAET;IAElB;;;;OAIG;IACH,eAFU,MAAM,CAEA;IAoBhB;;;;;;;;;;;;MASM;IAEN,kBAKC;IAIT;;;OAGG;IACH,6CAFU,OAAO,CAE4D;CAN5E;6BAxV4B,wDAAwD;0BAD3D,gDAAgD;oCAGtC,iEAAiE;8BADvE,yDAAyD;wCAE/C,8BAA8B"}

package/src/shade/renderer/particles/graph/ParticleValueType.d.ts

@@ -58,7 +58,7 @@ export function particle_type_conversion(from: ParticleValueType, to: ParticleVa
     dropped?: string;
     zeroed?: string;
     message: string;
-};
+} | null;
 /**
  * The types a value in a particle graph can have: a float vector of one to four lanes, and the
  * types that say what such a vector *means*.

package/src/shade/renderer/particles/graph/ParticleValueType.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleValueType.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleValueType.js"],"names":[],"mappings":"AAqKA;;;;;;;;;;GAUG;AACH,mDAFa,iBAAiB,GAAC,IAAI,CAQlC;AAED;;;;;;;;;GASG;AACH,gDAJW,MAAM,GACJ,iBAAiB,CAW7B;AAED;;;;;;;GAOG;AACH,8DAFa,iBAAiB,GAAC,IAAI,CAQlC;AAED;;;;;;;;;;;;GAYG;AACH,4CAHW,SAAS,iBAAiB,GAAC,IAAI,GAAC,SAAS,CAAC,GACxC,iBAAiB,GAAC,IAAI,CAkBlC;AAKD;;;;;;;;;GASG;AACH,+CALW,iBAAiB,MACjB,iBAAiB;cACJ,MAAM;aAAW,MAAM;aAAW,MAAM;EAyB/D;AA3RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAwBI;;;;;;;OAOG;IACH,gBAPW,MAAM,QACN,MAAM,cACN,MAAM;QAEY,QAAQ,GAA1B,OAAO;QACL,iBAAiB,CAU7B;IAvCD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;OAOG;IACH,UAFU,OAAO,CAEA;IAEjB;;OAEG;IACH,yBAEC;IAqBL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;AAQD,gCAAgC;AAChC,gCADW,iBAAiB,CACyC;AAErE,gCAAgC;AAChC,iCADW,iBAAiB,CAC2C;AAEvE,gCAAgC;AAChC,iCADW,iBAAiB,CAC2C;AAEvE,gCAAgC;AAChC,iCADW,iBAAiB,CAC2C;AAEvE;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;GASG;AACH,kCAFU,iBAAiB,CAE0F;AAErH;;;GAGG;AACH,mCAFU,cAAc,iBAAiB,CAAC,CAOvC;AAEH;;;GAGG;AACH,sCAFU,cAAc,iBAAiB,CAAC,CAIvC;AAEH;;;GAGG;AACH,uCAFU,cAAc,iBAAiB,CAAC,CAKvC;yBA9JsB,oDAAoD"}
+{"version":3,"file":"ParticleValueType.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleValueType.js"],"names":[],"mappings":"AAqKA;;;;;;;;;;GAUG;AACH,mDAFa,iBAAiB,GAAC,IAAI,CAQlC;AAED;;;;;;;;;GASG;AACH,gDAJW,MAAM,GACJ,iBAAiB,CAW7B;AAED;;;;;;;GAOG;AACH,8DAFa,iBAAiB,GAAC,IAAI,CAQlC;AAED;;;;;;;;;;;;GAYG;AACH,4CAHW,SAAS,iBAAiB,GAAC,IAAI,GAAC,SAAS,CAAC,GACxC,iBAAiB,GAAC,IAAI,CAkBlC;AAKD;;;;;;;;;GASG;AACH,+CALW,iBAAiB,MACjB,iBAAiB,GACf;IAAC,OAAO,CAAC,EAAE,MAAM,CAAC;IAAC,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAC,GAAC,IAAI,CAyBrE;AA3RD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiDG;AACH;IAwBI;;;;;;;OAOG;IACH,gBAPW,MAAM,QACN,MAAM,cACN,MAAM;QAEY,QAAQ,GAA1B,OAAO;QACL,iBAAiB,CAU7B;IAvCD;;;OAGG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;OAOG;IACH,UAFU,OAAO,CAEA;IAEjB;;OAEG;IACH,yBAEC;IAqBL;;;OAGG;IACH,8BAFU,OAAO,CAE8B;CAN9C;AAQD,gCAAgC;AAChC,gCADW,iBAAiB,CACyC;AAErE,gCAAgC;AAChC,iCADW,iBAAiB,CAC2C;AAEvE,gCAAgC;AAChC,iCADW,iBAAiB,CAC2C;AAEvE,gCAAgC;AAChC,iCADW,iBAAiB,CAC2C;AAEvE;;;GAGG;AACH,wCAFU,MAAM,CAE2B;AAE3C;;;;;;;;;GASG;AACH,kCAFU,iBAAiB,CAE0F;AAErH;;;GAGG;AACH,mCAFU,cAAc,iBAAiB,CAAC,CAOvC;AAEH;;;GAGG;AACH,sCAFU,cAAc,iBAAiB,CAAC,CAIvC;AAEH;;;GAGG;AACH,uCAFU,cAAc,iBAAiB,CAAC,CAKvC;yBA9JsB,oDAAoD"}

package/src/shade/renderer/particles/graph/make_particle_group.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"make_particle_group.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/make_particle_group.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAtB6B,KAAK;IACE,KAAK,EAA9B,SAAS,MAAM,CAAC;IACD,IAAI,EAAnB,MAAM;IACU,KAAK,GAArB,MAAM;IACU,IAAI,GAApB,MAAM;IACU,IAAI,GAApB,MAAM;IACuB,MAAM;IAII,cAAc;IAES,MAAM,GAApE,OAAO,6BAA6B,EAAE,cAAc;;WAGnD,iBAAiB;YAChB,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAAC;aACxD,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC,CAAA;KAAC,CAAC;EAgE3E;kCAnI6D,wBAAwB"}
+{"version":3,"file":"make_particle_group.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/make_particle_group.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH;IAtB6B,KAAK;IACE,KAAK,EAA9B,SAAS,MAAM,CAAC;IACD,IAAI,EAAnB,MAAM;IACU,KAAK,GAArB,MAAM;IACU,IAAI,GAApB,MAAM;IACU,IAAI,GAApB,MAAM;IACuB,MAAM;IAII,cAAc;IAES,MAAM,GAApE,OAAO,6BAA6B,EAAE,cAAc;IAElD;IACZ,KAAS,EAAE,iBAAiB,CAAC;IAC7B,MAAU,EAAE,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAA;KAAC,CAAC,CAAC;IACtE,OAAW,EAAE,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,EAAE,EAAE,MAAM;YAAC,IAAI,EAAE,MAAM,CAAC;YAAC,IAAI,EAAE,MAAM,CAAA;SAAC,CAAC,CAAA;KAAC,CAAC,CAAA;CACxE,CA+DH;kCAnI6D,wBAAwB"}

package/src/shade/renderer/particles/graph/particle_graph_authoring.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_graph_authoring.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_graph_authoring.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;GAaG;AACH,sDALW,MAAM,eAEN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDALW,MAAM,QACN,MAAM;UACiB,MAAM;WAAS,MAAM;IAC1C,MAAM,CA2BlB;AA2BD;;;;;GAKG;AACH,uCAHc,MAAM,KACP,MAAM,EAAE,CAIpB"}
+{"version":3,"file":"particle_graph_authoring.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_graph_authoring.js"],"names":[],"mappings":"AAMA;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;GAaG;AACH,sDALW,MAAM,eAEN,MAAM,GACJ,MAAM,CAelB;AAED;;;;;;;;;;;;;;GAcG;AACH,yDALW,MAAM,QACN,MAAM,UACN,MAAM,GAAC,MAAM,EAAE,GAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAC,GAC3C,MAAM,CA2BlB;AA2BD;;;;;GAKG;AACH,uCAHc,MAAM,KACP,MAAM,EAAE,CAIpB"}