@woosh/meep-engine 3.29.0 → 3.31.0

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

@@ -284,7 +284,12 @@ export function evaluate_particle_operation(op, a, b, c) {
         // the whole of what the option trades; anything an executor could disagree about by more
         // than a rounding is refused below rather than folded.
         case VM_OP.MAD: return Math.fround(a * b + c);
-        case VM_OP.MIX: return Math.fround(a + (b - a) * c);
+        case VM_OP.MIX: {
+            const from = Math.fround(a * Math.fround(1 - c));
+            const to = Math.fround(b * c);
+
+            return Math.fround(from + to);
+        }
         case VM_OP.SIN: return Math.fround(Math.sin(a));
         case VM_OP.COS: return Math.fround(Math.cos(a));
         case VM_OP.TAN: return Math.fround(Math.tan(a));
@@ -294,7 +299,7 @@ export function evaluate_particle_operation(op, a, b, c) {
         case VM_OP.LOG: return Math.fround(Math.log(a));
         // `1 / sqrt(a)` for `a <= 0` is an infinity or a `NaN`, and `finite` drops both — the same
         // rule that keeps `SQRT` next door out of trouble, so there is nothing to say here.
-        case VM_OP.RSQRT: return Math.fround(1 / Math.sqrt(a));
+        case VM_OP.RSQRT: return Math.fround(1 / Math.fround(Math.sqrt(a)));
         // WGSL's `pow` is `exp2(e2 * log2(e1))`, which is a `NaN` for every base at or below zero
         // — including `pow(0, 0)`, where JS says 1. A fold that turned the hardware's `NaN` into a
         // number would not be a rounding, so the non-positive bases are not folded at all.
@@ -306,9 +311,10 @@ export function evaluate_particle_operation(op, a, b, c) {
                 return NaN;
             }
 
-            const t = Math.min(Math.max((c - a) / (b - a), 0), 1);
+            const span = Math.fround(b - a);
+            const t = Math.min(Math.max(Math.fround(Math.fround(c - a) / span), 0), 1);
 
-            return Math.fround(t * t * (3 - 2 * t));
+            return Math.fround(Math.fround(t * t) * Math.fround(3 - Math.fround(2 * t)));
         }
         // `atan2(0, 0)` is 0 in JS and left to the implementation in WGSL. Every other pair is an
         // angle both agree on to a rounding.
@@ -423,14 +429,14 @@ function rewrite(instruction, lanes, known, value, options) {
     }
 
     if (instruction.op === VM_OP.SELECT) {
-        const collapsed = collapse_select(instruction, known, value, options.max_select_moves);
+        const collapsed = collapse_select(instruction, known, value, options.max_select_moves, options.register_slots);
 
         if (collapsed !== null) {
             return collapsed;
         }
     }
 
-    const identity = collapse_identity(instruction, known, value);
+    const identity = collapse_identity(instruction, known, value, options.register_slots);
 
     if (identity !== null) {
         return identity;
@@ -489,7 +495,8 @@ function peel_constant_tail(instruction, lanes, options) {
         [options.intern_constant(lanes.slice(first)), 0, 0]
     );
 
-    return particle_instruction_is_well_formed(narrowed) && particle_instruction_is_well_formed(load)
+    return particle_instruction_is_well_formed(narrowed, options.register_slots)
+        && particle_instruction_is_well_formed(load, options.register_slots)
         ? [narrowed, load]
         : null;
 }
@@ -519,7 +526,7 @@ function materialise(instruction, lanes, options) {
         [options.intern_constant(lanes), 0, 0]
     );
 
-    return particle_instruction_is_well_formed(words) ? [words] : null;
+    return particle_instruction_is_well_formed(words, options.register_slots) ? [words] : null;
 }
 
 /**
@@ -537,7 +544,7 @@ function materialise(instruction, lanes, options) {
  *
  * @returns {number[][]|null}
  */
-function collapse_select(instruction, known, value, max_select_moves) {
+function collapse_select(instruction, known, value, max_select_moves, slots) {
     const [when_false, when_true, condition] = instruction.sources;
     const width = instruction.operation_width;
     /** @type {import("./particle_program_analysis.js").ParticleOperandRun[]} the source picked, per lane */
@@ -572,7 +579,7 @@ function collapse_select(instruction, known, value, max_select_moves) {
         if (!is_itself) {
             const words = move_from(end - lane, instruction.write.base + lane, picked, lane);
 
-            if (!particle_instruction_is_well_formed(words)) {
+            if (!particle_instruction_is_well_formed(words, slots)) {
                 return null;
             }
 
@@ -608,7 +615,7 @@ function collapse_select(instruction, known, value, max_select_moves) {
  *
  * @returns {number[][]|null}
  */
-function collapse_identity(instruction, known, value) {
+function collapse_identity(instruction, known, value, slots) {
     const op = instruction.op;
     const width = instruction.operation_width;
     const sources = instruction.sources;
@@ -618,7 +625,7 @@ function collapse_identity(instruction, known, value) {
     const copy_of = (source) => {
         const words = move_from(width, instruction.write.base, source);
 
-        return particle_instruction_is_well_formed(words) ? [words] : null;
+        return particle_instruction_is_well_formed(words, slots) ? [words] : null;
     };
 
     switch (op) {
@@ -643,7 +650,7 @@ function collapse_identity(instruction, known, value) {
                     [a.word, b.word, 0]
                 );
 
-                return particle_instruction_is_well_formed(words) ? [words] : null;
+                return particle_instruction_is_well_formed(words, slots) ? [words] : null;
             };
 
             if (is(sources[1], 1)) return add(sources[0], sources[2]);

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":"AAmHY,wJAUZ;AArHA,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":"AAkH2B,wJAUJ;AApHvB,qBAAqB;AACrB,6CADW,MAAM,CACgD;;;;;UA0FnD,MAAM;;;;UACN,MAAM;;;;UACN,WAAW;;;;aACX,OAAO"}

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

@@ -60,7 +60,7 @@ export function pass_inline_constants(instructions, context) {
             continue;
         }
 
-        const rewrites = plan_inlining(decoded, i, source);
+        const rewrites = plan_inlining(decoded, i, source, context.register_slots);
 
         if (rewrites !== null) {
             for (const [index, words] of rewrites) {
@@ -157,9 +157,10 @@ function constant_source(instruction, constants) {
  * @param {import("./particle_program_analysis.js").ParticleDecodedInstruction[]} decoded
  * @param {number} index of the load
  * @param {ParticleConstantSource} source
+ * @param {number} register_slots size of the register file being optimized for
  * @returns {Map<number, number[]>|null} instruction index -> its rewritten words
  */
-function plan_inlining(decoded, index, source) {
+function plan_inlining(decoded, index, source, register_slots) {
     /** slots of the run the load still owns */
     const pending = new Set();
 
@@ -203,7 +204,7 @@ function plan_inlining(decoded, index, source) {
             words[0] = vm_with_kind(words[0], read.operand, VM_KIND.IMM);
             words[1 + read.operand] = first;
 
-            if (!particle_instruction_is_well_formed(words)) {
+            if (!particle_instruction_is_well_formed(words, register_slots)) {
                 return null;
             }
 

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+DguE,qJAAqP;AAxDr9E,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+DwsE,qJAAqP;AAxD77E,qBAAqB;AACrB,0CADW,MAAM,CAC0C"}

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

@@ -51,7 +51,7 @@ export function pass_narrow_widths(instructions, context) {
 
         words[0] = vm_with_width(words[0], width[i]);
 
-        if (!particle_instruction_is_well_formed(words)) {
+        if (!particle_instruction_is_well_formed(words, context.register_slots)) {
             continue;
         }
 

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":"AAuF09C,sJAAqP;AApF/sD,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+F82B,sJAAqP;AA5FnmC,qBAAqB;AACrB,2CADW,MAAM,CAC4C"}

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

@@ -38,10 +38,18 @@ export function pass_pack_registers(instructions, context) {
         const runs = instruction.write === null ? instruction.reads : [instruction.write, ...instruction.reads];
 
         for (const run of runs) {
+            if (run.base < 0 || run.base + run.span > slots) {
+                // A run outside the file this was asked to pack into cannot be remapped, and the
+                // marking loop used to skip it while the rewrite loop below read `remap` unguarded:
+                // an out-of-range index into an Int32Array is `undefined`, and `vm_with_dst` masks
+                // that to 0, so the destination silently became r0 on top of whatever the packer
+                // had just put there. `pass_schedule` and the allocator segment analysis both
+                // hand the program back untouched here, and so does this.
+                return null;
+            }
+
             for (let lane = 0; lane < run.span; lane++) {
-                if (run.base + lane < slots) {
-                    used[run.base + lane] = 1;
-                }
+                used[run.base + lane] = 1;
             }
         }
     }
@@ -76,7 +84,7 @@ export function pass_pack_registers(instructions, context) {
             words[1 + read.operand] = vm_operand_with_base(read.word, remap[read.base]);
         }
 
-        if (!particle_instruction_is_well_formed(words)) {
+        if (!particle_instruction_is_well_formed(words, slots)) {
             return null;
         }
 

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":"AA+GC,gJAMW;AA1GZ,qBAAqB;AACrB,qCADW,MAAM,CACgC"}
+{"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"}

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

@@ -61,8 +61,8 @@ export function pass_peephole(instructions, context) {
     let changed = false;
 
     for (const rewrite of [
-        options.merge_constant_loads ? merge_one_constant_load : null,
-        options.merge_moves ? merge_one_move : null,
+        options.merge_constant_loads ? (stream) => merge_one_constant_load(stream, context.register_slots) : null,
+        options.merge_moves ? (stream) => merge_one_move(stream, context.register_slots) : null,
         options.fuse_exact_multiply_add ? (stream) => fuse_one_multiply_add(stream, context, true) : null,
         options.fuse_multiply_add ? (stream) => fuse_one_multiply_add(stream, context, false) : null,
     ]) {
@@ -94,12 +94,13 @@ export function pass_peephole(instructions, context) {
  * @param {number[][]} instructions
  * @returns {number[][]|null}
  */
-function merge_one_constant_load(instructions) {
+function merge_one_constant_load(instructions, slots) {
     return merge_one_pair(
         instructions,
         VM_OP.LOAD_CONST,
         (a, b) => (b.words[1] === a.words[1] + a.operation_width ? a.words[1] : null),
-        () => true
+        () => true,
+        slots
     );
 }
 
@@ -115,7 +116,7 @@ function merge_one_constant_load(instructions) {
  * @param {number[][]} instructions
  * @returns {number[][]|null}
  */
-function merge_one_move(instructions) {
+function merge_one_move(instructions, slots) {
     return merge_one_pair(
         instructions,
         VM_OP.MOV,
@@ -160,7 +161,7 @@ function merge_one_move(instructions) {
  *   whether the second instruction's source still holds what it did, read at the first's position
  * @returns {number[][]|null}
  */
-function merge_one_pair(instructions, op, combined_source, source_survives) {
+function merge_one_pair(instructions, op, combined_source, source_survives, slots) {
     const decoded = decode_particle_instructions(instructions);
 
     for (let first = 0; first < decoded.length; first++) {
@@ -208,7 +209,7 @@ function merge_one_pair(instructions, op, combined_source, source_survives) {
             const kind = a.sources.length > 0 ? a.sources[0].kind : VM_KIND.NONE;
             const words = vm_pack_instruction(op, span, base, [kind, VM_KIND.NONE, VM_KIND.NONE], [source, 0, 0]);
 
-            if (!particle_instruction_is_well_formed(words)) {
+            if (!particle_instruction_is_well_formed(words, slots)) {
                 continue;
             }
 
@@ -255,7 +256,7 @@ function fuse_one_multiply_add(instructions, context, exact) {
         const multiply = decoded[i];
 
         if (multiply.op === VM_OP.MUL && (bounds === null || product_is_exact(multiply, bounds))) {
-            const fused = fuse_multiply_into_consumer(decoded, i);
+            const fused = fuse_multiply_into_consumer(decoded, i, context.register_slots);
 
             if (fused !== null) {
                 const out = instructions.slice();
@@ -295,7 +296,7 @@ function product_is_exact(multiply, bounds) {
  * @returns {{consumer: number, words: number[]}|null} `null` when the product is read by something
  *   other than one fusable consumer, or the factors do not survive to it
  */
-function fuse_multiply_into_consumer(decoded, index) {
+function fuse_multiply_into_consumer(decoded, index, slots) {
     const multiply = decoded[index];
     const product = multiply.write.base;
     const span = multiply.write.span;
@@ -341,7 +342,7 @@ function fuse_multiply_into_consumer(decoded, index) {
 
         const words = fused_words(multiply, consumer, position, other);
 
-        return words !== null && particle_instruction_is_well_formed(words) ? { consumer: j, words } : null;
+        return words !== null && particle_instruction_is_well_formed(words, slots) ? { consumer: j, words } : null;
     }
 
     return null;

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":"AAwHe,wJAOX;AArHJ,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":"AAuHmB,wJAO+B;AApHlD,qBAAqB;AACrB,6CADW,MAAM,CACgD"}

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

@@ -56,7 +56,7 @@ export function pass_propagate_copies(instructions, context) {
 
     for (let round = 0; round < rounds; round++) {
         const redirected = redirect_reads(current, context);
-        const forwarded = forward_destinations(redirected ?? current);
+        const forwarded = forward_destinations(redirected ?? current, context.register_slots);
 
         if (redirected === null && forwarded === null) {
             break;
@@ -90,7 +90,7 @@ function redirect_reads(instructions, context) {
         let words = instruction.words;
 
         for (const read of instruction.reads) {
-            const candidate = redirect(words, read, values);
+            const candidate = redirect(words, read, values, context.register_slots);
 
             if (candidate !== null) {
                 words = candidate;
@@ -126,7 +126,7 @@ function is_copy_onto_itself(words, instruction) {
 /**
  * @returns {number[]|null} the instruction with this read redirected, or `null` to leave it
  */
-function redirect(words, read, values) {
+function redirect(words, read, values, slots) {
     const origin = values.origin_of_read(read);
 
     if (origin < 0) {
@@ -143,7 +143,7 @@ function redirect(words, read, values) {
         return null;
     }
 
-    return particle_instruction_is_well_formed(repacked) ? repacked : null;
+    return particle_instruction_is_well_formed(repacked, slots) ? repacked : null;
 }
 
 /**
@@ -154,14 +154,15 @@ function redirect(words, read, values) {
  * keeping it incrementally honest would cost more than redoing it.
  *
  * @param {number[][]} instructions
+ * @param {number} slots size of the register file being optimized for
  * @returns {number[][]|null}
  */
-function forward_destinations(instructions) {
+function forward_destinations(instructions, slots) {
     let current = instructions;
     let changed = false;
 
     for (let attempt = 0; attempt < instructions.length; attempt++) {
-        const next = forward_one_destination(current);
+        const next = forward_one_destination(current, slots);
 
         if (next === null) {
             break;
@@ -176,9 +177,10 @@ function forward_destinations(instructions) {
 
 /**
  * @param {number[][]} instructions
+ * @param {number} slots size of the register file being optimized for
  * @returns {number[][]|null}
  */
-function forward_one_destination(instructions) {
+function forward_one_destination(instructions, slots) {
     const decoded = decode_particle_instructions(instructions);
 
     for (let copy = 0; copy < decoded.length; copy++) {
@@ -206,7 +208,7 @@ function forward_one_destination(instructions) {
             continue;
         }
 
-        const plan = plan_forwarding(decoded, copy, source.base, span, destination);
+        const plan = plan_forwarding(decoded, copy, source.base, span, destination, slots);
 
         if (plan === null) {
             continue;
@@ -246,7 +248,7 @@ function forward_one_destination(instructions) {
  * @param {number} destination first slot of the destination run
  * @returns {Array<[number, number[]]>|null} rewritten instructions by index, or `null` to leave the copy
  */
-function plan_forwarding(decoded, copy, base, span, destination) {
+function plan_forwarding(decoded, copy, base, span, destination, register_slots) {
     /** @type {Int32Array} per lane, the instruction that produced it; `-1` until found */
     const producer = new Int32Array(span).fill(-1);
 
@@ -350,7 +352,7 @@ function plan_forwarding(decoded, copy, base, span, destination) {
     const plan = [];
 
     for (const [index, words] of rewritten) {
-        if (!particle_instruction_is_well_formed(words)) {
+        if (!particle_instruction_is_well_formed(words, register_slots)) {
             return null;
         }
 

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":"AA8GU,4JAM8C;AA7GxD,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":"AA2GwC,4JAKP;AAzGjC,qBAAqB;AACrB,iDADW,MAAM,CACwD"}

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

@@ -56,7 +56,7 @@ export function pass_share_subexpressions(instructions, context) {
         let shared = false;
 
         if (previous !== undefined && values.holds(previous.base, previous.ids)) {
-            const replacement = share(instruction, previous, span);
+            const replacement = share(instruction, previous, span, context.register_slots);
 
             if (replacement !== null) {
                 for (const words of replacement) {
@@ -77,7 +77,15 @@ export function pass_share_subexpressions(instructions, context) {
         // Recorded after the write, so an expression that overwrites one of its own sources names
         // the register as it stands once the instruction has run.
         if (key !== null && !shared) {
-            available.set(key, { base: instruction.write.base, ids: values.ids_of(instruction.write.base, span) });
+            const ids = values.ids_of(instruction.write.base, span);
+
+            // null when the write leaves the register file, which `expression_key` does not catch —
+            // it answers null for an out-of-file READ only. Storing it brought the whole optimize
+            // down at the next instruction with the same key, inside `holds`, with a TypeError
+            // about `length` instead of the validation error the program deserves.
+            if (ids !== null) {
+                available.set(key, { base: instruction.write.base, ids });
+            }
         }
     }
 
@@ -139,7 +147,7 @@ function expression_key(instruction, values) {
  * @returns {number[][]|null} what to emit instead — nothing at all when the result is already in the
  *   destination, otherwise a copy of it — or `null` when the copy would not be a legal instruction
  */
-function share(instruction, previous, span) {
+function share(instruction, previous, span, slots) {
     if (previous.base === instruction.write.base) {
         return [];
     }
@@ -150,5 +158,5 @@ function share(instruction, previous, span) {
         [previous.base, 0, 0]
     );
 
-    return particle_instruction_is_well_formed(words) ? [words] : null;
+    return particle_instruction_is_well_formed(words, slots) ? [words] : 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":"AASA;;;;;GAKG;AACH,sCAFU,MAAM,EAAE,CAIf;AAEH;;;;;;;;;;;;GAYG;AACH;QAFiB,MAAM,GAAE,MAAM;EAS5B;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;IA0RI;;;;;;;;;;;;;;;;;;;;;;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,CA+C3B;IA7VD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAUV;;OAEG;IACH,sBAEC;IAED;;;;OAIG;IACH,gCAIC;IAED;;;;;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;;;;;;;;;;OAUG;IACH,cAHW,eAAe,GACb,OAAO,CAsBnB;IAED;;;;;;OAMG;IACH,QAFa,MAAM,CAsBlB;IAED;;;;;;;;;;;OAWG;IACH,YAFW,eAAe,QAsBzB;IAED;;;;OAIG;IACH,SAFa,eAAe,CAQ3B;IAyEL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C"}
+{"version":3,"file":"ParticleEmitter.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/runtime/ParticleEmitter.js"],"names":[],"mappings":"AASA;;;;;GAKG;AACH,sCAFU,MAAM,EAAE,CAIf;AAEH;;;;;;;;;;;;GAYG;AACH;QAFiB,MAAM,GAAE,MAAM;EAS5B;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4CG;AACH;IAiSI;;;;;;;;;;;;;;;;;;;;;;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,CA+C3B;IApWD;;;;OAIG;IACH,MAFU,MAAM,CAEN;IAUV;;OAEG;IACH,sBAEC;IAED;;;;OAIG;IACH,gCAIC;IAED;;;;;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;;;;;;;;;;OAUG;IACH,cAHW,eAAe,GACb,OAAO,CAsBnB;IAED;;;;;;OAMG;IACH,QAFa,MAAM,CAsBlB;IAED;;;;;;;;;;;OAWG;IACH,YAFW,eAAe,QA6BzB;IAED;;;;OAIG;IACH,SAFa,eAAe,CAQ3B;IAyEL;;;OAGG;IACH,4BAFU,OAAO,CAE0B;;CAN1C"}

package/src/shade/renderer/particles/runtime/ParticleEmitter.js

@@ -351,6 +351,13 @@ export class ParticleEmitter {
         this.render_rotation = other.render_rotation;
         this.render_frame = other.render_frame;
         this.render_velocity = other.render_velocity;
+
+        // That is every field `write_emitter_record` stages, so the row this emitter may already
+        // own is now wrong. The registry restages only what `is_stale` reports, and two emitters of
+        // one effect share the compiled program object — so the `set_program` escape hatch does not
+        // fire either, and a registered emitter copied over would keep the old spawn rate, blend
+        // flags and render bindings for the rest of its life. `bind_render` marks it too.
+        this.needsUpdate = true;
     }
 
     /**

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

@@ -10,6 +10,10 @@
  * transmittance the voxel volume leaves in front of this fragment, per channel; and
  * `sample_volumetrics` at this fragment, `.xyz` in-scatter and `.w` transmittance.
  *
+ * The particle-specific half is the blend mode: `particle_premultiply` turns the colour into the
+ * premultiplied form every side channel hands over, and `avboit_premultiplied_contribution` routes
+ * it from there — the same routing, with the same fog and coverage rules, as every other channel.
+ *
  * @type {CodeChunk}
  */
 export const chunk_particle_avboit_contribution: CodeChunk;

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

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

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

@@ -1,88 +1,47 @@
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { OIT_COVERAGE_MAX } from "../../rasterize/native/oit/OIT_CONSTANTS.js";
-import { chunk_particle_render_math } from "./chunk_particle_render_math.js";
-
-/**
- * What one particle fragment contributes to AVBOIT's four accumulators.
- *
- * The whole of the particle draw's decision, taken apart from the sampling that feeds it: which
- * accumulator a fragment belongs in, and with what weight. Lifted out of the fragment stage so it
- * can be run on the WGSL emulator against plain numbers — a fragment that samples an atlas, a depth
- * buffer, an integral texture and a froxel volume cannot be.
- *
- * The inputs are the shaded, *un*premultiplied colour and its emitter's blend mode; the
- * transmittance the voxel volume leaves in front of this fragment, per channel; and
- * `sample_volumetrics` at this fragment, `.xyz` in-scatter and `.w` transmittance.
- *
- * @type {CodeChunk}
- */
-export const chunk_particle_avboit_contribution = CodeChunk.from(/* language=wgsl */ `
-struct ParticleAVBOITContribution {
-    color : vec4<f32>,
-    norm : vec4<f32>,
-    extinction : vec4<f32>,
-    emission : vec4<f32>,
-}
-
-// Black covering fragments still contribute extinction; zero-alpha premultiplied RGB still emits.
-fn particle_avboit_is_empty(color : vec4<f32>, blend : u32) -> bool {
-    return all(particle_premultiply(color, blend) == vec4<f32>(0.0));
-}
-
-// The atlas is unorm, so non-negative straight alpha cannot produce emission. Signed alpha and
-// premultiplied sprites keep all four outputs: either can emit without positive coverage.
-fn particle_avboit_draw_blend(color : vec4<f32>, blend : u32) -> u32 {
-    if (blend == PARTICLE_BLEND_ADDITIVE) { return PARTICLE_BLEND_ADDITIVE; }
-    if (blend == PARTICLE_BLEND_ALPHA && color.a >= 0.0) { return PARTICLE_BLEND_ALPHA; }
-    return PARTICLE_BLEND_PREMULTIPLIED;
-}
-
-fn particle_avboit_contribution(
-    shaded : vec4<f32>,
-    blend : u32,
-    transmittance : vec3<f32>,
-    fog : vec4<f32>
-) -> ParticleAVBOITContribution {
-    var out : ParticleAVBOITContribution;
-
-    let premultiplied = particle_premultiply(shaded, blend);
-
-    /*
-     Full opacity would be zero transmittance, whose logarithm breaks the accumulators; below zero
-     it would be a negative extinction, and the resolve's exp(-sum) would brighten what is behind
-     the fragment instead of dimming it.
-    */
-    let coverage = clamp(premultiplied.a, 0.0, ${OIT_COVERAGE_MAX});
-
-    if (coverage <= 0.0) {
-        /*
-         Covers nothing: an additive emitter, or a premultiplied sprite with no alpha, which the
-         blended billboard pipeline blends the same way. It is dimmed by the fog in front of it,
-         but it does not carry the fog's own in-scatter: the scene it draws over already has that
-         composited in, and the resolve adds emission outside the normalization that would otherwise
-         take the duplicate away. Carrying it would add one copy of the fog per fragment.
-        */
-        out.color = vec4<f32>(0.0);
-        out.norm = vec4<f32>(0.0);
-        out.extinction = vec4<f32>(0.0);
-        out.emission = vec4<f32>(max(premultiplied.rgb * fog.w * transmittance, vec3<f32>(0.0)), 0.0);
-        return out;
-    }
-
-    // the ceiling is on the pair, so the colour is rescaled with the coverage it is weighted by
-    let scale = coverage / premultiplied.a;
-
-    // this one does hide part of the scene, so it owes that part its in-scatter back — and the
-    // resolve's normalization is what keeps the sum to one copy however many fragments there are
-    let color = premultiplied.rgb * scale * fog.w + fog.xyz * coverage;
-
-    let self_transmittance = vec3<f32>(1.0 - coverage);
-
-    out.color = vec4<f32>(color * transmittance, 0.0);
-    out.norm = vec4<f32>((1.0 - self_transmittance) * transmittance, 0.0);
-    out.extinction = vec4<f32>(-log(self_transmittance), 0.0);
-    out.emission = vec4<f32>(0.0);
-
-    return out;
-}
-`, [chunk_particle_render_math]);
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import {
+    chunk_avboit_premultiplied_contribution
+} from "../../rasterize/native/avboit/chunk_avboit_premultiplied_contribution.js";
+import { chunk_particle_render_math } from "./chunk_particle_render_math.js";
+
+/**
+ * What one particle fragment contributes to AVBOIT's four accumulators.
+ *
+ * The whole of the particle draw's decision, taken apart from the sampling that feeds it: which
+ * accumulator a fragment belongs in, and with what weight. Lifted out of the fragment stage so it
+ * can be run on the WGSL emulator against plain numbers — a fragment that samples an atlas, a depth
+ * buffer, an integral texture and a froxel volume cannot be.
+ *
+ * The inputs are the shaded, *un*premultiplied colour and its emitter's blend mode; the
+ * transmittance the voxel volume leaves in front of this fragment, per channel; and
+ * `sample_volumetrics` at this fragment, `.xyz` in-scatter and `.w` transmittance.
+ *
+ * The particle-specific half is the blend mode: `particle_premultiply` turns the colour into the
+ * premultiplied form every side channel hands over, and `avboit_premultiplied_contribution` routes
+ * it from there — the same routing, with the same fog and coverage rules, as every other channel.
+ *
+ * @type {CodeChunk}
+ */
+export const chunk_particle_avboit_contribution = CodeChunk.from(/* language=wgsl */ `
+// Black covering fragments still contribute extinction; zero-alpha premultiplied RGB still emits.
+fn particle_avboit_is_empty(color : vec4<f32>, blend : u32) -> bool {
+    return all(particle_premultiply(color, blend) == vec4<f32>(0.0));
+}
+
+// The atlas is unorm, so non-negative straight alpha cannot produce emission. Signed alpha and
+// premultiplied sprites keep all four outputs: either can emit without positive coverage.
+fn particle_avboit_draw_blend(color : vec4<f32>, blend : u32) -> u32 {
+    if (blend == PARTICLE_BLEND_ADDITIVE) { return PARTICLE_BLEND_ADDITIVE; }
+    if (blend == PARTICLE_BLEND_ALPHA && color.a >= 0.0) { return PARTICLE_BLEND_ALPHA; }
+    return PARTICLE_BLEND_PREMULTIPLIED;
+}
+
+fn particle_avboit_contribution(
+    shaded : vec4<f32>,
+    blend : u32,
+    transmittance : vec3<f32>,
+    fog : vec4<f32>
+) -> AVBOITContribution {
+    return avboit_premultiplied_contribution(particle_premultiply(shaded, blend), transmittance, fog);
+}
+`, [chunk_particle_render_math, chunk_avboit_premultiplied_contribution]);

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_avboit_occupancy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_occupancy.js"],"names":[],"mappings":"AAsJA,6DAIG;8BAjJ2B,+BAA+B"}
+{"version":3,"file":"shader_particle_avboit_occupancy.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_occupancy.js"],"names":[],"mappings":"AAwGA,6DAIG;8BApG2B,+BAA+B"}