@woosh/meep-engine 3.18.0 → 3.20.0

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

@@ -23,7 +23,7 @@
  * A source word means what its kind says — see {@link VM_KIND}:
  *
  * - `NONE`: not an operand the VM resolves — an unused slot, or a raw field the opcode reads for
- *   itself: an attribute offset, a component count, a builtin id, a curve handle, a pool index.
+ *   itself: an attribute offset, a component count, a builtin id, a pool index.
  * - `REG`: a register operand. Bits 0..7 are the first slot, bits 8..15 a swizzle — see below.
  * - `IMM`: the word IS the `f32` bit pattern of a literal, read in every lane. A scalar or a
  *   lane-uniform vector costs no register and no load; only a vector whose lanes differ still goes
@@ -80,8 +80,6 @@ export const VM_OPERAND = {
     COMP: "comp",
     /** builtin id (see {@link VM_BUILTIN}) */
     BUILTIN: "builtin",
-    /** curve handle (row index into the animation-curve table) */
-    CURVE: "curve",
 };
 
 /**
@@ -130,7 +128,8 @@ export const VM_BUILTIN_COMPONENTS = Object.freeze({
 
 /**
  * Opcodes. Numbers are stable wire values — never renumber, only append. 19 was `SCALE` and 45 was
- * `SWIZZLE`; both are spelled by an operand swizzle now and the numbers stay unused.
+ * `SWIZZLE`; both are spelled by an operand swizzle now. 61 was the animation-table sampler.
+ * These numbers stay unused.
  * @enum {number}
  */
 export const VM_OP = {
@@ -185,7 +184,6 @@ export const VM_OP = {
     SELECT: 55,
 
     RANDOM: 60,
-    CURVE: 61,
 };
 
 /**
@@ -559,7 +557,7 @@ const _ = VM_OPERAND.NONE;
  *
  * Keyed by opcode number. Used by the assembler for validation/disassembly and by the parity
  * meta-test to enforce that every opcode is handled by both executors.
- * @type {Map<number, {name: string, dst: boolean, operands: [string, string, string], width: string, dest: string, default_width: number, min_width: number, scalar_operands: number[]}>}
+ * @type {Map<number, {name: string, dst: boolean, operands: [string, string, string], width: string, dest: string, default_width: number, min_width: number}>}
  */
 export const VM_ISA = new Map();
 
@@ -575,7 +573,6 @@ export const VM_ISA = new Map();
  * @param {string} [options.dest] see {@link VM_DEST}; as wide as the operation unless it reduces
  * @param {number} [options.default_width] width the assembler uses when the text does not say
  * @param {number} [options.min_width] narrowest the opcode is meaningful at
- * @param {number[]} [options.scalar_operands] source slots read as a single lane whatever the width
  */
 function def(op, name, dst, s0 = _, s1 = _, s2 = _, options = {}) {
     if (VM_ISA.has(op)) {
@@ -603,7 +600,6 @@ function def(op, name, dst, s0 = _, s1 = _, s2 = _, options = {}) {
         dest,
         default_width,
         min_width: options.min_width ?? 1,
-        scalar_operands: options.scalar_operands ?? [],
     });
 }
 
@@ -669,8 +665,6 @@ def(VM_OP.SELECT, "SELECT", true, R, R, R);
 // One independent uniform draw in `[0, 1)` per lane, and nothing else: a shaped distribution is
 // arithmetic a program writes over this draw — see ../graph/particle_graph_distributions.js.
 def(VM_OP.RANDOM, "RANDOM", true);
-// `t` is one lane; the sampled value fills the destination's width.
-def(VM_OP.CURVE, "CURVE", true, VM_OPERAND.CURVE, R, _, { scalar_operands: [1] });
 
 // --- packing an instruction ---------------------------------------------------------------------
 
@@ -699,7 +693,7 @@ export function vm_pack_instruction(op, width, dst, kinds, sources) {
         const word = sources[slot] >>> 0;
 
         words[1 + slot] = kinds[slot] === VM_KIND.REG && meta !== undefined
-            ? vm_canonical_register(word, meta.scalar_operands.includes(slot) ? 1 : operation_width)
+            ? vm_canonical_register(word, operation_width)
             : word;
     }
 
@@ -731,8 +725,7 @@ export function vm_repack_instruction(words) {
  * @property {number} slot source slot, `0..2`
  * @property {number} kind a {@link VM_KIND}, never `NONE`
  * @property {number} word the source word as encoded
- * @property {number} lanes how many lanes the instruction reads of it: the operation's width, or one
- *   for a slot the ISA marks scalar
+ * @property {number} lanes how many lanes the instruction reads of it: the operation's width
  * @property {number} span register slots the operand reaches from its base, for a register; `0` for a
  *   literal
  */
@@ -741,9 +734,8 @@ export function vm_repack_instruction(words) {
  * Visit every source operand of an instruction — every slot whose kind is not `NONE` — with how
  * many lanes the opcode reads of it and how far into the file it reaches.
  *
- * The rules for the reach are not uniform and live here rather than in each caller: a source is
- * read as wide as the operation runs unless the ISA marks that slot scalar, and a register operand
- * reaches as far as its widest selector among the lanes read.
+ * A source is read as wide as the operation runs, and a register operand reaches as far as its
+ * widest selector among the lanes read.
  *
  * @param {ArrayLike<number>} words an instruction stream
  * @param {number} base index of the instruction's first word
@@ -770,7 +762,7 @@ export function vm_visit_operands(words, base, visit) {
         }
 
         const word = words[base + 1 + slot];
-        const lanes = meta.scalar_operands.includes(slot) ? 1 : operation_width;
+        const lanes = operation_width;
 
         operand.slot = slot;
         operand.kind = kind;

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

@@ -99,7 +99,6 @@ export function assemble_particle_program(text: string): ParticleProgram;
  * | attribute word offset | `@<word>` | `@7` |
  * | attribute component count | a bare integer `1..4` | `3` |
  * | builtin | a {@link VM_BUILTIN} name | `EMITTER_POSITION` |
- * | curve handle | `k<handle>` | `k2` |
  *
  * A register source's selectors say which lane of the value each lane of the instruction reads, one
  * letter of `xyzw` per lane the instruction spans; left off, lane `c` reads lane `c`. A literal is

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

@@ -1 +1 @@
-{"version":3,"file":"particle_assembly.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/particle_assembly.js"],"names":[],"mappings":"AA0KA;;;;;;;;GAQG;AAMH;;;;;;;;;;;GAWG;AACH,sDALW,eAAe;IAEE,MAAM,GAAvB,MAAM;IACJ,MAAM,CAmClB;AA0JD;;;;;;;;;;;GAWG;AACH,8CAHW,MAAM;aACM,eAAe,GAAC,IAAI;iBAAe,0BAA0B,EAAE;EA8IrF;AAED;;;;;;;;GAQG;AACH,gDAJW,MAAM,GACJ,eAAe,CAkB3B;AAjhBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8DG;AAEH,oEAAoE;AACpE,6CAD0D,MAAM,CACV;AAEtD,sEAAsE;AACtE,+CAD4D,MAAM,CACR;AAE1D,+DAA+D;AAC/D,oDADqD,MAAM,CACO;AAElE,kEAAkE;AAClE,gDADwD,MAAM,CACJ;AAE1D,iEAAiE;AACjE,iDADuD,MAAM,CACP;AAEtD;;;;;GAKG;AACH,gDAFU,MAAM,CAEqC;AAErD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEoC;;;;;;;;;;UA+CtC,MAAM;aACN,MAAM;;;;;;UA+hBN,MAAM;;;;UACN,MAAM;;;;gBACN,MAAM;;;;YACN,MAAM;;gCA7sBY,sBAAsB"}
+{"version":3,"file":"particle_assembly.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/isa/particle_assembly.js"],"names":[],"mappings":"AAyKA;;;;;;;;GAQG;AAMH;;;;;;;;;;;GAWG;AACH,sDALW,eAAe;IAEE,MAAM,GAAvB,MAAM;IACJ,MAAM,CAmClB;AAwJD;;;;;;;;;;;GAWG;AACH,8CAHW,MAAM;aACM,eAAe,GAAC,IAAI;iBAAe,0BAA0B,EAAE;EA8IrF;AAED;;;;;;;;GAQG;AACH,gDAJW,MAAM,GACJ,eAAe,CAkB3B;AA9gBD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6DG;AAEH,oEAAoE;AACpE,6CAD0D,MAAM,CACV;AAEtD,sEAAsE;AACtE,+CAD4D,MAAM,CACR;AAE1D,+DAA+D;AAC/D,oDADqD,MAAM,CACO;AAElE,kEAAkE;AAClE,gDADwD,MAAM,CACJ;AAE1D,iEAAiE;AACjE,iDADuD,MAAM,CACP;AAEtD;;;;;GAKG;AACH,gDAFU,MAAM,CAEqC;AAErD;;;;;;;;;GASG;AACH,8CAFU,MAAM,CAEoC;;;;;;;;;;UA+CtC,MAAM;aACN,MAAM;;;;;;UA6hBN,MAAM;;;;UACN,MAAM;;;;gBACN,MAAM;;;;YACN,MAAM;;gCA1sBY,sBAAsB"}

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

@@ -81,7 +81,6 @@ import {
  * | attribute word offset | `@<word>` | `@7` |
  * | attribute component count | a bare integer `1..4` | `3` |
  * | builtin | a {@link VM_BUILTIN} name | `EMITTER_POSITION` |
- * | curve handle | `k<handle>` | `k2` |
  *
  * A register source's selectors say which lane of the value each lane of the instruction reads, one
  * letter of `xyzw` per lane the instruction spans; left off, lane `c` reads lane `c`. A literal is
@@ -268,7 +267,7 @@ function disassemble_instruction(words, base) {
         } else if (vm_decode_kind(word0, slot) === VM_KIND.IMM) {
             operands.push(`${PARTICLE_ASSEMBLY_IMMEDIATE_PREFIX}${format_float(vm_f32_value(word))}`);
         } else {
-            operands.push(format_register(word, meta.scalar_operands.includes(slot) ? 1 : operation_width));
+            operands.push(format_register(word, operation_width));
         }
     }
 
@@ -337,8 +336,6 @@ function format_operand(role, value) {
             return String(value);
         case VM_OPERAND.BUILTIN:
             return BUILTIN_NAME_BY_ID.get(value) ?? String(value);
-        case VM_OPERAND.CURVE:
-            return `k${value}`;
         default:
             return String(value);
     }
@@ -809,7 +806,7 @@ function parse_instruction(line, line_number, report) {
 
     for (let slot = 0; slot < sources.length; slot++) {
         const source = sources[slot];
-        const lanes = meta.scalar_operands.includes(slot) ? 1 : operation_width;
+        const lanes = operation_width;
 
         if (source.kind === VM_KIND.REG && source.selectors !== undefined && source.selectors > 0 && source.selectors !== lanes) {
             report(
@@ -1090,17 +1087,6 @@ function parse_plain_operand(role, token, line_number, report) {
             return id === null ? null : { kind: VM_KIND.NONE, word: id };
         }
 
-        case VM_OPERAND.CURVE: {
-            const handle = parse_prefixed(token, "k");
-
-            if (handle === null) {
-                report(line_number, `Expected a curve handle like 'k0', got '${token}'`);
-                return null;
-            }
-
-            return { kind: VM_KIND.NONE, word: handle };
-        }
-
         default:
             report(line_number, `Unsupported operand role '${role}'`);
             return null;

package/src/shade/renderer/particles/optimizer/dag/particle_vector_graph.d.ts

@@ -124,7 +124,7 @@ export type ParticleVectorNode = {
      */
     patterns: number[];
     /**
-     * static fields: literal bits, a record word, a builtin id, a curve handle,
+     * static fields: literal bits, a record word, a builtin id,
      * the first draw of a `RANDOM`
      */
     imm: number[];

package/src/shade/renderer/particles/optimizer/dag/particle_vector_graph.js

@@ -66,7 +66,7 @@ export const PV = {
  * @property {number[]} children the values its sources read, one per source
  * @property {number[]} patterns per source, the swizzle it reads that value through — or, for
  *   `BUILD`, the single lane it takes
- * @property {number[]} imm static fields: literal bits, a record word, a builtin id, a curve handle,
+ * @property {number[]} imm static fields: literal bits, a record word, a builtin id,
  *   the first draw of a `RANDOM`
  */
 

package/src/shade/renderer/particles/optimizer/dag/particle_vector_lift.js

@@ -383,20 +383,6 @@ function evaluate(graph, instruction, operands, state) {
             return lanes_of(graph, value, dest);
         }
 
-        // Every lane is the same sample, so one lane holds it and a consumer reading it wide reads a
-        // broadcast.
-        case VM_OP.CURVE: {
-            const value = graph.make({
-                op,
-                width: 1,
-                children: [source(1).value],
-                patterns: [source(1).pattern],
-                imm: [words[1]],
-            });
-
-            return Array.from({ length: dest }, () => ({ value, lane: 0 }));
-        }
-
         default: {
             if (semantics.side_effects) {
                 return null;

package/src/shade/renderer/particles/optimizer/dag/particle_vector_pack.js

@@ -204,10 +204,10 @@ export function pack_particle_vectors(graph, section, extraction) {
 
         for (let source = 0; source < node.children.length; source++) {
             group.operands.push(operand(
-                slot_of(node, source),
+                source,
                 node.children[source],
                 node.patterns[source],
-                node.op === VM_OP.CURVE ? 1 : group.width,
+                group.width,
                 sequence
             ));
         }
@@ -695,7 +695,6 @@ export function chunk_stores(stores) {
 function raw_fields(node) {
     switch (node.op) {
         case VM_OP.LOAD_BUILTIN:
-        case VM_OP.CURVE:
             return [node.imm[0], -1, -1];
 
         default:
@@ -703,17 +702,6 @@ function raw_fields(node) {
     }
 }
 
-/**
- * @param {import("./particle_vector_graph.js").ParticleVectorNode} node
- * @param {number} source which of the node's sources
- * @returns {number} the instruction source slot it goes in
- */
-function slot_of(node, source) {
-    // `CURVE` takes its handle in slot 0 and the value it samples in slot 1; everything else fills
-    // its slots in order.
-    return node.op === VM_OP.CURVE ? source + 1 : source;
-}
-
 /**
  * How many lanes of each value anything actually reads.
  *
@@ -772,9 +760,7 @@ function measure_demand(graph, section, extraction) {
             continue;
         }
 
-        const reads = node.op === VM_OP.CURVE
-            ? 1
-            : Math.max(narrowable(node) ? width : node.operand_width, VM_ISA.get(node.op)?.min_width ?? 1);
+        const reads = Math.max(narrowable(node) ? width : node.operand_width, VM_ISA.get(node.op)?.min_width ?? 1);
 
         for (let source = 0; source < node.children.length; source++) {
             let highest = 0;

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

@@ -1 +1 @@
-{"version":3,"file":"particle_program_analysis.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_analysis.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AACH,mDAJW,UAAU,MAAM,CAAC,UACjB,MAAM,GACJ,0BAA0B,CAiDtC;AAED;;;GAGG;AACH,2DAHW,UAAU,UAAU,MAAM,CAAC,CAAC,GAC1B,0BAA0B,EAAE,CAUxC;AAED;;;;;;;GAOG;AACH,0CAJW,kBAAkB,UAClB,MAAM,GACJ,MAAM,EAAE,CAUpB;AAED;;;;;;;;;;;GAWG;AACH,2DAHW,UAAU,MAAM,CAAC,GACf,OAAO,CAiBnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,sDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,QAAQ,CAyDpB;AAED;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,gDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,oBAAoB,CA6EhC;AAED;;;;;;;;;;;GAWG;AACH,kDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,MAAM,CAmClB;AAeD;;;;;;GAMG;AACH,8CANW,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;;;;;;;GAaG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAmBnB;AAED;;;;;;;;;;GAUG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAanB;AAED;;;;;;;;;;;GAWG;AACH,oDANW,0BAA0B,EAAE,SAC5B,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAiCnB;AAED;;;;;;;;;;;;;GAaG;AACH;IACI;;OAEG;IACH,oBAFW,MAAM,EAsBhB;IAnBG,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,gDAAgD;IAChD,UADW,UAAU,CACgB;IACrC,mEAAmE;IACnE,MADW,UAAU,CACY;IACjC,kGAAkG;IAClG,UADW,UAAU,CACyB;IAC9C,qBAAqB;IACrB,SADW,MAAM,CACG;IACpB,sEAAsE;IACtE,WADW,MAAM,CACC;IAUtB;;;;OAIG;IACH,aAJW,MAAM,QACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CAczB;IAED;;;;;OAKG;IACH,eAHW,kBAAkB,GAChB,MAAM,EAAE,GAAC,IAAI,CAUzB;IAED;;;;OAIG;IACH,YAJW,MAAM,OACN,MAAM,EAAE,GACN,OAAO,CAcnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,qBAJW,kBAAkB,GAChB,MAAM,CAiDlB;IAED;;;;;;;;OAQG;IACH,eAFW,UAAU,MAAM,CAAC,QAgD3B;CACJ;;;;;aArsBa,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;;aACN,MAAM;;;;;WAEN,MAAM;;;;UAEN,MAAM;;;;;;WAKN,MAAM;;;;WACN,MAAM,EAAE;QACR,MAAM;;;;WACN,MAAM;;;;SACN,MAAM;;;;WACN,MAAM;;;;qBACN,MAAM;;;;UACN,MAAM;eACN,OAAO,4BAA4B,EAAE,mBAAmB;;;;WACxD,kBAAkB,GAAC,IAAI;;;;WACvB,kBAAkB,EAAE;;;;aACpB,kBAAkB,EAAE;;;;;;;UAoMpB,UAAU;;;;;WAEV,UAAU;;;;gBAEV,UAAU;;;;gBACV,MAAM;;yBAvRK,wCAAwC"}
+{"version":3,"file":"particle_program_analysis.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_analysis.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;;;;;;;;;;GA0BG;AAEH;;;;;;;;;;;GAWG;AAEH;;;;;;;;;;;;;;GAcG;AAEH;;;;;;GAMG;AACH,mDAJW,UAAU,MAAM,CAAC,UACjB,MAAM,GACJ,0BAA0B,CAiDtC;AAED;;;GAGG;AACH,2DAHW,UAAU,UAAU,MAAM,CAAC,CAAC,GAC1B,0BAA0B,EAAE,CAUxC;AAED;;;;;;;GAOG;AACH,0CAJW,kBAAkB,UAClB,MAAM,GACJ,MAAM,EAAE,CAUpB;AAED;;;;;;;;;;;GAWG;AACH,2DAHW,UAAU,MAAM,CAAC,GACf,OAAO,CAiBnB;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,sDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,QAAQ,CAyDpB;AAED;;;;;;;;GAQG;AAEH;;;;;;;;;;;;;;;GAeG;AACH,gDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,oBAAoB,CA6EhC;AAED;;;;;;;;;;;GAWG;AACH,kDAJW,0BAA0B,EAAE,mBAC5B,MAAM,GACJ,MAAM,CAmClB;AAED;;;;;;GAMG;AACH,8CANW,MAAM,UACN,MAAM,UACN,MAAM,UACN,MAAM,GACJ,OAAO,CAInB;AAED;;;;;;;;;;;;;GAaG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAmBnB;AAED;;;;;;;;;;GAUG;AACH,yDAPW,0BAA0B,EAAE,QAC5B,MAAM,MACN,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAanB;AAED;;;;;;;;;;;GAWG;AACH,oDANW,0BAA0B,EAAE,SAC5B,MAAM,QACN,MAAM,QACN,MAAM,GACJ,OAAO,CAiCnB;AAED;;;;;;;;;;;;;GAaG;AACH;IACI;;OAEG;IACH,oBAFW,MAAM,EAsBhB;IAnBG,qBAAqB;IACrB,OADW,MAAM,CACC;IAClB,gDAAgD;IAChD,UADW,UAAU,CACgB;IACrC,mEAAmE;IACnE,MADW,UAAU,CACY;IACjC,kGAAkG;IAClG,UADW,UAAU,CACyB;IAC9C,qBAAqB;IACrB,SADW,MAAM,CACG;IACpB,sEAAsE;IACtE,WADW,MAAM,CACC;IAUtB;;;;OAIG;IACH,aAJW,MAAM,QACN,MAAM,GACJ,MAAM,EAAE,GAAC,IAAI,CAczB;IAED;;;;;OAKG;IACH,eAHW,kBAAkB,GAChB,MAAM,EAAE,GAAC,IAAI,CAUzB;IAED;;;;OAIG;IACH,YAJW,MAAM,OACN,MAAM,EAAE,GACN,OAAO,CAcnB;IAED;;;;;;;;;;;;;;;;OAgBG;IACH,qBAJW,kBAAkB,GAChB,MAAM,CAiDlB;IAED;;;;;;;;OAQG;IACH,eAFW,UAAU,MAAM,CAAC,QAwC3B;CACJ;;;;;aAhrBa,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;UACN,MAAM;;;;;aACN,MAAM;;;;;WAEN,MAAM;;;;UAEN,MAAM;;;;;;WAKN,MAAM;;;;WACN,MAAM,EAAE;QACR,MAAM;;;;WACN,MAAM;;;;SACN,MAAM;;;;WACN,MAAM;;;;qBACN,MAAM;;;;UACN,MAAM;eACN,OAAO,4BAA4B,EAAE,mBAAmB;;;;WACxD,kBAAkB,GAAC,IAAI;;;;WACvB,kBAAkB,EAAE;;;;aACpB,kBAAkB,EAAE;;;;;;;UAoMpB,UAAU;;;;;WAEV,UAAU;;;;gBAEV,UAAU;;;;gBACV,MAAM;;yBAvRK,wCAAwC"}

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

@@ -362,7 +362,7 @@ export function analyze_particle_lanes(decoded, register_slots = PARTICLE_VM_REG
         }
 
         for (const read of instruction.reads) {
-            for (const slot of particle_read_slots(read, particle_lanes_read_at(instruction, read, operation_width))) {
+            for (const slot of particle_read_slots(read, operation_width)) {
                 if (slot < register_slots) {
                     live[slot] = 1;
                 }
@@ -420,19 +420,6 @@ export function particle_peak_live_slots(decoded, register_slots = PARTICLE_VM_R
     return peak;
 }
 
-/**
- * How many lanes of a source an instruction reads once it is narrowed to `operation_width`: one for a
- * slot the ISA marks scalar, the width for everything else.
- *
- * @param {ParticleDecodedInstruction} instruction
- * @param {ParticleOperandRun} read
- * @param {number} operation_width
- * @returns {number}
- */
-function particle_lanes_read_at(instruction, read, operation_width) {
-    return instruction.meta.scalar_operands.includes(read.operand) ? 1 : operation_width;
-}
-
 /**
  * @param {number} base_a
  * @param {number} span_a
@@ -728,28 +715,20 @@ export class ParticleValueNumbering {
         /** Gathered before anything is written: a source may alias the destination. */
         const lanes = new Array(span);
 
-        if (instruction.semantics.broadcasts) {
-            // One value in every lane, so lane `i` is a copy of lane 0 and traces back to it — which
-            // is what lets a consumer read the scalar instead of the widened form.
-            const id = this.next_id++;
-
-            lanes.fill({ id, home: base, producer: publish });
-        } else {
-            // A copy carries values only from a REGISTER source. A literal is a value the file never
-            // held, so a MOV from one mints — and its word is not the slot it would otherwise be
-            // read as.
-            const source = instruction.op === VM_OP.MOV && instruction.sources[0].kind === VM_KIND.REG
-                ? instruction.sources[0]
-                : null;
-
-            for (let lane = 0; lane < span; lane++) {
-                const from = source === null ? -1 : vm_operand_slot(source.word, lane);
-
-                lanes[lane] = from >= 0 && from < this.slots
-                    ? { id: this.value_id[from], home: this.home[from], producer: this.producer[from] }
-                    : { id: this.next_id++, home: base + lane, producer: publish };
-            }
-        }
+        // A copy carries values only from a REGISTER source. A literal is a value the file never
+        // held, so a MOV from one mints — and its word is not the slot it would otherwise be
+        // read as.
+        const source = instruction.op === VM_OP.MOV && instruction.sources[0].kind === VM_KIND.REG
+            ? instruction.sources[0]
+            : null;
+
+        for (let lane = 0; lane < span; lane++) {
+            const from = source === null ? -1 : vm_operand_slot(source.word, lane);
+
+            lanes[lane] = from >= 0 && from < this.slots
+                ? { id: this.value_id[from], home: this.home[from], producer: this.producer[from] }
+                : { id: this.next_id++, home: base + lane, producer: publish };
+        }
 
         for (let lane = 0; lane < span; lane++) {
             const slot = base + lane;

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

@@ -1 +1 @@
-{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AA8GA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;;YACM,WAAW;YAAU,OAAO;eAAa,MAAM;EAgBrE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW;YACA,UAAU;YAAU,OAAO;EAkEhD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,qDAVW;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,SACzD;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;IAErC,SAAS,GAA7B,MAAM;IACkD,KAAK,GAA7D;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI;IAIxC,MAAM,GAAC,IAAI,CAuCvB;AAED;;;;;;;;;;;;;;GAcG;AACH;IARkG,MAAM,EAA7F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACS,KAAK,EAA5F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACvD,YAAY,GAAnC,MAAM,MAAM,CAAC;IACG,UAAU,GAA1B,MAAM;IAGJ,MAAM,GAAC,IAAI,CAqBvB;AAED;;;;;;;GAOG;AACH,qGAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB;AAtRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,MAAM,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAA;CAAC,CAAC,CAOjG"}
+{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AA2GA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;;YACM,WAAW;YAAU,OAAO;eAAa,MAAM;EAerE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW;YACA,UAAU;YAAU,OAAO;EAkEhD;AAqCD;;;;;;;;;;;;;;GAcG;AACH,qDAVW;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC,SACzD;IAAC,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAC;IAErC,SAAS,GAA7B,MAAM;IACkD,KAAK,GAA7D;QAAC,MAAM,EAAE,UAAU,CAAC;QAAC,MAAM,EAAE,OAAO,CAAA;KAAC,GAAC,IAAI;IAIxC,MAAM,GAAC,IAAI,CAuCvB;AAED;;;;;;;;;;;;;;GAcG;AACH;IARkG,MAAM,EAA7F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACS,KAAK,EAA5F;QAAC,KAAK,EAAE,WAAW,CAAC;QAAC,SAAS,EAAE,YAAY,GAAC,MAAM,EAAE,CAAC;QAAC,cAAc,EAAE,MAAM,CAAA;KAAC;IACvD,YAAY,GAAnC,MAAM,MAAM,CAAC;IACG,UAAU,GAA1B,MAAM;IAGJ,MAAM,GAAC,IAAI,CAqBvB;AAED;;;;;;;GAOG;AACH,qGAHW,MAAM,GACJ,MAAM,GAAC,IAAI,CAmBvB;AArRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,MAAM,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAA;CAAC,CAAC,CAOjG"}

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

@@ -56,7 +56,7 @@ import { PARTICLE_ZERO_ABSORBING_OPS } from "./pass_fold_constants.js";
  *
  * ## Environments
  *
- * A program reads more than its constants — record words, builtins, the RNG, curve samples — and a
+ * A program reads more than its constants — record words, builtins, the RNG — and a
  * pass that mishandled any of those could still agree on a single run. {@link PARTICLE_ENVIRONMENTS}
  * varies all of them, including a record pre-filled with values a `LOAD_ATTR` can pick up.
  */
@@ -92,9 +92,6 @@ function seeded_record() {
     return record;
 }
 
-/** @param {number} handle @param {number} t @returns {number} */
-const sample_curve = (handle, t) => Math.sin(handle + t * 3) * 0.5 + handle * 0.125;
-
 /**
  * The contexts a program is compared in. Seeds differ so a pass that dropped or added a draw shows
  * up as a diverging RNG state rather than only as a diverging record.
@@ -128,7 +125,6 @@ export function run_particle_section({ words, constants, register_count, environ
         record,
         builtins: environment.builtins,
         rng_state: environment.rng_state,
-        sampleCurve: sample_curve,
     });
 
     return { record, killed: result.killed, rng_state: result.rng_state };

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

@@ -1 +1 @@
-{"version":3,"file":"particle_program_fuzz.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_fuzz.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;GAaG;AACH,oDAXuB,MAAM;IAED,WAAW,GAA5B,MAAM;IACY,IAAI,GAAtB,OAAO;IACW,MAAM,GAAxB,OAAO;IACU,cAAc,GAA/B,MAAM;oBAqHhB;AA8ED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yDALuB,MAAM;IAED,MAAM,GAAvB,MAAM;oBAmEhB"}
+{"version":3,"file":"particle_program_fuzz.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_fuzz.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;GAaG;AACH,oDAXuB,MAAM;IAED,WAAW,GAA5B,MAAM;IACY,IAAI,GAAtB,OAAO;IACW,MAAM,GAAxB,OAAO;IACU,cAAc,GAA/B,MAAM;oBAqHhB;AAuED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yDALuB,MAAM;IAED,MAAM,GAAvB,MAAM;oBAmEhB"}

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/ParticleEmitter.d.ts

@@ -24,6 +24,13 @@ export const EMITTER_RENDER_CHANNEL_COMPONENTS: {
 /**
  * One particle emitter: a scene node that runs a compiled effect.
  *
+ * **In a game, this is built for you.** An entity carrying
+ * {@link ../../../../engine/graphics/ecs/particles/ParticleEffect.js ParticleEffect} and a
+ * `Transform64` gets one of these from `engine/graphics3/GPUParticleEmitterSystem.js`, which owns it
+ * and keeps every field below in step with the component. Build one by hand for the cases with no
+ * ECS behind them — a playground, a tool, a spec — or reach for the one the system built through its
+ * `node_of(entity)` when an entity reference cannot say what you mean.
+ *
  * Being a {@link Node3D} is what places it. Add it to a scene and it gets a row in the scene
  * database's `transforms` table like any other node; parent it to a joint and the GPU hierarchy
  * pass composes its world matrix from the joint's every frame, animation included, with nothing
@@ -117,10 +124,10 @@ export class ParticleEmitter extends Node3D {
      * Image to draw the particles with, by URL, or `null` to draw against the default atlas — a
      * single white texel, so an untextured emitter is a flat quad of its colour.
      *
-     * The ECS GPUParticleEmitterSystem loads this URL through AssetManager and packs the image
-     * into a shared sheet. Standalone callers provide their own atlas and regions. Where
-     * a given image lands in that sheet is the system's answer, not the author's — it changes on
-     * every repack, without the emitter changing. The resolved patch is
+     * `engine/graphics3/GPUParticleEmitterSystem.js` loads this URL through AssetManager and packs
+     * the image into a sheet its scene shares. Standalone callers provide their own atlas and
+     * regions. Where a given image lands in that sheet is the system's answer, not the author's — it
+     * changes on every repack, without the emitter changing. The resolved patch is
      * {@link ./GPUParticleEmitterContext.js#atlas_region}.
      *
      * @type {string|null}

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

@@ -1 +1 @@
-{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ParticleEmitter.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,sCAFU,MAAM,EAAE,CAIf;AAEH;;;;;;;;;;;;GAYG;AACH;QAFiB,MAAM,GAAE,MAAM;EAS5B;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAsCG;AACH;IA0QI;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH;QAfwE,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;QAEQ,OAAO,EAAnE,OAAO,2BAA2B,EAAE,eAAe;QAExB,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACI,OAAO,GAA5B,MAAM,GAAC,IAAI;QACK,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACU,OAAO,GAAvB,MAAM;QACU,KAAK,GAArB,MAAM;QACyB,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACO,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACD,IAAI,GAApB,MAAM;QACJ,eAAe,CAgD3B;IA7UD;;;;;OAKG;IACH,QAFU,OAAO,6BAA6B,EAAE,cAAc,CAEvD;IAEP;;;;;OAKG;IACH,SAFU,OAAO,2BAA2B,EAAE,eAAe,CAErD;IAER;;;;;;;;;;;OAWG;IACH,SAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;;;;;;;OAQG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,UAFU,YAAY,CAEc;IAEpC,+FAA+F;IAC/F,iBADW,MAAM,CAC0B;IAC3C,gDAAgD;IAChD,aADW,MAAM,CACsB;IACvC,uDAAuD;IACvD,cADW,MAAM,CACuB;IACxC,+DAA+D;IAC/D,iBADW,MAAM,CAC0B;IAC3C,gEAAgE;IAChE,cADW,MAAM,CACuB;IACxC,sFAAsF;IACtF,iBADW,MAAM,CAC0B;IAE3C,mBAEC;IAED;;;;;;;;;;;;OAYG;IACH;YAHkB,MAAM,GAAC,MAAM;aA2B9B;IAED;;;;;;;;;;;;OAYG;IACH,cAHW,eAAe,GACb,OAAO,CAuBnB;IAED;;;;;;OAMG;IACH,QAFa,MAAM,CAsBlB;IAED;;;;;;;;;;;;OAYG;IACH,YAFW,eAAe,QAwBzB;IAED;;;;;;OAMG;IACH,SAFa,eAAe,CAgB3B;IA0EL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;uBA1ZsB,uBAAuB"}
+{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ParticleEmitter.js"],"names":[],"mappings":"AAUA;;;;;GAKG;AACH,sCAFU,MAAM,EAAE,CAIf;AAEH;;;;;;;;;;;;GAYG;AACH;QAFiB,MAAM,GAAE,MAAM;EAS5B;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA6CG;AACH;IA0QI;;;;;;;;;;;;;;;;;;;;;;OAsBG;IACH;QAfwE,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;QAEQ,OAAO,EAAnE,OAAO,2BAA2B,EAAE,eAAe;QAExB,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACI,OAAO,GAA5B,MAAM,GAAC,IAAI;QACK,IAAI,GAApB,MAAM;QACU,UAAU,GAA1B,MAAM;QACU,OAAO,GAAvB,MAAM;QACU,KAAK,GAArB,MAAM;QACyB,MAAM;gBAA9B,MAAM,GAAC,MAAM;;QACO,QAAQ,GAAnC,UAAU,MAAM,CAAC;QACD,IAAI,GAApB,MAAM;QACJ,eAAe,CAgD3B;IA7UD;;;;;OAKG;IACH,QAFU,OAAO,6BAA6B,EAAE,cAAc,CAEvD;IAEP;;;;;OAKG;IACH,SAFU,OAAO,2BAA2B,EAAE,eAAe,CAErD;IAER;;;;;;;;;;;OAWG;IACH,SAFU,MAAM,GAAC,IAAI,CAEN;IAEf;;;;;;;;OAQG;IACH,MAFU,MAAM,CAEP;IAET;;;;OAIG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;;;;;;;;;OAmBG;IACH,SAFU,MAAM,CAEJ;IAEZ;;;OAGG;IACH,OAFU,MAAM,CAEN;IAEV;;;;OAIG;IACH,UAFU,YAAY,CAEc;IAEpC,+FAA+F;IAC/F,iBADW,MAAM,CAC0B;IAC3C,gDAAgD;IAChD,aADW,MAAM,CACsB;IACvC,uDAAuD;IACvD,cADW,MAAM,CACuB;IACxC,+DAA+D;IAC/D,iBADW,MAAM,CAC0B;IAC3C,gEAAgE;IAChE,cADW,MAAM,CACuB;IACxC,sFAAsF;IACtF,iBADW,MAAM,CAC0B;IAE3C,mBAEC;IAED;;;;;;;;;;;;OAYG;IACH;YAHkB,MAAM,GAAC,MAAM;aA2B9B;IAED;;;;;;;;;;;;OAYG;IACH,cAHW,eAAe,GACb,OAAO,CAuBnB;IAED;;;;;;OAMG;IACH,QAFa,MAAM,CAsBlB;IAED;;;;;;;;;;;;OAYG;IACH,YAFW,eAAe,QAwBzB;IAED;;;;;;OAMG;IACH,SAFa,eAAe,CAgB3B;IA0EL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;CAN1C;uBAjasB,uBAAuB"}