@woosh/meep-engine 3.19.0 → 3.21.0

package/src/shade/renderer/particles/optimizer/particle_program_fuzz.js

@@ -41,7 +41,7 @@ const FUZZ_OPS = [
     VM_OP.SMOOTHSTEP, VM_OP.RSQRT, VM_OP.TAN, VM_OP.ASIN, VM_OP.ACOS, VM_OP.ATAN2,
     VM_OP.DOT, VM_OP.CROSS, VM_OP.LENGTH, VM_OP.NORMALIZE, VM_OP.DISTANCE,
     VM_OP.CMP_LT, VM_OP.CMP_LE, VM_OP.CMP_GT, VM_OP.CMP_GE, VM_OP.CMP_EQ,
-    VM_OP.SELECT, VM_OP.RANDOM, VM_OP.CURVE, VM_OP.LOAD_CONST, VM_OP.LOAD_ATTR, VM_OP.LOAD_BUILTIN,
+    VM_OP.SELECT, VM_OP.RANDOM, VM_OP.LOAD_CONST, VM_OP.LOAD_ATTR, VM_OP.LOAD_BUILTIN,
     VM_OP.NOP,
 ];
 
@@ -222,13 +222,6 @@ function emit_random_instruction(stream, assembler, rand, pool) {
             return;
         }
 
-        case VM_OP.CURVE: {
-            const handle = Math.floor(rand() * 4);
-
-            stream.curve(dst, handle, source(group), width);
-            return;
-        }
-
         default: {
             // A `SELECT` whose condition is a constant is the shape the folding pass exists for, and
             // random registers hold one about never — so it is worth steering into deliberately.

package/src/shade/renderer/particles/optimizer/particle_vm_semantics.d.ts

@@ -13,7 +13,7 @@ export function vm_semantics_of(op: number): ParticleOpSemantics;
  * it — whether it can be deleted when its result is unread, narrowed when its high lanes are dead,
  * evaluated at compile time, or recognised as a recomputation of something already in a register.
  * Those are four different questions and an opcode can answer them differently: `LOAD_ATTR` is
- * removable but not shareable across a store, `RANDOM` is neither, and `CURVE` is both.
+ * removable but not shareable across a store, `RANDOM` is neither, and `LOAD_BUILTIN` is both.
  *
  * Every opcode has to appear in {@link VM_SEMANTICS} — the spec asserts it — because the safe
  * default for a new one is "assume nothing", and a table that silently omitted it would instead have
@@ -22,7 +22,7 @@ export function vm_semantics_of(op: number): ParticleOpSemantics;
  * Which lane of a source feeds which lane of the result is not a property of the opcode any more:
  * every register operand carries a swizzle, and `vm_operand_slot` in the ISA answers it per operand.
  * What is left here is per-opcode: whether lane `i` of the result depends on lane `i` of the
- * sources alone (`lanewise`), and whether every lane of the result is the same value (`broadcasts`).
+ * sources alone (`lanewise`).
  */
 /**
  * @typedef {object} ParticleOpSemantics
@@ -37,9 +37,6 @@ export function vm_semantics_of(op: number): ParticleOpSemantics;
  * @property {boolean} shareable two executions with equal operand values produce equal results, so a
  *   second one can read the first one's register instead. False for anything reading the record or
  *   the RNG.
- * @property {boolean} broadcasts every lane of the destination holds the same value, by construction
- *   rather than by what the operands happen to be. Lane `i` is then a copy of lane 0 and may be read
- *   as one.
  * @property {boolean} foldable the JS reference and the WGSL interpreter are both obliged to produce
  *   the *same bits* for this operation, so evaluating it here and baking a constant changes nothing
  *   on either. Correctly-rounded IEEE arithmetic qualifies; a transcendental does not — JS
@@ -79,12 +76,6 @@ export type ParticleOpSemantics = {
      * the RNG.
      */
     shareable: boolean;
-    /**
-     * every lane of the destination holds the same value, by construction
-     * rather than by what the operands happen to be. Lane `i` is then a copy of lane 0 and may be read
-     * as one.
-     */
-    broadcasts: boolean;
     /**
      * the JS reference and the WGSL interpreter are both obliged to produce
      * the *same bits* for this operation, so evaluating it here and baking a constant changes nothing

package/src/shade/renderer/particles/optimizer/particle_vm_semantics.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AAoJA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAY/B;AAnKD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,+CAA+C;AAC/C,2BADW,IAAI,MAAM,EAAE,mBAAmB,CAAC,CACL;;;;;;;kBA7BxB,OAAO;;;;;cAGP,OAAO;;;;;;gBAEP,OAAO;;;;;;eAGP,OAAO;;;;;;gBAGP,OAAO;;;;;;;;cAGP,OAAO;;;;;;;;;;sBAKP,OAAO"}
+{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AA4IA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAW/B;AA1JD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,+CAA+C;AAC/C,2BADW,IAAI,MAAM,EAAE,mBAAmB,CAAC,CACL;;;;;;;kBA1BxB,OAAO;;;;;cAGP,OAAO;;;;;;gBAEP,OAAO;;;;;;eAGP,OAAO;;;;;;;;cAGP,OAAO;;;;;;;;;;sBAKP,OAAO"}

package/src/shade/renderer/particles/optimizer/particle_vm_semantics.js

@@ -7,7 +7,7 @@ import { VM_OP } from "../isa/ParticleVMISA.js";
  * it — whether it can be deleted when its result is unread, narrowed when its high lanes are dead,
  * evaluated at compile time, or recognised as a recomputation of something already in a register.
  * Those are four different questions and an opcode can answer them differently: `LOAD_ATTR` is
- * removable but not shareable across a store, `RANDOM` is neither, and `CURVE` is both.
+ * removable but not shareable across a store, `RANDOM` is neither, and `LOAD_BUILTIN` is both.
  *
  * Every opcode has to appear in {@link VM_SEMANTICS} — the spec asserts it — because the safe
  * default for a new one is "assume nothing", and a table that silently omitted it would instead have
@@ -16,7 +16,7 @@ import { VM_OP } from "../isa/ParticleVMISA.js";
  * Which lane of a source feeds which lane of the result is not a property of the opcode any more:
  * every register operand carries a swizzle, and `vm_operand_slot` in the ISA answers it per operand.
  * What is left here is per-opcode: whether lane `i` of the result depends on lane `i` of the
- * sources alone (`lanewise`), and whether every lane of the result is the same value (`broadcasts`).
+ * sources alone (`lanewise`).
  */
 
 /**
@@ -32,9 +32,6 @@ import { VM_OP } from "../isa/ParticleVMISA.js";
  * @property {boolean} shareable two executions with equal operand values produce equal results, so a
  *   second one can read the first one's register instead. False for anything reading the record or
  *   the RNG.
- * @property {boolean} broadcasts every lane of the destination holds the same value, by construction
- *   rather than by what the operands happen to be. Lane `i` is then a copy of lane 0 and may be read
- *   as one.
  * @property {boolean} foldable the JS reference and the WGSL interpreter are both obliged to produce
  *   the *same bits* for this operation, so evaluating it here and baking a constant changes nothing
  *   on either. Correctly-rounded IEEE arithmetic qualifies; a transcendental does not — JS
@@ -62,7 +59,6 @@ function semantics(op, flags) {
         lanewise: false,
         narrowable: false,
         shareable: false,
-        broadcasts: false,
         foldable: false,
         foldable_inexact: false,
         ...flags,
@@ -141,10 +137,6 @@ semantics(VM_OP.SELECT, EXACT);
 // Ordered and side-effecting: it advances the shared RNG, and its width IS the number of draws it
 // takes. Removing, duplicating, reordering or narrowing one moves every value drawn after it.
 semantics(VM_OP.RANDOM, { side_effects: true });
-// An external WGSL symbol, but a pure function of (handle, t) — so a dead one goes and a repeated
-// one is shared. Every lane of the result is the same sample, which is what makes it narrowable —
-// and what makes it a broadcast, so a consumer reading it wide is a consumer that wants `.xxxx`.
-semantics(VM_OP.CURVE, { lanewise: true, narrowable: true, shareable: true, broadcasts: true });
 
 /**
  * What may be assumed about an opcode. An unknown one is assumed to do everything, so a new opcode
@@ -159,7 +151,6 @@ export function vm_semantics_of(op) {
         lanewise: false,
         narrowable: false,
         shareable: false,
-        broadcasts: false,
         foldable: false,
         foldable_inexact: false,
     };

package/src/shade/renderer/particles/runtime/create_particle_effect.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"create_particle_effect.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/create_particle_effect.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IALwE,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;IACjC,IAAI;IACJ,MAAM;;YACb,OAAO,6BAA6B,EAAE,cAAc;aAAW,OAAO,2BAA2B,EAAE,eAAe;EAKxI"}
+{"version":3,"file":"create_particle_effect.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/create_particle_effect.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;GAeG;AACH;IALwE,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;IACjC,IAAI;IACJ,MAAM;IACvB;IAAE,MAAM,EAAE,OAAO,6BAA6B,EAAE,cAAc,CAAC;IAAC,OAAO,EAAE,OAAO,2BAA2B,EAAE,eAAe,CAAA;CAAE,CAK1I"}

package/src/shade/renderer/particles/shaders/chunk_particle_avboit_contribution.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_avboit_contribution.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_avboit_contribution.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,iDAFU,SAAS,CA0Dc;0BA1EP,oCAAoC"}
+{"version":3,"file":"chunk_particle_avboit_contribution.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/chunk_particle_avboit_contribution.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;GAaG;AACH,iDAFU,SAAS,CAuEc;0BAvFP,oCAAoC"}

package/src/shade/renderer/particles/shaders/chunk_particle_avboit_contribution.js

@@ -24,6 +24,19 @@ struct ParticleAVBOITContribution {
     emission : vec4<f32>,
 }
 
+// Black covering fragments still contribute extinction; zero-alpha premultiplied RGB still emits.
+fn particle_avboit_is_empty(color : vec4<f32>, blend : u32) -> bool {
+    return all(particle_premultiply(color, blend) == vec4<f32>(0.0));
+}
+
+// The atlas is unorm, so non-negative straight alpha cannot produce emission. Signed alpha and
+// premultiplied sprites keep all four outputs: either can emit without positive coverage.
+fn particle_avboit_draw_blend(color : vec4<f32>, blend : u32) -> u32 {
+    if (blend == PARTICLE_BLEND_ADDITIVE) { return PARTICLE_BLEND_ADDITIVE; }
+    if (blend == PARTICLE_BLEND_ALPHA && color.a >= 0.0) { return PARTICLE_BLEND_ALPHA; }
+    return PARTICLE_BLEND_PREMULTIPLIED;
+}
+
 fn particle_avboit_contribution(
     shaded : vec4<f32>,
     blend : u32,

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.d.ts

@@ -1,9 +1,6 @@
-/**
- * The draw pipeline: the four additive accumulators, reverse-Z depth test against the scene, no
- * depth write.
- * @type {RenderPipelineDescriptor}
- */
-export const PARTICLE_AVBOIT_DRAW_PIPELINE: RenderPipelineDescriptor;
+export const PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE: RenderPipelineDescriptor;
+export const PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE: RenderPipelineDescriptor;
+export const PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE: RenderPipelineDescriptor;
 /** The draw shader's resource set, for building its bind group. */
 export const PARTICLE_AVBOIT_DRAW_RESOURCES: ShaderResourceSetDescriptor;
 /** The assembled shader, for the validity tier. */

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAkIA;;;;GAIG;AACH,4CAFU,wBAAwB,CAa/B;AAEH,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCAxJb,iEAAiE;4CAW9D,sDAAsD;iCAFjE,kCAAkC"}
+{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAgLA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCAxLb,iEAAiE;4CAW9D,sDAAsD;iCAFjE,kCAAkC"}

package/src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js

@@ -77,9 +77,28 @@ struct ParticleAVBOITDrawOutput {
     @location(3) emission : vec4<f32>,
 }
 
+// Each draw uses the same GPU-owned alive list. Clip the other modes before rasterization.
+fn particle_avboit_vertex(vi : u32, ii : u32, blend : u32) -> ParticleVertexOut {
+    var out = particle_billboard_vertex(vi, ii);
+    if (particle_avboit_draw_blend(out.color, out.blend) != blend) {
+        out.clip = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+    }
+    return out;
+}
+
 @vertex
-fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    return particle_billboard_vertex(vi, ii);
+fn vs_alpha(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ALPHA);
+}
+
+@vertex
+fn vs_additive(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ADDITIVE);
+}
+
+@vertex
+fn vs_general(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_PREMULTIPLIED);
 }
 
 @fragment
@@ -104,6 +123,10 @@ fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
         color = particle_apply_lighting(color, in.world_position, normalize(in.normal));
     }
 
+    if (particle_avboit_is_empty(color, in.blend)) {
+        discard;
+    }
+
     let volumetrics = sample_volumetrics(in.view_depth, screen_uv, in.clip.xy);
 
     let contribution = particle_avboit_contribution(color, in.blend, transmittance, volumetrics);
@@ -129,22 +152,31 @@ fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
 const descriptor = ShaderDescriptor.from({ label: "Particle AVBOIT Draw", body, resources });
 
 /**
- * The draw pipeline: the four additive accumulators, reverse-Z depth test against the scene, no
- * depth write.
- * @type {RenderPipelineDescriptor}
+ * The variants share WGSL, bindings and attachments; only the vertex entry point and target writes
+ * differ. Disabling unused targets avoids blending zeros over every billboard pixel.
+ * @param {string} label
+ * @param {string} entryPoint
+ * @param {number[]} writeMasks
+ * @returns {RenderPipelineDescriptor}
  */
-export const PARTICLE_AVBOIT_DRAW_PIPELINE = RenderPipelineDescriptor.from({
-    label: "Particle AVBOIT Draw",
-    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    vertex: { module: { code: descriptor.source }, entryPoint: "vs_main" },
-    fragment: {
-        module: { code: descriptor.source },
-        entryPoint: "fs_main",
-        targets: AVBOIT_DRAW_TARGETS,
-    },
-    depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
-    primitive: { topology: "triangle-list", cullMode: "none" },
-});
+function create_draw_pipeline(label, entryPoint, writeMasks) {
+    return RenderPipelineDescriptor.from({
+        label,
+        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+        vertex: { module: { code: descriptor.source }, entryPoint },
+        fragment: {
+            module: { code: descriptor.source },
+            entryPoint: "fs_main",
+            targets: AVBOIT_DRAW_TARGETS.map((target, i) => ({ ...target, writeMask: writeMasks[i] })),
+        },
+        depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
+        primitive: { topology: "triangle-list", cullMode: "none" },
+    });
+}
+
+export const PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Alpha", "vs_alpha", [0xF, 0xF, 0xF, 0]);
+export const PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Additive", "vs_additive", [0, 0, 0, 0xF]);
+export const PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw General", "vs_general", [0xF, 0xF, 0xF, 0xF]);
 
 /** The draw shader's resource set, for building its bind group. */
 export const PARTICLE_AVBOIT_DRAW_RESOURCES = resources;

package/src/shade/renderer/particles/shaders/shader_particle_emit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAqD3B,iDAIG;6BA1G0B,mCAAmC;8BAGlC,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAoD3B,iDAIG;6BAxG0B,mCAAmC;8BAGlC,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_emit.js

@@ -8,7 +8,6 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_fast } from "../vm/chunk_particle_vm_registers_fast.js";
-import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
 import { chunk_particle_emit_step } from "./chunk_particle_emit_step.js";
 
 /**
@@ -99,7 +98,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_emit_step,
     chunk_particle_vm_registers_fast,
-    chunk_particle_curve_disabled,
 ]);
 
 export const shader_particle_emit = ComputeShader.from({

package/src/shade/renderer/particles/shaders/shader_particle_emit_wide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit_wide.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,iDAFU,MAAM,CAGiD;AAiEjE,sDAIG;8BA9G2B,+BAA+B"}
+{"version":3,"file":"shader_particle_emit_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit_wide.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,iDAFU,MAAM,CAGiD;AAgEjE,sDAIG;8BA5G2B,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_emit_wide.js

@@ -7,7 +7,6 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_VM_WIDE_LAUNCH_LANES } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.js";
-import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
 import { chunk_particle_emit_step } from "./chunk_particle_emit_step.js";
 import { EMIT_SETTINGS, PARTICLE_EMIT_WORKGROUP_SIZE } from "./shader_particle_emit.js";
 
@@ -104,7 +103,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_emit_step,
     chunk_particle_vm_registers_wide,
-    chunk_particle_curve_disabled,
 ]);
 
 export const shader_particle_emit_wide = ComputeShader.from({

package/src/shade/renderer/particles/shaders/shader_particle_simulate.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AA0DA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAuD/B,qDAIG;iDAxH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAsD/B,qDAIG;iDApH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_simulate.js

@@ -8,7 +8,6 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_fast } from "../vm/chunk_particle_vm_registers_fast.js";
-import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
 import { chunk_particle_simulate_step } from "./chunk_particle_simulate_step.js";
 
 /**
@@ -47,9 +46,7 @@ import { chunk_particle_simulate_step } from "./chunk_particle_simulate_step.js"
  * frame from that same value, so thread count and bound agree by construction — and, because the
  * padded length is a whole number of workgroups, agree exactly.
  *
- * All structured reads go through `array<u32>` for emulator-testability. Curve sampling uses the
- * pluggable `particle_vm_sample_curve` — here the no-op provider; the feature swaps in the
- * animation-database-backed one.
+ * All structured reads go through `array<u32>` for emulator-testability.
  *
  * @type {ComputeShader}
  */
@@ -116,7 +113,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_simulate_step,
     chunk_particle_vm_registers_fast,
-    chunk_particle_curve_disabled,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

package/src/shade/renderer/particles/shaders/shader_particle_simulate_wide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate_wide.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;GAGG;AACH,qDAFU,MAAM,CAGqD;AA8DrE,0DAIG;8BAvH2B,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate_wide.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;GAGG;AACH,qDAFU,MAAM,CAGqD;AA6DrE,0DAIG;8BArH2B,+BAA+B"}

package/src/shade/renderer/particles/shaders/shader_particle_simulate_wide.js

@@ -7,7 +7,6 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_SIMULATE_WORKGROUP_SIZE, PARTICLE_VM_WIDE_LAUNCH_LANES } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.js";
-import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
 import { chunk_particle_simulate_step } from "./chunk_particle_simulate_step.js";
 import { SIMULATE_SETTINGS } from "./shader_particle_simulate.js";
 
@@ -111,7 +110,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_simulate_step,
     chunk_particle_vm_registers_wide,
-    chunk_particle_curve_disabled,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

package/src/shade/renderer/particles/sort/graph_particle_sort.d.ts

@@ -1,11 +1,24 @@
 /**
  * Frame-graph wiring for the RENDER order: the frame's alive list quantised by view depth and
- * scattered back-to-front, into `gpu.sorted`, for a draw whose blending is order-dependent.
+ * scattered back-to-front, for a draw whose blending is order-dependent.
  *
  * reset -> histogram -> csdldf scan -> scatter. The two per-particle passes are indirect, sized by
  * the same `sim_dispatch_args` the coherence reset wrote from the GPU's own alive count, so nothing
  * here is sized by a host-side particle count.
  *
+ * ## Every buffer here is the graph's
+ *
+ * Nothing the sort touches outlives the frame — the reset zeroes the bins and cursors, and the two
+ * per-particle lists are written for every entry the scatter goes on to read. So the pass that
+ * first writes each one declares it (a {@link BufferResourceDescriptor} in place of a handle) and
+ * the graph allocates it at that pass and releases it at its last reader, into the pool every other
+ * feature draws from. Two of them are a word per particle: at the renderer's default capacity that
+ * is 4 MiB the system would otherwise reserve for a mode it may never be drawn in.
+ *
+ * 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) and the cursor; `keys` and `sorted` are written by
+ * the same indirect dispatch that later reads them, entry for entry.
+ *
  * This is the ONLY producer of a depth ordering, and only {@link ParticleRenderMode.BILLBOARD} runs
  * it. It must never be confused with the simulation order the coherence passes build (`coherence/`):
  * that one groups by VM program so a wave runs one program, is camera-independent, and lives in a
@@ -14,36 +27,27 @@
  *
  * @param {object} params
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {object} params.gpu the persistent buffers owned by {@link GPUParticleSystem}
- * @param {GPUBuffer} params.gpu.sort_histogram `{count, elements}` bins for the CSDLDF scan
- * @param {GPUBuffer} params.gpu.sort_cursor per-bin scatter cursor
- * @param {GPUBuffer} params.gpu.sort_keys per-alive-entry depth bin
- * @param {GPUBuffer} params.gpu.sorted the back-to-front slot list this produces
  * @param {number} params.camera graph handle of the camera uniform buffer
  * @param {number} params.emitter_database graph handle
  * @param {number} params.pool graph handle of the particle pool
  * @param {number} params.alive graph handle of this frame's compacted alive list
  * @param {number} params.counters graph handle of the atomic counters
  * @param {number} params.dispatch_args graph handle of one workgroup per live particle
+ * @param {number} params.capacity pool capacity in particles — the length of the two lists below
  * @param {number} params.bucket_count depth bins the sort quantises into
  * @param {number} params.near view depth the first bin starts at
  * @param {number} params.far view depth the last bin ends at
  * @returns {number} graph handle of the sorted slot list
  */
-export function graph_particle_sort({ graph, gpu, camera, emitter_database, pool, alive, counters, dispatch_args, bucket_count, near, far, }: {
+export function graph_particle_sort({ graph, camera, emitter_database, pool, alive, counters, dispatch_args, capacity, bucket_count, near, far, }: {
     graph: import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph;
-    gpu: {
-        sort_histogram: GPUBuffer;
-        sort_cursor: GPUBuffer;
-        sort_keys: GPUBuffer;
-        sorted: GPUBuffer;
-    };
     camera: number;
     emitter_database: number;
     pool: number;
     alive: number;
     counters: number;
     dispatch_args: number;
+    capacity: number;
     bucket_count: number;
     near: number;
     far: number;

package/src/shade/renderer/particles/sort/graph_particle_sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particle_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/sort/graph_particle_sort.js"],"names":[],"mappings":"AAcA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH;IAjBqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,GAAG;QACI,cAAc;QACd,WAAW;QACX,SAAS;QACT,MAAM;;IACb,MAAM,EAArB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,YAAY,EAA3B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,GAAG,EAAlB,MAAM;IACJ,MAAM,CA2ElB"}
+{"version":3,"file":"graph_particle_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/sort/graph_particle_sort.js"],"names":[],"mappings":"AAgBA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwCG;AACH;IAbqG,KAAK,EAA/F,OAAO,8DAA8D,EAAE,UAAU;IAClE,MAAM,EAArB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,GAAG,EAAlB,MAAM;IACJ,MAAM,CA0ElB"}

package/src/shade/renderer/particles/sort/graph_particle_sort.js

@@ -1,10 +1,10 @@
 import { assert } from "../../../../core/assert.js";
 import { align_4 } from "../../../../core/binary/align_4.js";
+import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
 import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
 import { PREFIX_SCAN_CSDLDF_HEADER_WORDS } from "../../gpu_primitive/prefix_sum/v1/shader_prefix_scan_csdldf.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 {
     PARTICLE_SORT_WORKGROUP_SIZE,
     shader_particle_sort_histogram,
@@ -12,14 +12,29 @@ import {
     shader_particle_sort_scatter,
 } from "./shader_particle_sort.js";
 
+const WORD = Uint32Array.BYTES_PER_ELEMENT;
+
 /**
  * Frame-graph wiring for the RENDER order: the frame's alive list quantised by view depth and
- * scattered back-to-front, into `gpu.sorted`, for a draw whose blending is order-dependent.
+ * scattered back-to-front, for a draw whose blending is order-dependent.
  *
  * reset -> histogram -> csdldf scan -> scatter. The two per-particle passes are indirect, sized by
  * the same `sim_dispatch_args` the coherence reset wrote from the GPU's own alive count, so nothing
  * here is sized by a host-side particle count.
  *
+ * ## Every buffer here is the graph's
+ *
+ * Nothing the sort touches outlives the frame — the reset zeroes the bins and cursors, and the two
+ * per-particle lists are written for every entry the scatter goes on to read. So the pass that
+ * first writes each one declares it (a {@link BufferResourceDescriptor} in place of a handle) and
+ * the graph allocates it at that pass and releases it at its last reader, into the pool every other
+ * feature draws from. Two of them are a word per particle: at the renderer's default capacity that
+ * is 4 MiB the system would otherwise reserve for a mode it may never be drawn in.
+ *
+ * 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) and the cursor; `keys` and `sorted` are written by
+ * the same indirect dispatch that later reads them, entry for entry.
+ *
  * This is the ONLY producer of a depth ordering, and only {@link ParticleRenderMode.BILLBOARD} runs
  * it. It must never be confused with the simulation order the coherence passes build (`coherence/`):
  * that one groups by VM program so a wave runs one program, is camera-independent, and lives in a
@@ -28,17 +43,13 @@ import {
  *
  * @param {object} params
  * @param {import("../../../../engine/graphics/render/frame_graph/FrameGraph.js").FrameGraph} params.graph
- * @param {object} params.gpu the persistent buffers owned by {@link GPUParticleSystem}
- * @param {GPUBuffer} params.gpu.sort_histogram `{count, elements}` bins for the CSDLDF scan
- * @param {GPUBuffer} params.gpu.sort_cursor per-bin scatter cursor
- * @param {GPUBuffer} params.gpu.sort_keys per-alive-entry depth bin
- * @param {GPUBuffer} params.gpu.sorted the back-to-front slot list this produces
  * @param {number} params.camera graph handle of the camera uniform buffer
  * @param {number} params.emitter_database graph handle
  * @param {number} params.pool graph handle of the particle pool
  * @param {number} params.alive graph handle of this frame's compacted alive list
  * @param {number} params.counters graph handle of the atomic counters
  * @param {number} params.dispatch_args graph handle of one workgroup per live particle
+ * @param {number} params.capacity pool capacity in particles — the length of the two lists below
  * @param {number} params.bucket_count depth bins the sort quantises into
  * @param {number} params.near view depth the first bin starts at
  * @param {number} params.far view depth the last bin ends at
@@ -46,37 +57,39 @@ import {
  */
 export function graph_particle_sort({
                                         graph,
-                                        gpu,
                                         camera,
                                         emitter_database,
                                         pool,
                                         alive,
                                         counters,
                                         dispatch_args,
+                                        capacity,
                                         bucket_count,
                                         near,
                                         far,
                                     }) {
-    // The four buffers below are made on the first frame that sorts, not with the rest of the pool,
-    // because a system drawn through AVBOIT never sorts. Naming the missing one is worth a line:
-    // `graph_import_buffer` of an undefined buffer fails a long way from the cause.
-    for (const name of ["sort_histogram", "sort_cursor", "sort_keys", "sorted"]) {
-        assert.defined(gpu[name], `gpu.${name} — the render-order scratch was not allocated before the sort`);
-    }
+    assert.isPositiveInteger(capacity, "capacity");
+    assert.isPositiveInteger(bucket_count, "bucket_count");
 
-    let histogram = graph_import_buffer(graph, gpu.sort_histogram, "particles/sort_histogram");
-    let cursor = graph_import_buffer(graph, gpu.sort_cursor, "particles/sort_cursor");
-    let keys = graph_import_buffer(graph, gpu.sort_keys, "particles/sort_keys");
-    let sorted = graph_import_buffer(graph, gpu.sorted, "particles/sorted");
-
-    // The reset's widest loop is the scan header plus the bins rounded up to a whole vec4.
+    // The reset's widest loop is the scan header plus the bins rounded up to a whole vec4, and so
+    // is the buffer it clears.
     const reset_words = PREFIX_SCAN_CSDLDF_HEADER_WORDS + align_4(bucket_count);
 
+    const LIST_DESCRIPTOR = BufferResourceDescriptor.from(capacity * WORD, GPUBufferUsage.STORAGE);
+
+    // Each pass below is handed a descriptor for the buffers it is the first to write, and a handle
+    // for everything else; `graph_compute_pass` creates the one and threads the other.
+    let histogram;
+    let cursor;
     {
         const out = graph_compute_pass({
             graph,
             shader: shader_particle_sort_reset,
-            bindings: { histogram, cursor, settings: { u_bucket_count: bucket_count } },
+            bindings: {
+                histogram: BufferResourceDescriptor.from(reset_words * WORD, GPUBufferUsage.STORAGE),
+                cursor: BufferResourceDescriptor.from(bucket_count * WORD, GPUBufferUsage.STORAGE),
+                settings: { u_bucket_count: bucket_count },
+            },
             group_count: [Math.ceil(reset_words / PARTICLE_SORT_WORKGROUP_SIZE), 1, 1],
         });
         histogram = out.histogram;
@@ -85,12 +98,14 @@ export function graph_particle_sort({
 
     // The counters are only read here, but an atomic read needs a read_write binding, and the
     // graph sees a write — so the handle is threaded through like any other.
+    let keys;
     {
         const out = graph_compute_indirect_pass({
             graph,
             shader: shader_particle_sort_histogram,
             bindings: {
-                camera, emitter_database, pool, alive, counters, keys, histogram,
+                camera, emitter_database, pool, alive, counters, histogram,
+                keys: LIST_DESCRIPTOR,
                 settings: { u_near: near, u_far: far, u_bucket_count: bucket_count },
             },
             command: dispatch_args,
@@ -106,15 +121,10 @@ export function graph_particle_sort({
         element_max_count: bucket_count,
     });
 
-    {
-        const out = graph_compute_indirect_pass({
-            graph,
-            shader: shader_particle_sort_scatter,
-            bindings: { keys, alive, scanned, counters, cursor, sorted },
-            command: dispatch_args,
-        });
-        sorted = out.sorted;
-    }
-
-    return sorted;
+    return graph_compute_indirect_pass({
+        graph,
+        shader: shader_particle_sort_scatter,
+        bindings: { keys, alive, scanned, counters, cursor, sorted: LIST_DESCRIPTOR },
+        command: dispatch_args,
+    }).sorted;
 }

package/src/shade/renderer/particles/vm/ParticleVMReference.d.ts

@@ -36,17 +36,15 @@ export function u32_to_unit_f32(u: number): number;
  * @param {Uint32Array} params.record particle record words (mutated in place); attributes are f32 bits
  * @param {number[][]} [params.builtins] builtin values indexed by {@link VM_BUILTIN} id, each a 4-array
  * @param {number} [params.rng_state] initial RNG state (u32)
- * @param {(handle: number, t: number) => number} [params.sampleCurve] curve evaluator for the CURVE op
  * @returns {{ killed: boolean, rng_state: number }}
  */
-export function execute_particle_vm({ words, constants, register_count, record, builtins, rng_state, sampleCurve, }: {
+export function execute_particle_vm({ words, constants, register_count, record, builtins, rng_state, }: {
     words: Uint32Array;
     constants: Float32Array;
     register_count: number;
     record: Uint32Array;
     builtins?: number[][];
     rng_state?: number;
-    sampleCurve?: (handle: number, t: number) => number;
 }): {
     killed: boolean;
     rng_state: number;

package/src/shade/renderer/particles/vm/ParticleVMReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleVMReference.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/ParticleVMReference.js"],"names":[],"mappings":"AA0BA;;;;;;;GAOG;AACH,gCAHW,MAAM;WACK,MAAM;WAAS,MAAM;EAW1C;AAED;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAqED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;WATW,WAAW;eACX,YAAY;oBACZ,MAAM;YACN,WAAW;eACX,MAAM,EAAE,EAAE;gBACV,MAAM;2BACG,MAAM,KAAK,MAAM,KAAK,MAAM;;YACzB,OAAO;eAAa,MAAM;EA+RhD"}
+{"version":3,"file":"ParticleVMReference.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/ParticleVMReference.js"],"names":[],"mappings":"AA0BA;;;;;;;GAOG;AACH,gCAHW,MAAM,GACJ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAW5C;AAED;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AA8DD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR+B,KAAK,EAAzB,WAAW;IACU,SAAS,EAA9B,YAAY;IACG,cAAc,EAA7B,MAAM;IACc,MAAM,EAA1B,WAAW;IACS,QAAQ,GAA5B,MAAM,EAAE,EAAE;IACM,SAAS,GAAzB,MAAM;IACJ;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAuRlD"}