@woosh/meep-engine 3.58.0 → 3.59.0

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

@@ -34,7 +34,7 @@ export function particle_integer_bound_of_value(value: number): number;
  * The facts come from the shapes effects are actually made of. A comparison or a `step` is 0 or 1;
  * a mask built from one, `cmp * 2 - 1`, is -1 or 1; a literal is whatever it is. Those flow through
  * copies, negation, `abs`, `floor`, `min`, `max`, `clamp` and `select` unchanged in kind, and
- * through the arithmetic with their bounds combined. Everything else — a draw, an attribute, a
+ * through the arithmetic with their bounds combined. Everything else — a draw, a particle field, a
  * builtin, `fract`, a division, a transcendental — is unknown. So is any value whose bound would
  * pass 2^24: above it an integer may no longer be representable, and once a rounding could have
  * happened nothing downstream is exact any more.

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

@@ -16,7 +16,7 @@ import { decode_particle_instruction, particle_read_slots } from "./particle_pro
  * The facts come from the shapes effects are actually made of. A comparison or a `step` is 0 or 1;
  * a mask built from one, `cmp * 2 - 1`, is -1 or 1; a literal is whatever it is. Those flow through
  * copies, negation, `abs`, `floor`, `min`, `max`, `clamp` and `select` unchanged in kind, and
- * through the arithmetic with their bounds combined. Everything else — a draw, an attribute, a
+ * through the arithmetic with their bounds combined. Everything else — a draw, a particle field, a
  * builtin, `fract`, a division, a transcendental — is unknown. So is any value whose bound would
  * pass 2^24: above it an integer may no longer be representable, and once a rounding could have
  * happened nothing downstream is exact any more.

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

@@ -29,10 +29,10 @@ export function run_particle_section({ words, constants, register_count, environ
  * to the rewrite is an opcode this follows. Everything the marked slots flow into is marked too, and a
  * store carries the mark into the record word it writes.
  *
- * A `LOAD_ATTR` of a marked record word marks its destination back, so a value that went out through
- * the record and came back in is still followed. Slots are cleared by a write whose sources are all
- * unmarked — the value there is then the same in both programs — while record words are only ever
- * added to, because a store cannot un-write what an earlier one already made unequal.
+ * A `LOAD_PARTICLE_FIELD` of a marked record word marks its destination back, so a value that went
+ * out through the record and came back in is still followed. Slots are cleared by a write whose
+ * sources are all unmarked — the value there is then the same in both programs — while record words
+ * are only ever added to, because a store cannot un-write what an earlier one already made unequal.
  *
  * Static, so it over-approximates the runs: a lane that never actually held a substituted zero is
  * marked anyway. That is the right direction to be wrong in, and it is not blunt in practice — see

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":"AAgIA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;IACJ;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAgBvE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW,GACT;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,CAkEjD;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,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAC;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,qBAAqB,CAAA;CAAC,CAAC,CAO5K"}
+{"version":3,"file":"particle_program_equivalence.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_equivalence.js"],"names":[],"mappings":"AAiIA;;;;;;;;;GASG;AACH;IAN+B,KAAK,EAAzB,WAAW;IACmB,SAAS,EAAvC,YAAY,GAAC,MAAM,EAAE;IACN,cAAc,EAA7B,MAAM;IACS,WAAW,EAA1B,MAAM;IACJ;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAgBvE;AAED;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,+CAHW,WAAW,GACT;IAAC,MAAM,EAAE,UAAU,CAAC;IAAC,MAAM,EAAE,OAAO,CAAA;CAAC,CAmEjD;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;AAvRD;;;;;GAKG;AACH,oCAFU,MAAM;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,EAAE,EAAE,CAAC;IAAC,SAAS,EAAE,MAAM,CAAC;IAAC,MAAM,EAAE,MAAM,WAAW,CAAC;IAAC,WAAW,EAAE,OAAO,8BAA8B,EAAE,qBAAqB,CAAA;CAAC,CAAC,CAO5K"}

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

@@ -58,7 +58,8 @@ import { PARTICLE_ZERO_ABSORBING_OPS } from "./pass_fold_constants.js";
  *
  * A program reads more than its constants — record words, builtins, the RNG, the wind — 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.
+ * varies all of them, including a record pre-filled with values a `LOAD_PARTICLE_FIELD` can pick
+ * up.
  */
 
 /** Distinct, non-round values, so a builtin read from the wrong id or lane lands on a wrong number. */
@@ -76,8 +77,8 @@ BUILTINS_A[VM_BUILTIN.TIME] = [12.5, 0, 0, 0];
 const BUILTINS_B = BUILTINS_A.map(v => v.map(x => -x + 0.5));
 
 /**
- * A record with something in every user word — a program that loads an attribute the harness left
- * at zero is a program whose loads are all interchangeable.
+ * A record with something in every user word — a program that loads a particle field the harness
+ * left at zero is a program whose loads are all interchangeable.
  *
  * @returns {Uint32Array}
  */
@@ -163,10 +164,10 @@ export function run_particle_section({ words, constants, register_count, environ
  * to the rewrite is an opcode this follows. Everything the marked slots flow into is marked too, and a
  * store carries the mark into the record word it writes.
  *
- * A `LOAD_ATTR` of a marked record word marks its destination back, so a value that went out through
- * the record and came back in is still followed. Slots are cleared by a write whose sources are all
- * unmarked — the value there is then the same in both programs — while record words are only ever
- * added to, because a store cannot un-write what an earlier one already made unequal.
+ * A `LOAD_PARTICLE_FIELD` of a marked record word marks its destination back, so a value that went
+ * out through the record and came back in is still followed. Slots are cleared by a write whose
+ * sources are all unmarked — the value there is then the same in both programs — while record words
+ * are only ever added to, because a store cannot un-write what an earlier one already made unequal.
  *
  * Static, so it over-approximates the runs: a lane that never actually held a substituted zero is
  * marked anyway. That is the right direction to be wrong in, and it is not blunt in practice — see
@@ -198,9 +199,10 @@ export function particle_multiply_reach(words) {
             }
         }
 
-        // The record operands are read straight out of the words: `LOAD_ATTR` keeps its offset and
-        // component count in s0 and s1, `STORE_ATTR` in s1 and s2 behind the value it stores.
-        if (instruction.op === VM_OP.LOAD_ATTR) {
+        // The record operands are read straight out of the words: `LOAD_PARTICLE_FIELD` keeps its
+        // offset and component count in s0 and s1, `STORE_PARTICLE_FIELD` in s1 and s2 behind the
+        // value it stores.
+        if (instruction.op === VM_OP.LOAD_PARTICLE_FIELD) {
             const offset = instruction.words[1];
             const components = instruction.words[2];
 
@@ -209,7 +211,7 @@ export function particle_multiply_reach(words) {
             }
         }
 
-        if (instruction.op === VM_OP.STORE_ATTR) {
+        if (instruction.op === VM_OP.STORE_PARTICLE_FIELD) {
             const offset = instruction.words[2];
             const components = instruction.words[3];
             const value = instruction.sources[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.LOAD_CONST, VM_OP.LOAD_ATTR, VM_OP.LOAD_BUILTIN,
+    VM_OP.SELECT, VM_OP.RANDOM, VM_OP.LOAD_CONST, VM_OP.LOAD_PARTICLE_FIELD, VM_OP.LOAD_BUILTIN,
     VM_OP.SAMPLE_WIND, VM_OP.NOP,
 ];
 
@@ -149,7 +149,7 @@ export function random_particle_program(rand, {
             break;
         }
 
-        stream.storeAttr(value.base, cursor, value.width);
+        stream.storeParticleField(value.base, cursor, value.width);
         cursor += value.width;
     }
 
@@ -169,7 +169,7 @@ export function random_particle_program(rand, {
 
         const unreachable = pick(values);
 
-        stream.storeAttr(unreachable.base, 1, unreachable.width);
+        stream.storeParticleField(unreachable.base, 1, unreachable.width);
     }
 
     return assembler.build();
@@ -214,11 +214,11 @@ function emit_random_instruction(stream, assembler, rand, pool) {
             stream.loadBuiltin(dst, Math.floor(rand() * Object.keys(VM_BUILTIN).length), width);
             return;
 
-        case VM_OP.LOAD_ATTR: {
+        case VM_OP.LOAD_PARTICLE_FIELD: {
             const components = 1 + Math.floor(rand() * 4);
             const offset = 1 + Math.floor(rand() * (PARTICLE_RECORD_WORD_COUNT - components - 1));
 
-            stream.loadAttr(dst, offset, components, width);
+            stream.loadParticleField(dst, offset, components, width);
             return;
         }
 
@@ -308,7 +308,7 @@ export function random_particle_copy_program(rand, { groups = 5 } = {}) {
             if (roll < 0.12) {
                 stream.loadConst(source + pick(VM_MAX_WIDTH), assembler.constant(rand()), 1);
             } else if (roll < 0.24) {
-                stream.storeAttr(destination + pick(VM_MAX_WIDTH), 1 + pick(8), 1);
+                stream.storeParticleField(destination + pick(VM_MAX_WIDTH), 1 + pick(8), 1);
             } else if (roll < 0.32) {
                 stream.emit(VM_OP.ADD, pick(slots), pick(slots), pick(slots), 0, 1);
             } else if (roll < 0.36) {
@@ -323,7 +323,7 @@ export function random_particle_copy_program(rand, { groups = 5 } = {}) {
 
     // Store the file, so what the copies moved is observed rather than dropped as dead.
     for (let base = 0; base + VM_MAX_WIDTH <= slots && base + VM_MAX_WIDTH < PARTICLE_RECORD_WORD_COUNT; base += VM_MAX_WIDTH) {
-        stream.storeAttr(base, base + 1, VM_MAX_WIDTH);
+        stream.storeParticleField(base, base + 1, VM_MAX_WIDTH);
     }
 
     return assembler.build();

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

@@ -12,8 +12,9 @@ export function vm_semantics_of(op: number): ParticleOpSemantics;
  * {@link ../isa/ParticleVMISA.js} says what an instruction *does*; this says what may be done *to*
  * 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 `LOAD_BUILTIN` is both.
+ * Those are four different questions and an opcode can answer them differently:
+ * `LOAD_PARTICLE_FIELD` is 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

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":"AAyJA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAW/B;AAvKD;;;;;;;;;;;;;;;;;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"}
+{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AA0JA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAW/B;AAxKD;;;;;;;;;;;;;;;;;;GAkBG;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

@@ -6,8 +6,9 @@ import { VM_OP } from "../isa/ParticleVMISA.js";
  * {@link ../isa/ParticleVMISA.js} says what an instruction *does*; this says what may be done *to*
  * 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 `LOAD_BUILTIN` is both.
+ * Those are four different questions and an opcode can answer them differently:
+ * `LOAD_PARTICLE_FIELD` is 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
@@ -80,8 +81,8 @@ semantics(VM_OP.MOV, EXACT);
 semantics(VM_OP.LOAD_CONST, EXACT);
 // Reads the record, so it is removable when dead but may not be shared across a store that could
 // touch the same words — which is why it is not `shareable` and the CSE pass never sees it.
-semantics(VM_OP.LOAD_ATTR, { lanewise: true, narrowable: true });
-semantics(VM_OP.STORE_ATTR, { side_effects: true });
+semantics(VM_OP.LOAD_PARTICLE_FIELD, { lanewise: true, narrowable: true });
+semantics(VM_OP.STORE_PARTICLE_FIELD, { side_effects: true });
 semantics(VM_OP.LOAD_BUILTIN, { lanewise: true, narrowable: true, shareable: true });
 semantics(VM_OP.KILL, { side_effects: true });
 

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

@@ -1 +1 @@
-{"version":3,"file":"pass_allocate_registers.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_allocate_registers.js"],"names":[],"mappings":"AA0FqC,0JAEqB;AAxB1D;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH,4DAJW,OAAO,gCAAgC,EAAE,0BAA0B,EAAE,SACrE,MAAM,GACJ,wBAAwB,GAAC,IAAI,CAsHzC;AAlND,qBAAqB;AACrB,+CADW,MAAM,CACoD;;;;;UA6DvD,MAAM;;;;WACN,MAAM;;;;SACN,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;;;;;;aAKN,MAAM,EAAE;;;;YACR,MAAM;;;;YACN,MAAM;;;;WACN,MAAM;;;cAKN,uBAAuB,EAAE;;;;YACzB,qBAAqB,EAAE;;;;kBACvB,UAAU,EAAE;;;;eACZ,WAAW,EAAE;;;;mBACb,UAAU;;;;gBACV,MAAM"}
+{"version":3,"file":"pass_allocate_registers.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_allocate_registers.js"],"names":[],"mappings":"AA0FyD,0JAEqB;AAxB9E;;;;;;;GAOG;AAEH;;;;;;GAMG;AAEH;;;;;;;;GAQG;AAEH;;;;;;GAMG;AACH,4DAJW,OAAO,gCAAgC,EAAE,0BAA0B,EAAE,SACrE,MAAM,GACJ,wBAAwB,GAAC,IAAI,CAsHzC;AAlND,qBAAqB;AACrB,+CADW,MAAM,CACoD;;;;;UA6DvD,MAAM;;;;WACN,MAAM;;;;SACN,MAAM;;;;YACN,MAAM;;;;YACN,MAAM;;;;;;aAKN,MAAM,EAAE;;;;YACR,MAAM;;;;YACN,MAAM;;;;WACN,MAAM;;;cAKN,uBAAuB,EAAE;;;;YACzB,qBAAqB,EAAE;;;;kBACvB,UAAU,EAAE;;;;eACZ,WAAW,EAAE;;;;mBACb,UAAU;;;;gBACV,MAAM"}

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

@@ -1 +1 @@
-{"version":3,"file":"pass_dedup_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_dedup_constants.js"],"names":[],"mappings":"AA+GA;;;;;;GAMG;AACH,4DAHW,UAAU,UAAU,MAAM,CAAC,CAAC,gBACnB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,QAWhD;AAzB+B,uJAUkE;AA9GlG,qBAAqB;AACrB,4CADW,MAAM,CAC8C"}
+{"version":3,"file":"pass_dedup_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_dedup_constants.js"],"names":[],"mappings":"AA+GA;;;;;;GAMG;AACH,4DAHW,UAAU,UAAU,MAAM,CAAC,CAAC,gBACnB,MAAM,QAAE,MAAM,QAAE,MAAM,KAAG,IAAI,QAWhD;AAvBU,uJASQ;AA/GnB,qBAAqB;AACrB,4CADW,MAAM,CAC8C"}

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

@@ -1 +1 @@
-{"version":3,"file":"pass_eliminate_dead_code.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_eliminate_dead_code.js"],"names":[],"mappings":"AAmD8jF,2JAAqP;AAjDnzF,qBAAqB;AACrB,sCADW,MAAM,CACkC"}
+{"version":3,"file":"pass_eliminate_dead_code.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_eliminate_dead_code.js"],"names":[],"mappings":"AAmD2gF,2JAAqP;AAjDhwF,qBAAqB;AACrB,sCADW,MAAM,CACkC"}

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

@@ -1,51 +1,51 @@
-import { analyze_particle_lanes, decode_particle_instructions } from "./particle_program_analysis.js";
-
-/** @type {string} */
-export const PARTICLE_PASS_DEAD_CODE = "dead_code";
-
-/**
- * Drop instructions that cannot affect the program's meaning: the ones nothing reads, and the ones
- * that never run.
- *
- * A program means the record it leaves, the kill flag it sets and the RNG state it ends on.
- * Registers do not survive the section, so an instruction whose every written lane goes unread — and
- * which does nothing else on the way — could not have been observed. `NOP` is the degenerate case
- * and goes for the same reason.
- *
- * What stays whatever its result:
- *
- * - `RANDOM`, always. It advances the shared RNG, so a draw nobody reads still moves every draw
- *   after it. This is the one place where "the result is dead" and "the instruction is dead" come
- *   apart, and getting it wrong would not fail loudly — it would quietly reseed the effect.
- * - `STORE_ATTR` and `KILL`, which are the program's output.
- * - `LOAD_ATTR` is removable when dead; it reads the record but changes nothing.
- *
- * Deadness is transitive in one backward sweep, because {@link analyze_particle_lanes} walks in
- * reverse and a dead instruction contributes none of its reads: the sole consumer of a value being
- * dead makes its producer dead in the same pass, however long the chain.
- *
- * ## Unreachable code
- *
- * A `HALT` returns, so everything after the first one is deleted — and the `HALT` is then the last
- * instruction in the section, which is where execution stops anyway, so it goes too. Both executors
- * run exactly `instruction_count` instructions and neither needs a terminator.
- *
- * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
- */
-export function pass_eliminate_dead_code(instructions, context) {
-    const decoded = decode_particle_instructions(instructions);
-    const { keep, halt_index } = analyze_particle_lanes(decoded, context.register_slots);
-
-    const end = halt_index >= 0 ? halt_index : instructions.length;
-
-    /** @type {number[][]} */
-    const out = [];
-
-    for (let i = 0; i < end; i++) {
-        if (keep[i]) {
-            out.push(instructions[i]);
-        }
-    }
-
-    return out.length === instructions.length ? null : out;
-}
+import { analyze_particle_lanes, decode_particle_instructions } from "./particle_program_analysis.js";
+
+/** @type {string} */
+export const PARTICLE_PASS_DEAD_CODE = "dead_code";
+
+/**
+ * Drop instructions that cannot affect the program's meaning: the ones nothing reads, and the ones
+ * that never run.
+ *
+ * A program means the record it leaves, the kill flag it sets and the RNG state it ends on.
+ * Registers do not survive the section, so an instruction whose every written lane goes unread — and
+ * which does nothing else on the way — could not have been observed. `NOP` is the degenerate case
+ * and goes for the same reason.
+ *
+ * What stays whatever its result:
+ *
+ * - `RANDOM`, always. It advances the shared RNG, so a draw nobody reads still moves every draw
+ *   after it. This is the one place where "the result is dead" and "the instruction is dead" come
+ *   apart, and getting it wrong would not fail loudly — it would quietly reseed the effect.
+ * - `STORE_PARTICLE_FIELD` and `KILL`, which are the program's output.
+ * - `LOAD_PARTICLE_FIELD` is removable when dead; it reads the record but changes nothing.
+ *
+ * Deadness is transitive in one backward sweep, because {@link analyze_particle_lanes} walks in
+ * reverse and a dead instruction contributes none of its reads: the sole consumer of a value being
+ * dead makes its producer dead in the same pass, however long the chain.
+ *
+ * ## Unreachable code
+ *
+ * A `HALT` returns, so everything after the first one is deleted — and the `HALT` is then the last
+ * instruction in the section, which is where execution stops anyway, so it goes too. Both executors
+ * run exactly `instruction_count` instructions and neither needs a terminator.
+ *
+ * @type {import("./optimize_particle_program.js").ParticleOptimizerPass}
+ */
+export function pass_eliminate_dead_code(instructions, context) {
+    const decoded = decode_particle_instructions(instructions);
+    const { keep, halt_index } = analyze_particle_lanes(decoded, context.register_slots);
+
+    const end = halt_index >= 0 ? halt_index : instructions.length;
+
+    /** @type {number[][]} */
+    const out = [];
+
+    for (let i = 0; i < end; i++) {
+        if (keep[i]) {
+            out.push(instructions[i]);
+        }
+    }
+
+    return out.length === instructions.length ? null : out;
+}

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

@@ -1 +1 @@
-{"version":3,"file":"pass_fold_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_fold_constants.js"],"names":[],"mappings":"AAyF4B,sJAEwD;AAuJpF;;;;;;;;;;GAUG;AACH,gDANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAyElB;AApTD,qBAAqB;AACrB,2CADW,MAAM,CAC4C;AAE7D;;;;;GAKG;AACH,0CAFU,IAAI,MAAM,CAAC,CAE2C"}
+{"version":3,"file":"pass_fold_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_fold_constants.js"],"names":[],"mappings":"AAyFgD,sJAG9C;AAsJF;;;;;;;;;;GAUG;AACH,gDANW,MAAM,KACN,MAAM,KACN,MAAM,KACN,MAAM,GACJ,MAAM,CAyElB;AApTD,qBAAqB;AACrB,2CADW,MAAM,CAC4C;AAE7D;;;;;GAKG;AACH,0CAFU,IAAI,MAAM,CAAC,CAE2C"}

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

@@ -87,7 +87,7 @@ export const PARTICLE_ZERO_ABSORBING_OPS = new Set([VM_OP.MUL]);
  * because there is nothing here to buy with it. The fold only fires where an argument is already a
  * compile-time constant, and over all eighteen built-in groups — `curl4`, the simplex noises, the
  * quaternion and sampling groups, 6,523 instructions optimized — turning it on changes not one
- * instruction: every `sin` in the tree takes its argument from a `random`, an attribute or a
+ * instruction: every `sin` in the tree takes its argument from a `random`, a particle field or a
  * builtin. On the fuzzer's programs, where the opcode mix is uniform and operands are often
  * literals, it takes another 8.8% off what the default pipeline leaves (5,443 to 4,963 over 200
  * programs). So the option is real and tested and worth having for a frontend that folds harder
@@ -174,7 +174,7 @@ function evaluate_lanes(instruction, known, value, options) {
         return lanes;
     }
 
-    if (instruction.op === VM_OP.LOAD_ATTR) {
+    if (instruction.op === VM_OP.LOAD_PARTICLE_FIELD) {
         // Lanes past the component count are the zero an over-wide load is defined to read. The
         // ones inside it are whatever the record holds, which is not knowable here.
         for (let lane = instruction.words[2]; lane < count; lane++) {
@@ -453,9 +453,9 @@ function rewrite(instruction, lanes, known, value, options) {
  * instruction stops reading the upper lanes of its sources, and those are usually a broadcast, a
  * mask, and the arithmetic that built them. A distribution's mask lane is exactly this shape.
  *
- * Only for opcodes that compute their result from registers. `LOAD_ATTR`'s lanes past its component
- * count are already the zero it reads for free, and peeling those would be a load in place of
- * nothing at all.
+ * Only for opcodes that compute their result from registers. `LOAD_PARTICLE_FIELD`'s lanes past its
+ * component count are already the zero it reads for free, and peeling those would be a load in
+ * place of nothing at all.
  *
  * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction} instruction
  * @param {Array<number|null>} lanes

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

@@ -1 +1 @@
-{"version":3,"file":"pass_inline_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_inline_constants.js"],"names":[],"mappings":"AAkH2B,wJAUJ;AApHvB,qBAAqB;AACrB,6CADW,MAAM,CACgD;;;;;UA0FnD,MAAM;;;;UACN,MAAM;;;;UACN,WAAW;;;;aACX,OAAO"}
+{"version":3,"file":"pass_inline_constants.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_inline_constants.js"],"names":[],"mappings":"AAmHQ,wJASmC;AApH3C,qBAAqB;AACrB,6CADW,MAAM,CACgD;;;;;UA0FnD,MAAM;;;;UACN,MAAM;;;;UACN,WAAW;;;;aACX,OAAO"}

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

@@ -1 +1 @@
-{"version":3,"file":"pass_narrow_widths.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_narrow_widths.js"],"names":[],"mappings":"AA+DwsE,qJAAqP;AAxD77E,qBAAqB;AACrB,0CADW,MAAM,CAC0C"}
+{"version":3,"file":"pass_narrow_widths.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_narrow_widths.js"],"names":[],"mappings":"AA+D4tE,qJAAqP;AAxDj9E,qBAAqB;AACrB,0CADW,MAAM,CAC0C"}

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

@@ -1 +1 @@
-{"version":3,"file":"pass_pack_registers.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_pack_registers.js"],"names":[],"mappings":"AA+F82B,sJAAqP;AA5FnmC,qBAAqB;AACrB,2CADW,MAAM,CAC4C"}
+{"version":3,"file":"pass_pack_registers.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_pack_registers.js"],"names":[],"mappings":"AA+Fk4B,sJAAqP;AA5FvnC,qBAAqB;AACrB,2CADW,MAAM,CAC4C"}

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

@@ -1 +1 @@
-{"version":3,"file":"pass_peephole.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_peephole.js"],"names":[],"mappings":"AA8GyF,gJAGpD;AAtGrC,qBAAqB;AACrB,qCADW,MAAM,CACgC"}
+{"version":3,"file":"pass_peephole.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_peephole.js"],"names":[],"mappings":"AA+GQ,gJAEiD;AAtGzD,qBAAqB;AACrB,qCADW,MAAM,CACgC"}

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

@@ -1 +1 @@
-{"version":3,"file":"pass_propagate_copies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_propagate_copies.js"],"names":[],"mappings":"AAuHmB,wJAO+B;AApHlD,qBAAqB;AACrB,6CADW,MAAM,CACgD"}
+{"version":3,"file":"pass_propagate_copies.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_propagate_copies.js"],"names":[],"mappings":"AAuHuC,wJAO+B;AApHtE,qBAAqB;AACrB,6CADW,MAAM,CACgD"}

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

@@ -1 +1 @@
-{"version":3,"file":"pass_schedule.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_schedule.js"],"names":[],"mappings":"AAmHsD,gJAWoB;AA5H1E,qBAAqB;AACrB,qCADW,MAAM,CACgC"}
+{"version":3,"file":"pass_schedule.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_schedule.js"],"names":[],"mappings":"AAoHY,gJAU6E;AA5HzF,qBAAqB;AACrB,qCADW,MAAM,CACgC"}

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

@@ -21,8 +21,8 @@ export const PARTICLE_PASS_SCHEDULE = "schedule";
  * program had. Instructions with side effects are barriers: nothing crosses a draw, a store, a kill
  * or a halt in either direction, and they keep their order among themselves. That is stricter than
  * a pure instruction crossing a store needs, and it is what keeps the ordering promises of
- * `optimize_particle_program.js` — the draw sequence, attribute aliasing — structural for this pass
- * as for every other.
+ * `optimize_particle_program.js` — the draw sequence, particle field aliasing — structural for this
+ * pass as for every other.
  *
  * ## How the order is chosen
  *

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

@@ -1 +1 @@
-{"version":3,"file":"pass_share_subexpressions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_share_subexpressions.js"],"names":[],"mappings":"AA2GwC,4JAKP;AAzGjC,qBAAqB;AACrB,iDADW,MAAM,CACwD"}
+{"version":3,"file":"pass_share_subexpressions.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/pass_share_subexpressions.js"],"names":[],"mappings":"AA4GmC,4JAKN;AA1G7B,qBAAqB;AACrB,iDADW,MAAM,CACwD"}

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

@@ -25,10 +25,11 @@ export const PARTICLE_PASS_SHARE_SUBEXPRESSIONS = "share_subexpressions";
  *
  * ## What is not shared
  *
- * `LOAD_ATTR` reads the record, which a `STORE_ATTR` in between may have changed, and `RANDOM` reads
- * the RNG, which every draw changes. Neither is shareable, so neither is ever considered here — the
- * `shareable` column of {@link ./particle_vm_semantics.js} is the whole of the rule, which is what
- * keeps the aliasing question from having to be answered a second time in this file.
+ * `LOAD_PARTICLE_FIELD` reads the record, which a `STORE_PARTICLE_FIELD` in between may have
+ * changed, and `RANDOM` reads the RNG, which every draw changes. Neither is shareable, so neither
+ * is ever considered here — the `shareable` column of {@link ./particle_vm_semantics.js} is the
+ * whole of the rule, which is what keeps the aliasing question from having to be answered a second
+ * time in this file.
  *
  * `ADD`, `MUL` and `CMP_EQ` match with their operands either way round. `MIN` and `MAX` do not,
  * although they look just as commutative: `min(-0, 0)` and `min(0, -0)` are different registers'