@woosh/meep-engine 3.19.0 → 3.21.0

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.js

@@ -90,12 +90,14 @@ for (const type of PARTICLE_ALL_VALUE_TYPES) {
  *
  * IDs are handed out in declaration order rather than by {@link NodeDescription}'s global counter,
  * so they do not drift with unrelated node usage elsewhere in the engine. Appending new node types
- * at the end of the library is therefore safe; reordering or removing existing ones renumbers every
- * node that follows, which would invalidate already-serialized graphs.
+ * at the end of the library is therefore safe. Removed types leave their IDs unused so existing
+ * serialized graphs retain the same IDs for every remaining type.
  *
  * @type {Map<string, ParticleNodeDescription>}
  */
-const descriptions_by_name = new Map();
+const descriptions_by_name = new Map();
+
+let next_description_id = 0;
 
 /**
  * @param {string} name
@@ -123,7 +125,7 @@ function define(name, inputs, emit, {
     const description = new ParticleNodeDescription();
 
     description.name = name;
-    description.id = descriptions_by_name.size;
+    description.id = next_description_id++;
 
     // what an author reads is decided in one table, away from the lowering; see
     // ./particle_node_presentation.js
@@ -572,14 +574,8 @@ define("compare", ["a", "b"], (s, c) => {
 }, MASK_RESULT);
 define("select", ["a", "b", "condition"], (s, c) => s.emit(VM_OP.SELECT, c.out, c.in("a"), c.in("b"), c.in("condition"), c.width), blend_controlled_by("condition"));
 
-// --- curves ---
-// One lane of `t` in, one value out — which the opcode writes across every lane it is asked for, so
-// a curve read wider than a scalar is the broadcast for free.
-define("curve", ["t"], (s, c) => s.curve(c.out, c.parameters.handle, c.in("t"), c.width), {
-    infer_types: () => ({ output: PARTICLE_TYPE_F32, inputs: { t: PARTICLE_TYPE_F32 } }),
-    operation_width: ({ demand }) => demand,
-    input_widths: () => ({ t: 1 }),
-});
+// ID 39 belonged to the removed animation-table sampler. Keep it unused.
+next_description_id++;
 
 // --- semantic sources ---
 // Appended rather than filed with the other sources, because a node type's id is its position in
@@ -665,9 +661,7 @@ function expanding(name, inputs, output, body) {
     return description;
 }
 
-// One curve, written into the program. Not the `curve` node above: that one samples a row of the
-// host's animation-curve table and this one *is* the curve, the way `color` is a colour rather than
-// the name of one.
+// One authored curve, written into the program as arithmetic.
 expanding(
     "curveLiteral",
     [{ name: "t", type: PARTICLE_TYPE_F32 }],

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"}

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

@@ -1 +1 @@
-{"version":3,"file":"particle_group_json.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_json.js"],"names":[],"mappings":"AA+CA;;;;;;;;;GASG;AAEH;;;GAGG;AACH,gDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,iBAAiB,CAmC7B;AAED;;;;;;;;;;GAUG;AACH;IAPqC,IAAI,EAA9B,iBAAiB;IACsB,cAAc;IAES,OAAO,UAA5D,MAAM,KAAE,CAAC,0BAAwB,SAAS,CAAC;IAElD,OAAO,wBAAwB,EAAE,iBAAiB,CAiD9D;AAED;;;;;;;GAOG;AACH,mDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,8BAA8B,EAAE,uBAAuB,EAAE,CAI5E;AA9JD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAEwC;AAExD;;GAEG;AACH,yCAFU,MAAM,CAE0C;;UAS5C,MAAM;WACN,MAAM;UACN,MAAM;UACN,MAAM;YACN,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;aACxC,MAAM;QAAC,MAAM,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;UACxC,OAAO,0BAA0B,EAAE,iBAAiB"}
+{"version":3,"file":"particle_group_json.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_json.js"],"names":[],"mappings":"AA+CA;;;;;;;;;GASG;AAEH;;;GAGG;AACH,gDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,iBAAiB,CAmC7B;AAED;;;;;;;;;;GAUG;AACH;IAPqC,IAAI,EAA9B,iBAAiB;IACsB,cAAc;IAES,OAAO,UAA5D,MAAM,KAAE,CAAC,0BAAwB,SAAS,CAAC;IAElD,OAAO,wBAAwB,EAAE,iBAAiB,CAiD9D;AAED;;;;;;;GAOG;AACH,mDAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,8BAA8B,EAAE,uBAAuB,EAAE,CAI5E;AA9JD;;;;;;;;;;;;;;;;;;;;GAoBG;AAEH;;;GAGG;AACH,wCAFU,MAAM,CAEwC;AAExD;;GAEG;AACH,yCAFU,MAAM,CAE0C;;UAS5C,MAAM;WACN,MAAM;UACN,MAAM;UACN,MAAM;YACN,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;aACxC,MAAM;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,GAAC,IAAI,CAAA;KAAC,CAAC;UACxC,OAAO,0BAA0B,EAAE,iBAAiB"}

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

@@ -1 +1 @@
-{"version":3,"file":"particle_group_library.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_library.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH,+CAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,wBAAwB,EAAE,iBAAiB,CAgB9D;AAED;;;;GAIG;AACH,mCAFa,OAAO,wBAAwB,EAAE,iBAAiB,EAAE,CAIhE;AAED;;;;;GAKG;AACH,yCAHW,MAAM,GACJ,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,SAAS,CAIxE;AAED;;;;;GAKG;AACH,6CAHW,MAAM,GACJ,OAAO,CAInB"}
+{"version":3,"file":"particle_group_library.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_group_library.js"],"names":[],"mappings":"AAoBA;;;;;;;;;;GAUG;AACH,+CAHW,OAAO,wBAAwB,EAAE,iBAAiB,GAChD,OAAO,wBAAwB,EAAE,iBAAiB,CAqB9D;AAED;;;;GAIG;AACH,mCAFa,OAAO,wBAAwB,EAAE,iBAAiB,EAAE,CAIhE;AAED;;;;;GAKG;AACH,yCAHW,MAAM,GACJ,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,SAAS,CAIxE;AAED;;;;;GAKG;AACH,6CAHW,MAAM,GACJ,OAAO,CAInB"}

package/src/shade/renderer/particles/graph/particle_group_library.js

@@ -38,9 +38,14 @@ export function register_particle_group(group) {
 
     // The group node itself, and the two boundary blocks its body is wired to: a view that opens the
     // group draws those, and everything drawn needs a box generated for it.
-    PARTICLE_NODE_REGISTRY.addNode(group.description);
-    PARTICLE_NODE_REGISTRY.addNode(group.inputNode.description);
-    PARTICLE_NODE_REGISTRY.addNode(group.outputNode.description);
+    // Stock types leave holes when removed. Allocate after their highest ID rather than relying
+    // on NodeDescription's global counter, which counts constructions, not reserved IDs.
+    let id = Math.max(...PARTICLE_NODE_REGISTRY.nodes.keys()) + 1;
+
+    for (const description of [group.description, group.inputNode.description, group.outputNode.description]) {
+        description.id = id++;
+        PARTICLE_NODE_REGISTRY.addNode(description);
+    }
 
     return group;
 }

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

@@ -91,8 +91,6 @@ export const PARTICLE_PARAMETER_KIND: Readonly<{
     ENUM: "enum";
     /** one to four lane selectors in `[0, 4)`, one per output lane */
     SWIZZLE: "swizzle";
-    /** a non-negative integer — a curve handle */
-    INTEGER: "integer";
     /**
      * an {@link ../../../../engine/animation/curve/AnimationCurve.js AnimationCurve}, as the
      * `{keys: [...]}` record that class writes and reads

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

@@ -1 +1 @@
-{"version":3,"file":"particle_node_parameters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_parameters.js"],"names":[],"mappings":"AAwMA;;;;;;;;;;;;;;;;;GAiBG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAwBD;;;;;;GAMG;AACH,+CAJW,MAAM,GACJ,qBAAqB,EAAE,CAcnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,uDANW,MAAM;IAEyD,MAAM,GAArE,OAAO,6BAA6B,EAAE,cAAc;IAElD,MAAM,CAmBlB;AAED;;;;GAIG;AACH,2CAFa,MAAM;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,uBAAuB,CAAC;IAAC,UAAU,EAAE,qBAAqB,EAAE,CAAA;CAAC,CAAC,CAOrI;;;;sCA7RS,MAAM;AApBhB;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH;IACI,0FAA0F;;IAE1F,kFAAkF;;IAElF,mFAAmF;;IAEnF,2EAA2E;;IAE3E,kEAAkE;;IAElE,8CAA8C;;IAE9C;;;OAGG;;IAEH;;;OAGG;;GAEJ;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,gDAFU,MAAM,EAAE,CAWf;AAEH;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,MAAM;EAI7B;AAEF;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,qBAAqB,EAAE;EA8F7C;;;;;;;;UA7IW,MAAM;;;;UACN,MAAM;;;;;;;;;;YAGC,MAAM;;;;;;;;YACb,OAAO;;;;kBAIP,MAAM"}
+{"version":3,"file":"particle_node_parameters.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_parameters.js"],"names":[],"mappings":"AA+LA;;;;;;;;;;;;;;;;;GAiBG;AACH,sDAHW,MAAM,GACJ,MAAM,CAIlB;AAwBD;;;;;;GAMG;AACH,+CAJW,MAAM,GACJ,qBAAqB,EAAE,CAcnC;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,uDANW,MAAM;IAEyD,MAAM,GAArE,OAAO,6BAA6B,EAAE,cAAc;IAElD,MAAM,CAmBlB;AAED;;;;GAIG;AACH,2CAFa,MAAM;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,uBAAuB,CAAC;IAAC,UAAU,EAAE,qBAAqB,EAAE,CAAA;CAAC,CAAC,CAOrI;;;;sCApRS,MAAM;AApBhB;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH;IACI,0FAA0F;;IAE1F,kFAAkF;;IAElF,mFAAmF;;IAEnF,2EAA2E;;IAE3E,kEAAkE;;IAElE;;;OAGG;;IAEH;;;OAGG;;GAEJ;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;;;;GASG;AACH,gDAFU,MAAM,EAAE,CAWf;AAEH;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,MAAM;EAI7B;AAEF;;;;;GAKG;AACH;QAFiB,MAAM,GAAE,qBAAqB,EAAE;EAuF7C;;;;;;;;UAtIW,MAAM;;;;UACN,MAAM;;;;;;;;;;YAGC,MAAM;;;;;;;;YACb,OAAO;;;;kBAIP,MAAM"}

package/src/shade/renderer/particles/graph/particle_node_parameters.js

@@ -37,8 +37,6 @@ export const PARTICLE_PARAMETER_KIND = Object.freeze({
     ENUM: "enum",
     /** one to four lane selectors in `[0, 4)`, one per output lane */
     SWIZZLE: "swizzle",
-    /** a non-negative integer — a curve handle */
-    INTEGER: "integer",
     /**
      * an {@link ../../../../engine/animation/curve/AnimationCurve.js AnimationCurve}, as the
      * `{keys: [...]}` record that class writes and reads
@@ -172,13 +170,6 @@ export const PARTICLE_NODE_PARAMETER_SCHEMA = Object.freeze({
         description: "Which input lane each output lane reads; one to four of them, and that count is the result's width.",
     }],
 
-    curve: [{
-        name: "handle",
-        kind: PARTICLE_PARAMETER_KIND.INTEGER,
-        default: 0,
-        description: "Row of the animation-curve table to sample.",
-    }],
-
     curveLiteral: [{
         name: "curve",
         kind: PARTICLE_PARAMETER_KIND.CURVE,

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

@@ -1 +1 @@
-{"version":3,"file":"particle_node_presentation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_presentation.js"],"names":[],"mappings":"AA2UA;;;;;;;GAOG;AACH,iDAHW,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAIvD;AA3SD;;;;;;;;GAQG;AACH;QAFiB,MAAM,GAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;EAwRjE"}
+{"version":3,"file":"particle_node_presentation.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_node_presentation.js"],"names":[],"mappings":"AAiUA;;;;;;;GAOG;AACH,iDAHW,MAAM,GACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAC,CAIvD;AAjSD;;;;;;;;GAQG;AACH;QAFiB,MAAM,GAAE;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC;EA8QjE"}

package/src/shade/renderer/particles/graph/particle_node_presentation.js

@@ -301,17 +301,7 @@ export const PARTICLE_NODE_PRESENTATION = Object.freeze({
     },
 
     // --- ramps ---
-    // Two ways to have a curve, and the labels say which is which. The table one came first and was
-    // called just "Curve"; it is renamed here rather than leaving the new one to explain itself,
-    // because "the one that samples the host's table" is the surprising half of the pair and the
-    // one an author has to have decided to want.
-    curve: {
-        label: "Curve Table",
-        icon: `M5 18C10 18 9 6 19 6 ${dot(5, 18, 1.6)} ${dot(19, 6, 1.6)}`,
-        help: "sample a row of the host's animation-curve table at t",
-    },
     curveLiteral: {
-        // the same curve with its keys on it: this one is the curve rather than a handle to one
         label: "Curve",
         icon: `M4 19C10 19 8 5 20 5 ${dot(4, 19, 1.8)} ${dot(12, 12, 1.8)} ${dot(20, 5, 1.8)}`,
         help: "a curve of your own, written into the program: t in, its value out",

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

@@ -128,14 +128,8 @@ export function roll_out_particle_gradient(g: import("./ParticleGroupBuilder.js"
  * {@link ./ParticleNodeDescription.js ParticleNodeDescription#expand}), and this is what they expand
  * *into*: stock nodes, which is to say VM instructions, with the curve rolled out along them.
  *
- * ## Rolled out, not sampled
- *
- * There is a `CURVE` opcode, and it is not this. That one samples a row of the animation-curve table
- * a host uploads, which is the right answer for a curve an author is dragging around at runtime and
- * the wrong one for a curve that is part of the effect: it costs a table, a row, a handle to keep in
- * step with it, and a texture fetch. A ramp with four stops rolls out to about twenty instructions
- * of pure arithmetic, needs nothing from the host, and constant-folds where an author has left a
- * segment flat.
+ * A ramp with four stops rolls out to about twenty instructions of pure arithmetic, needs nothing
+ * from the host, and constant-folds where an author has left a segment flat.
  *
  * ## How a piecewise function becomes straight-line code
  *

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

@@ -1 +1 @@
-{"version":3,"file":"particle_ramp.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_ramp.js"],"names":[],"mappings":"AA2FA;;;;;;;;GAQG;AACH,0CAFa,sBAAsB,CASlC;AAED;;;;GAIG;AACH,6CAFa,oBAAoB,EAAE,CAOlC;AAUD;;;;;;;;;GASG;AACH,+CAFa,OAAO,CAanB;AAED;;;;;GAKG;AACH,kDAFa,OAAO,CAanB;AAED;;;;;;;;;GASG;AACH,2CAHW,sBAAsB,GACpB,gBAAgB,EAAE,CAI9B;AAED;;;;;;GAMG;AACH,gDAHW,sBAAsB,GACpB,cAAc,CAQ1B;AAED;;;;;GAKG;AACH,qDAHW,cAAc,GACZ,sBAAsB,CAWlC;AAED;;;;;GAKG;AACH,+CAHW,oBAAoB,EAAE,GACpB,oBAAoB,EAAE,CAMlC;AAED;;;;;;;GAOG;AACH,gDAJW,oBAAoB,EAAE,KACtB,MAAM,GACJ,MAAM,EAAE,CAsBpB;AA8BD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CALW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,sBAAsB,OA+ChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CANW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,oBAAoB,EAAE,cACtB,MAAM,OA8BhB;AA/YD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwDG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AACH,iDAFU,MAAM,CAEoC;;;;;;UAxBtC,MAAM;WACN,MAAM;eACN,MAAM;gBACN,MAAM;;;;;qCAMP;IAAC,IAAI,EAAE,gBAAgB,EAAE,CAAA;CAAC;;;;;;mCAQ1B;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC;+BAlFjB,sDAAsD"}
+{"version":3,"file":"particle_ramp.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/particle_ramp.js"],"names":[],"mappings":"AAqFA;;;;;;;;GAQG;AACH,0CAFa,sBAAsB,CASlC;AAED;;;;GAIG;AACH,6CAFa,oBAAoB,EAAE,CAOlC;AAUD;;;;;;;;;GASG;AACH,+CAFa,OAAO,CAanB;AAED;;;;;GAKG;AACH,kDAFa,OAAO,CAanB;AAED;;;;;;;;;GASG;AACH,2CAHW,sBAAsB,GACpB,gBAAgB,EAAE,CAI9B;AAED;;;;;;GAMG;AACH,gDAHW,sBAAsB,GACpB,cAAc,CAQ1B;AAED;;;;;GAKG;AACH,qDAHW,cAAc,GACZ,sBAAsB,CAWlC;AAED;;;;;GAKG;AACH,+CAHW,oBAAoB,EAAE,GACpB,oBAAoB,EAAE,CAMlC;AAED;;;;;;;GAOG;AACH,gDAJW,oBAAoB,EAAE,KACtB,MAAM,GACJ,MAAM,EAAE,CAsBpB;AA8BD;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,2CALW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,sBAAsB,OA+ChC;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,8CANW,OAAO,2BAA2B,EAAE,oBAAoB,iBAExD,oBAAoB,EAAE,cACtB,MAAM,OA8BhB;AAzYD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkDG;AAEH;;;;;;;;;GASG;AAEH;;;;GAIG;AAEH;;;;;;GAMG;AAEH;;;GAGG;AACH,iDAFU,MAAM,CAEoC;;;;;;UAxBtC,MAAM;WACN,MAAM;eACN,MAAM;gBACN,MAAM;;;;;qCAMP;IAAC,IAAI,EAAE,gBAAgB,EAAE,CAAA;CAAC;;;;;;mCAQ1B;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,EAAE,CAAA;CAAC;+BA5EjB,sDAAsD"}

package/src/shade/renderer/particles/graph/particle_ramp.js

@@ -11,14 +11,8 @@ import { AnimationCurve } from "../../../../engine/animation/curve/AnimationCurv
  * {@link ./ParticleNodeDescription.js ParticleNodeDescription#expand}), and this is what they expand
  * *into*: stock nodes, which is to say VM instructions, with the curve rolled out along them.
  *
- * ## Rolled out, not sampled
- *
- * There is a `CURVE` opcode, and it is not this. That one samples a row of the animation-curve table
- * a host uploads, which is the right answer for a curve an author is dragging around at runtime and
- * the wrong one for a curve that is part of the effect: it costs a table, a row, a handle to keep in
- * step with it, and a texture fetch. A ramp with four stops rolls out to about twenty instructions
- * of pure arithmetic, needs nothing from the host, and constant-folds where an author has left a
- * segment flat.
+ * A ramp with four stops rolls out to about twenty instructions of pure arithmetic, needs nothing
+ * from the host, and constant-folds where an author has left a segment flat.
  *
  * ## How a piecewise function becomes straight-line code
  *

package/src/shade/renderer/particles/graph/validate_particle_graph.js

@@ -231,12 +231,6 @@ function check_parameters(node, description, layout, error) {
                 }
                 break;
 
-            case PARTICLE_PARAMETER_KIND.INTEGER:
-                if (!Number.isInteger(value) || value < 0) {
-                    error(node.id, `Parameter '${parameter.name}' must be a non-negative whole number.`);
-                }
-                break;
-
             // A curve and a gradient are the only parameters with a shape underneath them, and both
             // are written out into instructions rather than read at runtime — so a malformed one is
             // a compile that throws rather than a value that misbehaves, and it is worth catching

package/src/shade/renderer/particles/graph_particles.d.ts

@@ -59,6 +59,17 @@
  * passes must read — exactly the ReSTIR reservoir pattern. Every persistent buffer is imported
  * exactly once: two imports of one buffer are two resource entries the graph cannot tell apart.
  *
+ * ## What is imported, and what the graph owns
+ *
+ * A buffer is imported only if its contents cross the frame boundary: the pool, the free list, the
+ * counters, the alive lists, `sim_list` (written here, read by next frame's simulate),
+ * `dispatch_args` (the same), the program blob and the two CPU-uploaded queues. Everything else is
+ * produced and consumed inside one graph, so the pass that first writes it declares it with a
+ * {@link BufferResourceDescriptor} in place of a handle and the graph allocates it just in time and
+ * releases it after its last reader — into the pool every other feature draws from. That is the
+ * spawn counts and the emit command, the VM's wide register file, the draw args, the bucketing
+ * scratch (`coherence/`) and the whole depth sort (`sort/`).
+ *
  * On the very first frame `dispatch_args` must be zero-initialised (WebGPU zero-fills new buffers)
  * and the `ALIVE_IN` counter 0, so simulate is a no-op until the first build-indirect has run.
  */

package/src/shade/renderer/particles/graph_particles.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA7BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IACS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CAuTrC;;;;;UA/Va,MAAM;;;;WACN,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;uBACN,MAAM;;;;;sBACN,MAAM"}
+{"version":3,"file":"graph_particles.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA0EG;AAEH;;;;;;;;;GASG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAgCG;AACH;IA7BkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,cAAc,EAA7B,MAAM;IACS,GAAG,EAAlB,MAAM;IACS,QAAQ;QACC,QAAQ,EAAhC,MAAM;QAEkB,WAAW,EAAnC,MAAM;;IACS,QAAQ,EAAvB,MAAM;IACS,YAAY,EAA3B,MAAM;IAEU,cAAc,EAA9B,OAAO;IAGQ,KAAK;QACC,EAAE,EAAvB,MAAM;QACe,IAAI,EAAzB,MAAM;QACe,KAAK,EAA1B,MAAM;QACiB,QAAQ,GAA/B,OAAO;QACc,WAAW,EAAhC,MAAM;QACe,mBAAmB,EAAxC,MAAM;QACe,YAAY,EAAjC,MAAM;QAGe,eAAe,EAApC,MAAM;QAC6D,eAAe,EAAlF,OAAO,6BAA6B,EAAE,cAAc;;IAElD,yBAAyB,CA8TrC;;;;;UAtWa,MAAM;;;;WACN,MAAM;;;;cACN,MAAM;;;;eACN,MAAM;;;;uBACN,MAAM;;;;;sBACN,MAAM"}

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

@@ -98,6 +98,17 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
  * passes must read — exactly the ReSTIR reservoir pattern. Every persistent buffer is imported
  * exactly once: two imports of one buffer are two resource entries the graph cannot tell apart.
  *
+ * ## What is imported, and what the graph owns
+ *
+ * A buffer is imported only if its contents cross the frame boundary: the pool, the free list, the
+ * counters, the alive lists, `sim_list` (written here, read by next frame's simulate),
+ * `dispatch_args` (the same), the program blob and the two CPU-uploaded queues. Everything else is
+ * produced and consumed inside one graph, so the pass that first writes it declares it with a
+ * {@link BufferResourceDescriptor} in place of a handle and the graph allocates it just in time and
+ * releases it after its last reader — into the pool every other feature draws from. That is the
+ * spawn counts and the emit command, the VM's wide register file, the draw args, the bucketing
+ * scratch (`coherence/`) and the whole depth sort (`sort/`).
+ *
  * On the very first frame `dispatch_args` must be zero-initialised (WebGPU zero-fills new buffers)
  * and the `ALIVE_IN` counter 0, so simulate is a no-op until the first build-indirect has run.
  */
@@ -134,8 +145,8 @@ import { graph_particle_warmup } from "./warmup/graph_particle_warmup.js";
  * @param {object} params.frame per-frame scalars
  * @param {number} params.frame.dt
  * @param {number} params.frame.time
- * @param {number} params.frame.index
- * @param {boolean} [params.frame.rebucket] program assignments changed since the previous frame
+ * @param {number} params.frame.index
+ * @param {boolean} [params.frame.rebucket] program assignments changed since the previous frame
  * @param {number} params.frame.max_catchup seconds of missed spawning a woken emitter makes up
  * @param {number} params.frame.spawn_command_count entries in `gpu.spawn_commands` this frame
  * @param {number} params.frame.warmup_count entries in `gpu.warmup_queue` this frame — emitters
@@ -163,9 +174,16 @@ export function graph_particles_simulate({
     assert.isPositiveInteger(capacity, "capacity");
 
     const gr_program = graph_import_buffer(graph, gpu.program, "particles/program");
-    let gr_sim_list = graph_import_buffer(graph, gpu.sim_list, "particles/sim_list");
-    let gr_dispatch = graph_import_buffer(graph, gpu.dispatch_args, "particles/dispatch_args");
-    let gr_draw = graph_import_buffer(graph, gpu.draw_args, "particles/draw_args");
+    let gr_sim_list = graph_import_buffer(graph, gpu.sim_list, "particles/sim_list");
+    let gr_dispatch = graph_import_buffer(graph, gpu.dispatch_args, "particles/dispatch_args");
+    // The draw args are the one indirect buffer that does NOT cross the frame boundary: build-
+    // indirect writes all four words at the end of the frame and this frame's draw is the only
+    // reader, so the pass that writes them declares them and the graph owns them. `gr_dispatch` is
+    // the opposite case and stays imported — next frame's simulate is its reader.
+    let gr_draw = BufferResourceDescriptor.from(
+        4 * Uint32Array.BYTES_PER_ELEMENT,
+        GPUBufferUsage.STORAGE | GPUBufferUsage.INDIRECT,
+    );
 
     // Buffers mutated by more than one pass must be THREADED: each compute pass writing an imported
     // buffer returns a renamed (versioned) handle, and the next pass must read THAT handle — reading
@@ -177,32 +195,32 @@ export function graph_particles_simulate({
     // Two tables in one buffer — the emitter records the CPU authors and the state the GPU
     // integrates — so the passes that write the state rename the handle every reader after them
     // takes.
-    let emitter_database = graph_import_buffer(graph, gpu.emitter_database, "particles/emitter_database");
-
-    /** @type {import("./coherence/graph_particle_bucket.js").ParticleBucketScratch|undefined} */
-    let bucket_scratch;
-    if (frame.rebucket) {
-        // Live program edits can split a previously uniform wave. Rebuild from the previous
-        // compact alive list BEFORE reset discards its count and before simulate broadcasts code.
-        const bucketed = graph_particle_bucket({
-            graph, gpu, emitter_database, pool, counters, bucket_count,
-            alive: graph_import_buffer(graph, gpu.alive_read, "particles/alive_read"),
-            sim_list: gr_sim_list,
-        });
-        gr_sim_list = bucketed.sim_list;
-        bucket_scratch = bucketed.scratch;
-        const indirect = graph_compute_pass({
-            graph, shader: shader_particle_build_indirect,
-            bindings: {
-                counters: bucketed.counters, dispatch_args: gr_dispatch, draw_args: gr_draw,
-                u_workgroup_size: PARTICLE_SIMULATE_WORKGROUP_SIZE,
-            },
-            group_count: [1, 1, 1],
-        });
-        counters = indirect.counters;
-        gr_dispatch = indirect.dispatch_args;
-        gr_draw = indirect.draw_args;
-    }
+    let emitter_database = graph_import_buffer(graph, gpu.emitter_database, "particles/emitter_database");
+
+    /** @type {import("./coherence/graph_particle_bucket.js").ParticleBucketScratch|undefined} */
+    let bucket_scratch;
+    if (frame.rebucket) {
+        // Live program edits can split a previously uniform wave. Rebuild from the previous
+        // compact alive list BEFORE reset discards its count and before simulate broadcasts code.
+        const bucketed = graph_particle_bucket({
+            graph, emitter_database, pool, counters, capacity, bucket_count,
+            alive: graph_import_buffer(graph, gpu.alive_read, "particles/alive_read"),
+            sim_list: gr_sim_list,
+        });
+        gr_sim_list = bucketed.sim_list;
+        bucket_scratch = bucketed.scratch;
+        const indirect = graph_compute_pass({
+            graph, shader: shader_particle_build_indirect,
+            bindings: {
+                counters: bucketed.counters, dispatch_args: gr_dispatch, draw_args: gr_draw,
+                u_workgroup_size: PARTICLE_SIMULATE_WORKGROUP_SIZE,
+            },
+            group_count: [1, 1, 1],
+        });
+        counters = indirect.counters;
+        gr_dispatch = indirect.dispatch_args;
+        gr_draw = indirect.draw_args;
+    }
 
     // 1. Reset the alive/sorted/sim-padded counters (dead count + ALIVE_IN snapshot persist) and
     //    seed the frame's spawn budget from the free count.
@@ -406,14 +424,14 @@ export function graph_particles_simulate({
     //    and this pass's rewrite of it on unrelated dependency chains.
     const bucketed = graph_particle_bucket({
         graph,
-        gpu,
         emitter_database,
         pool,
         alive: alive_write,
         counters,
-        sim_list: gr_sim_list,
-        bucket_count,
-        scratch: bucket_scratch,
+        sim_list: gr_sim_list,
+        capacity,
+        bucket_count,
+        scratch: bucket_scratch,
     });
     counters = bucketed.counters;
 
@@ -421,8 +439,8 @@ export function graph_particles_simulate({
     //    rows the tick and the AVBOIT occupancy read. After the bucketing because the dispatch is
     //    the one the coherence reset sized from the GPU's own alive count.
     {
-        const out = graph_particle_bounds({
-            graph,
+        const out = graph_particle_bounds({
+            graph,
             emitter_database,
             pool,
             alive: alive_write,

package/src/shade/renderer/particles/graph_particles_avboit.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAjBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CAoG/E"}
+{"version":3,"file":"graph_particles_avboit.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_avboit.js"],"names":[],"mappings":"AAuCA;;;;;;;;;;;;;;;GAeG;AACH;IARkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACoB,kBAAkB,EAA5C,UAAU,MAAM,CAAC;IACF,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,mBAAmB,EAAlC,MAAM;IACJ,MAAM,CA8ClB;AAED;;;;;;;;;;;;;;;GAeG;AACH;IAZkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,IAAI,EAAnB,MAAM;IACwD,MAAM,EAApE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAC;QAAC,KAAK,EAAE,MAAM,CAAA;KAAC;IAC9B,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAC,CA8EjE;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAjBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IACnB,QAAQ,EAAnE,OAAO,2BAA2B,EAAE,cAAc;IACnC,MAAM,EAArB,MAAM;IACS,aAAa,EAA5B,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,QAAQ,EAAvB,MAAM;IACS,eAAe,EAA9B,MAAM;IACS,oBAAoB,EAAnC,MAAM;IACsE,YAAY,EAAxF;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,QAAQ,EAAE,MAAM,CAAA;KAAC;IAC5C,KAAK;IACT,aAAa;IACjB,IAAI,EAAnB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IACJ;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,UAAU,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAC,CA2G/E"}

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

@@ -6,7 +6,9 @@ import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../rasterize/native/avboit/sha
 import { STATIC_GRAPHICS_ENGINE_ASSETS } from "../STATIC_GRAPHICS_ENGINE_ASSETS.js";
 import { shader_particle_avboit_occupancy } from "./shaders/shader_particle_avboit_occupancy.js";
 import {
-    PARTICLE_AVBOIT_DRAW_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE,
+    PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE,
     PARTICLE_AVBOIT_DRAW_RESOURCES,
 } from "./shaders/shader_particle_avboit_draw.js";
 import {
@@ -268,7 +270,7 @@ export function graph_particle_avboit_draw({
         // allowed because the attachment is read-only.
         const pass_encoder = encoder.constructRenderPass({
             label: "Particle AVBOIT Draw",
-            pipeline: PARTICLE_AVBOIT_DRAW_PIPELINE,
+            pipeline: PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE,
             bindings,
             colorAttachments: [
                 attachment(data.color),
@@ -281,8 +283,15 @@ export function graph_particle_avboit_draw({
                 depthReadOnly: true,
             },
         });
-        pass_encoder.drawIndirect(resources.get(data.draw_args), 0);
-        pass_encoder.end();
+        // All three use the alive list; their vertex stages select disjoint particle groups.
+        // Premultiplied particles can both cover and emit, so they retain the general pipeline.
+        const args = resources.get(data.draw_args);
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.setPipeline(graphics.render_pipelines.obtain(PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE));
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.setPipeline(graphics.render_pipelines.obtain(PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE));
+        pass_encoder.drawIndirect(args, 0);
+        pass_encoder.end();
     }
 
     const pass_data = {};

package/src/shade/renderer/particles/graph_particles_billboard.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_particles_billboard.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_billboard.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;WAhBW,OAAO,2DAA2D,EAAE,UAAU;YAC9E,MAAM;WACN,MAAM;WACN,MAAM;UACN,MAAM;eACN,MAAM;sBACN,MAAM;eACN,MAAM;;;;wCAKS,MAAM,gBAAgB,MAAM,KAAK,MAAM;;IAEpD,MAAM,CAuDlB"}
+{"version":3,"file":"graph_particles_billboard.d.ts","sourceRoot":"","sources":["../../../../../src/shade/renderer/particles/graph_particles_billboard.js"],"names":[],"mappings":"AAkBA;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAhBkG,KAAK,EAA5F,OAAO,2DAA2D,EAAE,UAAU;IAC/D,MAAM,EAArB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,KAAK,EAApB,MAAM;IACS,IAAI,EAAnB,MAAM;IACS,SAAS,EAAxB,MAAM;IACS,gBAAgB,EAA/B,MAAM;IACS,SAAS,EAAxB,MAAM;IAES,MAAM;QACS,KAAK;QACT,aAAa;QAC+B,eAAe,EAArF,CAAC,YAAY,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM,KAAK,MAAM;;IAEpD,MAAM,CAuDlB"}

package/src/shade/renderer/particles/isa/InstructionStream.d.ts

@@ -17,7 +17,7 @@ export class InstructionStream {
      * A source is what its slot's role in the ISA says: for a register-role slot, a register operand
      * word — a slot index, or `vm_register(slot, pattern)` to read it through a swizzle — or a
      * literal from `vm_immediate(value)`; for any other role, the raw value (an attribute offset, a
-     * component count, a builtin id, a curve handle, a pool index). The kinds word 0 carries follow
+     * component count, a builtin id, a pool index). The kinds word 0 carries follow
      * from that, and register operands are stored in their canonical spelling.
      *
      * `width` is the lane count the operation spans. Left out, it is the opcode's natural width —
@@ -123,17 +123,6 @@ export class InstructionStream {
      * @returns {InstructionStream}
      */
     random(dst: number, width?: number): InstructionStream;
-    /**
-     * @param {number} dst
-     * @param {number} curve_handle
-     * @param {number|{kind: number, word: number}} t a register operand word or a literal, read one lane
-     * @param {number} [width]
-     * @returns {InstructionStream}
-     */
-    curve(dst: number, curve_handle: number, t: number | {
-        kind: number;
-        word: number;
-    }, width?: number): InstructionStream;
     /**
      * @returns {InstructionStream}
      */

package/src/shade/renderer/particles/isa/InstructionStream.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"InstructionStream.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/InstructionStream.js"],"names":[],"mappings":"AAkCA;;;;;;GAMG;AACH;IACI,yCAAyC;IACzC,cADW,MAAM,EAAE,EAAE,CACH;IAClB,iEAAiE;IACjE,gBADW,MAAM,CACE;IAsBnB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SARW,MAAM,QACN,MAAM,OACN,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,OACnC,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,OACnC,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,UACnC,MAAM,GACJ,iBAAiB,CA6D7B;IAED;;;;;;OAMG;IACH,iBAHW,UAAU,MAAM,CAAC,GACf,iBAAiB,CAS7B;IAID;;;;;OAKG;IACH,SALW,MAAM,OACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,eALW,MAAM,OACN,MAAM,SACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,eALW,MAAM,kBACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;;OASG;IACH,cANW,MAAM,eACN,MAAM,mBACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;;;;OAQG;IACH,kBALW,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,eACnC,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;OAKG;IACH,iBALW,MAAM,cACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;OAGG;IACH,gBAHW,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GACjC,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;OAMG;IACH,WANW,MAAM,gBACN,MAAM,KACN,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,UACnC,MAAM,GACJ,iBAAiB,CAI7B;IAED;;OAEG;IACH,QAFa,iBAAiB,CAI7B;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,WAFa,WAAW,CAWvB;;CACJ"}
+{"version":3,"file":"InstructionStream.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/InstructionStream.js"],"names":[],"mappings":"AAkCA;;;;;;GAMG;AACH;IACI,yCAAyC;IACzC,cADW,MAAM,EAAE,EAAE,CACH;IAClB,iEAAiE;IACjE,gBADW,MAAM,CACE;IAsBnB;;;;;;;;;;;;;;;;;;;;;OAqBG;IACH,SARW,MAAM,QACN,MAAM,OACN,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,OACnC,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,OACnC,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,UACnC,MAAM,GACJ,iBAAiB,CA6D7B;IAED;;;;;;OAMG;IACH,iBAHW,UAAU,MAAM,CAAC,GACf,iBAAiB,CAS7B;IAID;;;;;OAKG;IACH,SALW,MAAM,OACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,eALW,MAAM,OACN,MAAM,SACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;OAKG;IACH,eALW,MAAM,kBACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;;;;;;;OASG;IACH,cANW,MAAM,eACN,MAAM,mBACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;;;;OAQG;IACH,kBALW,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,eACnC,MAAM,mBACN,MAAM,GACJ,iBAAiB,CAK7B;IAED;;;;;OAKG;IACH,iBALW,MAAM,cACN,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;;OAGG;IACH,gBAHW,MAAM,GAAC;QAAC,IAAI,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,MAAM,CAAA;KAAC,GACjC,iBAAiB,CAI7B;IAED;;;;;;;;OAQG;IACH,YAJW,MAAM,UACN,MAAM,GACJ,iBAAiB,CAI7B;IAED;;OAEG;IACH,QAFa,iBAAiB,CAI7B;IAED;;OAEG;IACH,gCAEC;IAED;;OAEG;IACH,WAFa,WAAW,CAWvB;;CACJ"}

package/src/shade/renderer/particles/isa/InstructionStream.js

@@ -72,7 +72,7 @@ export class InstructionStream {
      * A source is what its slot's role in the ISA says: for a register-role slot, a register operand
      * word — a slot index, or `vm_register(slot, pattern)` to read it through a swizzle — or a
      * literal from `vm_immediate(value)`; for any other role, the raw value (an attribute offset, a
-     * component count, a builtin id, a curve handle, a pool index). The kinds word 0 carries follow
+     * component count, a builtin id, a pool index). The kinds word 0 carries follow
      * from that, and register operands are stored in their canonical spelling.
      *
      * `width` is the lane count the operation spans. Left out, it is the opcode's natural width —
@@ -259,17 +259,6 @@ export class InstructionStream {
         return this.emit(VM_OP.RANDOM, dst, 0, 0, 0, width);
     }
 
-    /**
-     * @param {number} dst
-     * @param {number} curve_handle
-     * @param {number|{kind: number, word: number}} t a register operand word or a literal, read one lane
-     * @param {number} [width]
-     * @returns {InstructionStream}
-     */
-    curve(dst, curve_handle, t, width = undefined) {
-        return this.emit(VM_OP.CURVE, dst, curve_handle, t, 0, width);
-    }
-
     /**
      * @returns {InstructionStream}
      */