@woosh/meep-engine 3.15.0 → 3.16.0

package/src/shade/renderer/particles/vm/chunk_particle_vm.js

@@ -1,9 +1,18 @@
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { chunk_random } from "../../shader/chunk/random/chunk_random.js";
 import {
+    PARTICLE_PROGRAM_CODE_BASE_WORD,
+    PARTICLE_PROGRAM_HEADER_WORDS,
     PARTICLE_VM_MAX_INSTRUCTIONS,
-    PARTICLE_VM_REGISTER_COUNT,
+    PARTICLE_VM_REGISTER_SLOTS,
 } from "../ParticleConstants.js";
-import { VM_BUILTIN, VM_OP, VM_RANDOM_MODE } from "../isa/ParticleVMISA.js";
+import {
+    VM_BUILTIN,
+    VM_OP,
+    VM_OP_MASK,
+    VM_WIDTH_MASK,
+    VM_WIDTH_SHIFT,
+} from "../isa/ParticleVMISA.js";
 
 /**
  * WGSL implementation of the particle VM — the interpreter a single simulation dispatch runs over
@@ -13,30 +22,85 @@ import { VM_BUILTIN, VM_OP, VM_RANDOM_MODE } from "../isa/ParticleVMISA.js";
  * Opcode numbers, register-file size and the instruction budget are interpolated straight from the
  * ISA / constants so the WGSL can never drift from the JS side.
  *
+ * ## Registers are scalars
+ *
+ * `vm_reg` is an `array<f32>`, not an `array<vec4<f32>>`, and an instruction's width says how many
+ * consecutive slots each of its operands spans. The file is dynamically indexed, so it lives in
+ * registers rather than scratch and its size is the shader's register footprint: as `vec4`s it cost
+ * 81 VGPRs on RDNA2 and held the shader to 10 waves against a cap of 16, and the same count of
+ * floats as slots holds far more values, because a `vec3` costs three of them instead of four.
+ * Spanning only the lanes an instruction needs also roughly halves both the arithmetic and the
+ * interpreter's own size — a `vec4` op against a dynamically indexed file is twelve `v_movrel`,
+ * where a loop over its width is emitted once.
+ *
+ * ## The builtin context stays a struct
+ *
+ * `vm_load_builtin`'s `switch` looks like something an `array<f32, 8 * 4>` indexed by builtin id
+ * would delete outright — the shape the JS reference's `builtins` already has. It is measured, not
+ * assumed, and the array loses: on RDNA2 (gfx1030, amdspv) the register file stops living in
+ * registers the moment a SECOND dynamically indexed array exists, whatever its size. Same
+ * interpreter, one builtin load:
+ *
+ * | builtin context             | VGPRs | scratch   | waves |
+ * |-----------------------------|-------|-----------|-------|
+ * | struct + switch (this)      | 53    | 0         | 16    |
+ * | `array<f32, 32>` by id      | 46    | 64 dwords | 16    |
+ * | `array<vec4<f32>, 8>`       | 47    | 64 dwords | 16    |
+ * | context atop a 64-slot file | 78    | 0         | 12    |
+ *
+ * 64 dwords is `vm_reg` plus the context spilled together: the promotion pass gives up on both
+ * rather than picking one, and every register access becomes memory traffic. Folding the context
+ * into the register file instead keeps it out of scratch and costs a quarter of the occupancy. So
+ * the id stays a `switch` over named fields — a select chain fed from the registers the setup
+ * wrote — and only the per-lane pick was worth deleting.
+ *
  * Dispatch uses a `switch` over the opcode — a jump table on real hardware and (since the emulator
  * gained switch support) directly emulator-runnable. Register-file writes are the only per-instruction
  * state mutation, which the emulator handles reliably; the RNG state (RANDOM opcode) is a running
- * read-modify-write and can't be verified through the interpreter loop under the emulator, so it is
- * checked in isolation (see the parity spec + the reference known-answer test).
+ * read-modify-write, and now that the emulator wraps u32 arithmetic at 32 bits it runs through the
+ * interpreter loop too and is cross-checked against the reference by the parity spec.
+ *
+ * The RNG is the engine's house generator: `RANDOM` draws through `random()`, over the shared
+ * `rnd_state`. The VM used to carry its own PCG and its own state word, which by the end differed
+ * from `random()` in nothing but the names — an implementation fork with no reason to exist.
+ *
+ * ## The RNG has no distributions
+ *
+ * `RANDOM` is one uniform draw per lane, and that is the whole opcode. It used to switch over a
+ * distribution mode — signed, unit sphere, unit disk — and each of those is arithmetic a program
+ * can write over this draw for itself: with their constants hoisted, a unit sphere is ten
+ * instructions and a unit disk seven, bit-identical to what the switch computed, because they are
+ * the same expression. A sampler is a useful thing to have and there is no principled place to stop
+ * adding them, which is the argument for the VM having none: they belong in a library over the
+ * instruction set, not inside it — see ../graph/particle_graph_distributions.js.
  *
  * ## Contract
  *
- * - Register file, RNG state, kill flag and the builtin context are module-scope `var<private>`.
- *   Call `particle_vm_reset()` at the start of each particle, seed `vm_rng_state`, and populate
- *   `vm_ctx` before invoking {@link particle_vm_execute}.
- * - `particle_vm_execute(program, program_offset, instruction_count, constants, constant_offset,
- *   pool, record_base)` runs one section. Attributes are read/written as f32 bit patterns inside
- *   `pool` at `record_base + attribute_offset`.
+ * - Register file, kill flag and the builtin context are module-scope `var<private>`, as is the
+ *   shared `rnd_state` the RNG runs on. Call `particle_vm_reset()` at the start of each particle,
+ *   seed `rnd_state`, and populate `vm_ctx` before invoking {@link particle_vm_execute}.
+ * - `particle_vm_execute(program, code_offset, instruction_count, constant_offset, pool,
+ *   record_base)` runs one section. `program` is the packed arena buffer — header, constant pool,
+ *   code, see `ParticleConstants.PARTICLE_PROGRAM_HEADER_WORDS` — so code and data are one binding.
+ *   Attributes are read/written as f32 bit patterns inside `pool` at `record_base +
+ *   attribute_offset`.
+ * - The three section parameters may be per-lane or wave-uniform; the interpreter is the same
+ *   either way, but not its cost. Simulate passes them through `subgroupBroadcastFirst` because
+ *   its waves are one program by construction (`../shaders/shader_particle_simulate.js`), and the
+ *   driver then fetches the instruction words through the scalar unit, branches the switch on a
+ *   scalar and indexes `vm_reg` through M0 without the per-lane waterfall. Emit cannot: its waves
+ *   span emitters.
  * - The `CURVE` opcode calls the external symbol `particle_vm_sample_curve(handle: u32, t: f32) ->
  *   f32`. The enclosing shader must define it (production: animation-curve backed; tests: a stub).
  */
 
-const R = PARTICLE_VM_REGISTER_COUNT;
+const R = PARTICLE_VM_REGISTER_SLOTS;
 
 const source = /* language=wgsl */ `
-const PARTICLE_VM_REGISTER_COUNT : u32 = ${R}u;
+const PARTICLE_VM_REGISTER_SLOTS : u32 = ${R}u;
 const PARTICLE_VM_MAX_INSTRUCTIONS : u32 = ${PARTICLE_VM_MAX_INSTRUCTIONS}u;
-const PARTICLE_VM_TWO_PI : f32 = 6.28318530717958647692;
+const PARTICLE_PROGRAM_HEADER_WORDS : u32 = ${PARTICLE_PROGRAM_HEADER_WORDS}u;
+const PARTICLE_PROGRAM_CODE_BASE_WORD : u32 = ${PARTICLE_PROGRAM_CODE_BASE_WORD}u;
 
 // Per-invocation builtin inputs the host assembles before running a program.
 struct ParticleVMContext {
@@ -50,32 +114,21 @@ struct ParticleVMContext {
     emitter_up : vec3<f32>,
 }
 
-var<private> vm_reg : array<vec4<f32>, ${R}>;
-var<private> vm_rng_state : u32;
+// One f32 per slot. A value of width w occupies w consecutive slots, and an operand names the first.
+var<private> vm_reg : array<f32, ${R}>;
 var<private> vm_killed : bool;
 var<private> vm_ctx : ParticleVMContext;
 
 // Zero the register file and reset the kill flag. Call once per particle before executing a section.
 fn particle_vm_reset() {
-    for (var i = 0u; i < PARTICLE_VM_REGISTER_COUNT; i = i + 1u) {
-        vm_reg[i] = vec4<f32>(0.0);
+    for (var i = 0u; i < PARTICLE_VM_REGISTER_SLOTS; i = i + 1u) {
+        vm_reg[i] = 0.0;
     }
     vm_killed = false;
 }
 
-// PCG-RXS-M-XS-32 — must match pcg_next() in ParticleVMReference.js bit-for-bit.
-fn vm_rng_next() -> u32 {
-    let s = vm_rng_state * 747796405u + 2891336453u;
-    let shift = (s >> 28u) + 4u;
-    let word = ((s >> shift) ^ s) * 277803737u;
-    vm_rng_state = s;
-    return (word >> 22u) ^ word;
-}
-
-fn vm_rng_unit() -> f32 {
-    return f32(vm_rng_next() >> 8u) * (1.0 / 16777216.0);
-}
-
+// The lanes a builtin does not fill are the padding an over-wide read is defined to see: zero
+// behind a scalar, and behind a vector the \`w\` its window closes with.
 fn vm_load_builtin(id : u32) -> vec4<f32> {
     switch id {
         case ${VM_BUILTIN.DELTA_TIME}u: { return vec4<f32>(vm_ctx.delta_time, 0.0, 0.0, 0.0); }
@@ -90,75 +143,57 @@ fn vm_load_builtin(id : u32) -> vec4<f32> {
     }
 }
 
-fn vm_lane(v : vec4<f32>, i : u32) -> f32 {
-    switch i {
-        case 0u: { return v.x; }
-        case 1u: { return v.y; }
-        case 2u: { return v.z; }
-        default: { return v.w; }
+// Sum of products over \`width\` slots of each operand. The reductions are all this plus a square root.
+fn vm_dot_slots(a : u32, b : u32, width : u32) -> f32 {
+    var sum = 0.0;
+    for (var c = 0u; c < width; c = c + 1u) {
+        sum = sum + vm_reg[a + c] * vm_reg[b + c];
     }
+    return sum;
 }
 
-fn vm_normalize_keep_w(v : vec4<f32>) -> vec4<f32> {
-    let len = length(v.xyz);
-    let inv = select(0.0, 1.0 / len, len > 0.0);
-    return vec4<f32>(v.xyz * inv, v.w);
-}
-
-fn vm_random(mode : u32) -> vec4<f32> {
-    switch mode {
-        case ${VM_RANDOM_MODE.UNIFORM}u: {
-            return vec4<f32>(vm_rng_unit(), vm_rng_unit(), vm_rng_unit(), vm_rng_unit());
-        }
-        case ${VM_RANDOM_MODE.UNIFORM_SIGNED}u: {
-            return vec4<f32>(vm_rng_unit() * 2.0 - 1.0, vm_rng_unit() * 2.0 - 1.0, vm_rng_unit() * 2.0 - 1.0, vm_rng_unit() * 2.0 - 1.0);
-        }
-        case ${VM_RANDOM_MODE.UNIT_SPHERE}u: {
-            let z = vm_rng_unit() * 2.0 - 1.0;
-            let ang = vm_rng_unit() * PARTICLE_VM_TWO_PI;
-            let r = sqrt(max(0.0, 1.0 - z * z));
-            return vec4<f32>(r * cos(ang), r * sin(ang), z, 0.0);
-        }
-        default: { // UNIT_DISK
-            let r = sqrt(vm_rng_unit());
-            let ang = vm_rng_unit() * PARTICLE_VM_TWO_PI;
-            return vec4<f32>(r * cos(ang), r * sin(ang), 0.0, 0.0);
+// Read an attribute (f32 bits) out of the record into \`width\` slots. Slots past the attribute's
+// component count read zero, which is how a narrow attribute reaches a wider operation for free.
+fn vm_load_attr(pool : ptr<storage, array<u32>, read_write>, base : u32, off : u32, comp : u32, dst : u32, width : u32) {
+    for (var c = 0u; c < width; c = c + 1u) {
+        if (c < comp) {
+            vm_reg[dst + c] = bitcast<f32>((*pool)[base + off + c]);
+        } else {
+            vm_reg[dst + c] = 0.0;
         }
     }
 }
 
-// Load a vec4 attribute (f32 bits) from the record, honouring the component count.
-fn vm_load_attr(pool : ptr<storage, array<u32>, read_write>, base : u32, off : u32, comp : u32) -> vec4<f32> {
-    var v = vec4<f32>(0.0);
-    if (comp > 0u) { v.x = bitcast<f32>((*pool)[base + off]); }
-    if (comp > 1u) { v.y = bitcast<f32>((*pool)[base + off + 1u]); }
-    if (comp > 2u) { v.z = bitcast<f32>((*pool)[base + off + 2u]); }
-    if (comp > 3u) { v.w = bitcast<f32>((*pool)[base + off + 3u]); }
-    return v;
-}
-
-fn vm_store_attr(pool : ptr<storage, array<u32>, read_write>, base : u32, off : u32, comp : u32, v : vec4<f32>) {
-    if (comp > 0u) { (*pool)[base + off] = bitcast<u32>(v.x); }
-    if (comp > 1u) { (*pool)[base + off + 1u] = bitcast<u32>(v.y); }
-    if (comp > 2u) { (*pool)[base + off + 2u] = bitcast<u32>(v.z); }
-    if (comp > 3u) { (*pool)[base + off + 3u] = bitcast<u32>(v.w); }
+// One record word per component, and the width is the component count — a store cannot write slots
+// the value does not have.
+fn vm_store_attr(pool : ptr<storage, array<u32>, read_write>, base : u32, off : u32, comp : u32, src : u32) {
+    for (var c = 0u; c < comp; c = c + 1u) {
+        (*pool)[base + off + c] = bitcast<u32>(vm_reg[src + c]);
+    }
 }
 
 // Execute one program section against a particle record living in pool at record_base.
+//
+// \`program\` is the packed arena buffer: a header, the constant pool, then the code. The header's
+// first word says where the code starts; \`code_offset\` is a word offset into the code section and
+// \`constant_offset\` a WORD index into the pool — both as the emitter record carries them.
 fn particle_vm_execute(
     program : ptr<storage, array<u32>, read>,
-    program_offset : u32,
+    code_offset : u32,
     instruction_count : u32,
-    constants : ptr<storage, array<u32>, read>,
     constant_offset : u32,
     pool : ptr<storage, array<u32>, read_write>,
     record_base : u32,
 ) {
     let count = min(instruction_count, PARTICLE_VM_MAX_INSTRUCTIONS);
+    let code_base = (*program)[PARTICLE_PROGRAM_CODE_BASE_WORD] + code_offset;
 
     for (var pc = 0u; pc < count; pc = pc + 1u) {
-        let ib = program_offset + pc * 5u;
-        let op = (*program)[ib];
+        let ib = code_base + pc * 5u;
+        let word0 = (*program)[ib];
+        let op = word0 & ${VM_OP_MASK}u;
+        // Lane count this instruction spans. The opcodes whose count is fixed ignore it.
+        let w = (word0 >> ${VM_WIDTH_SHIFT}u) & ${VM_WIDTH_MASK}u;
         let dst = (*program)[ib + 1u];
         let s0 = (*program)[ib + 2u];
         let s1 = (*program)[ib + 3u];
@@ -167,69 +202,166 @@ fn particle_vm_execute(
         switch op {
             case ${VM_OP.HALT}u: { return; }
             case ${VM_OP.NOP}u: {}
-            case ${VM_OP.MOV}u: { vm_reg[dst] = vm_reg[s0]; }
+            case ${VM_OP.MOV}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = vm_reg[s0 + c]; }
+            }
             case ${VM_OP.LOAD_CONST}u: {
-                let cb = (constant_offset + s0) * 4u;
-                vm_reg[dst] = vec4<f32>(
-                    bitcast<f32>((*constants)[cb]),
-                    bitcast<f32>((*constants)[cb + 1u]),
-                    bitcast<f32>((*constants)[cb + 2u]),
-                    bitcast<f32>((*constants)[cb + 3u]),
-                );
-            }
-            case ${VM_OP.LOAD_ATTR}u: { vm_reg[dst] = vm_load_attr(pool, record_base, s0, s1); }
-            case ${VM_OP.STORE_ATTR}u: { vm_store_attr(pool, record_base, s0, s1, vm_reg[dst]); }
-            case ${VM_OP.LOAD_BUILTIN}u: { vm_reg[dst] = vm_load_builtin(s0); }
-            case ${VM_OP.KILL}u: { if (vm_reg[dst].x > 0.0) { vm_killed = true; } }
-
-            case ${VM_OP.ADD}u: { vm_reg[dst] = vm_reg[s0] + vm_reg[s1]; }
-            case ${VM_OP.SUB}u: { vm_reg[dst] = vm_reg[s0] - vm_reg[s1]; }
-            case ${VM_OP.MUL}u: { vm_reg[dst] = vm_reg[s0] * vm_reg[s1]; }
-            case ${VM_OP.DIV}u: { vm_reg[dst] = vm_reg[s0] / vm_reg[s1]; }
-            case ${VM_OP.MAD}u: { vm_reg[dst] = vm_reg[s0] * vm_reg[s1] + vm_reg[s2]; }
-            case ${VM_OP.MIN}u: { vm_reg[dst] = min(vm_reg[s0], vm_reg[s1]); }
-            case ${VM_OP.MAX}u: { vm_reg[dst] = max(vm_reg[s0], vm_reg[s1]); }
-            case ${VM_OP.MIX}u: { vm_reg[dst] = mix(vm_reg[s0], vm_reg[s1], vm_reg[s2]); }
-            case ${VM_OP.CLAMP}u: { vm_reg[dst] = clamp(vm_reg[s0], vm_reg[s1], vm_reg[s2]); }
-            case ${VM_OP.SCALE}u: { vm_reg[dst] = vm_reg[s0] * vm_reg[s1].x; }
-
-            case ${VM_OP.NEG}u: { vm_reg[dst] = -vm_reg[s0]; }
-            case ${VM_OP.ABS}u: { vm_reg[dst] = abs(vm_reg[s0]); }
-            case ${VM_OP.FLOOR}u: { vm_reg[dst] = floor(vm_reg[s0]); }
-            case ${VM_OP.FRACT}u: { vm_reg[dst] = fract(vm_reg[s0]); }
-            case ${VM_OP.SQRT}u: { vm_reg[dst] = sqrt(vm_reg[s0]); }
-            case ${VM_OP.SIN}u: { vm_reg[dst] = sin(vm_reg[s0]); }
-            case ${VM_OP.COS}u: { vm_reg[dst] = cos(vm_reg[s0]); }
-            case ${VM_OP.EXP}u: { vm_reg[dst] = exp(vm_reg[s0]); }
-            case ${VM_OP.LOG}u: { vm_reg[dst] = log(vm_reg[s0]); }
-            case ${VM_OP.POW}u: { vm_reg[dst] = pow(vm_reg[s0], vm_reg[s1]); }
-            case ${VM_OP.STEP}u: { vm_reg[dst] = step(vm_reg[s0], vm_reg[s1]); }
-            case ${VM_OP.SMOOTHSTEP}u: { vm_reg[dst] = smoothstep(vm_reg[s0], vm_reg[s1], vm_reg[s2]); }
-
-            case ${VM_OP.DOT}u: { vm_reg[dst] = vec4<f32>(dot(vm_reg[s0].xyz, vm_reg[s1].xyz)); }
-            case ${VM_OP.CROSS}u: { vm_reg[dst] = vec4<f32>(cross(vm_reg[s0].xyz, vm_reg[s1].xyz), 0.0); }
-            case ${VM_OP.LENGTH}u: { vm_reg[dst] = vec4<f32>(length(vm_reg[s0].xyz)); }
-            case ${VM_OP.NORMALIZE}u: { vm_reg[dst] = vm_normalize_keep_w(vm_reg[s0]); }
-            case ${VM_OP.DISTANCE}u: { vm_reg[dst] = vec4<f32>(distance(vm_reg[s0].xyz, vm_reg[s1].xyz)); }
+                let cb = PARTICLE_PROGRAM_HEADER_WORDS + constant_offset + s0;
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = bitcast<f32>((*program)[cb + c]); }
+            }
+            case ${VM_OP.LOAD_ATTR}u: { vm_load_attr(pool, record_base, s0, s1, dst, w); }
+            case ${VM_OP.STORE_ATTR}u: { vm_store_attr(pool, record_base, s0, s1, dst); }
+            case ${VM_OP.LOAD_BUILTIN}u: {
+                // The lane is a dynamic index into a vec4 VALUE, not into memory: no second array,
+                // and five instructions fewer than the switch that used to pick it.
+                let v = vm_load_builtin(s0);
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = v[c]; }
+            }
+            case ${VM_OP.KILL}u: { if (vm_reg[dst] > 0.0) { vm_killed = true; } }
+
+            case ${VM_OP.ADD}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = vm_reg[s0 + c] + vm_reg[s1 + c]; }
+            }
+            case ${VM_OP.SUB}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = vm_reg[s0 + c] - vm_reg[s1 + c]; }
+            }
+            case ${VM_OP.MUL}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = vm_reg[s0 + c] * vm_reg[s1 + c]; }
+            }
+            case ${VM_OP.DIV}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = vm_reg[s0 + c] / vm_reg[s1 + c]; }
+            }
+            case ${VM_OP.MAD}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = vm_reg[s0 + c] * vm_reg[s1 + c] + vm_reg[s2 + c]; }
+            }
+            case ${VM_OP.MIN}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = min(vm_reg[s0 + c], vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.MAX}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = max(vm_reg[s0 + c], vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.MIX}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = mix(vm_reg[s0 + c], vm_reg[s1 + c], vm_reg[s2 + c]); }
+            }
+            case ${VM_OP.CLAMP}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = clamp(vm_reg[s0 + c], vm_reg[s1 + c], vm_reg[s2 + c]); }
+            }
+            case ${VM_OP.SCALE}u: {
+                let k = vm_reg[s1];
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = vm_reg[s0 + c] * k; }
+            }
+
+            case ${VM_OP.NEG}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = -vm_reg[s0 + c]; }
+            }
+            case ${VM_OP.ABS}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = abs(vm_reg[s0 + c]); }
+            }
+            case ${VM_OP.FLOOR}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = floor(vm_reg[s0 + c]); }
+            }
+            case ${VM_OP.FRACT}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = fract(vm_reg[s0 + c]); }
+            }
+            case ${VM_OP.SQRT}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = sqrt(vm_reg[s0 + c]); }
+            }
+            case ${VM_OP.SIN}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = sin(vm_reg[s0 + c]); }
+            }
+            case ${VM_OP.COS}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = cos(vm_reg[s0 + c]); }
+            }
+            case ${VM_OP.EXP}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = exp(vm_reg[s0 + c]); }
+            }
+            case ${VM_OP.LOG}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = log(vm_reg[s0 + c]); }
+            }
+            case ${VM_OP.POW}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = pow(vm_reg[s0 + c], vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.STEP}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = step(vm_reg[s0 + c], vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.SMOOTHSTEP}u: {
+                for (var c = 0u; c < w; c = c + 1u) {
+                    vm_reg[dst + c] = smoothstep(vm_reg[s0 + c], vm_reg[s1 + c], vm_reg[s2 + c]);
+                }
+            }
+
+            // The reductions write ONE slot. Whatever wants the result wider gets an explicit
+            // broadcast from the compiler; the implicit fill-all-four is gone.
+            case ${VM_OP.DOT}u: { vm_reg[dst] = vm_dot_slots(s0, s1, w); }
+            case ${VM_OP.CROSS}u: {
+                // Both operands are read out before either is written: the destination is allowed to
+                // be one of them.
+                let ax = vm_reg[s0]; let ay = vm_reg[s0 + 1u]; let az = vm_reg[s0 + 2u];
+                let bx = vm_reg[s1]; let by = vm_reg[s1 + 1u]; let bz = vm_reg[s1 + 2u];
+                vm_reg[dst] = ay * bz - az * by;
+                vm_reg[dst + 1u] = az * bx - ax * bz;
+                vm_reg[dst + 2u] = ax * by - ay * bx;
+                // A fourth slot, if asked for, is the zero the opcode used to append.
+                for (var c = 3u; c < w; c = c + 1u) { vm_reg[dst + c] = 0.0; }
+            }
+            case ${VM_OP.LENGTH}u: { vm_reg[dst] = sqrt(vm_dot_slots(s0, s0, w)); }
+            case ${VM_OP.NORMALIZE}u: {
+                let len = sqrt(vm_dot_slots(s0, s0, w));
+                let inv = select(0.0, 1.0 / len, len > 0.0);
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = vm_reg[s0 + c] * inv; }
+            }
+            case ${VM_OP.DISTANCE}u: {
+                var sum = 0.0;
+                for (var c = 0u; c < w; c = c + 1u) {
+                    let e = vm_reg[s0 + c] - vm_reg[s1 + c];
+                    sum = sum + e * e;
+                }
+                vm_reg[dst] = sqrt(sum);
+            }
             case ${VM_OP.SWIZZLE}u: {
-                let v = vm_reg[s0];
-                vm_reg[dst] = vec4<f32>(
-                    vm_lane(v, s1 & 3u),
-                    vm_lane(v, (s1 >> 2u) & 3u),
-                    vm_lane(v, (s1 >> 4u) & 3u),
-                    vm_lane(v, (s1 >> 6u) & 3u),
-                );
+                // Every selected slot is read before any is written, so an in-place swizzle — which
+                // is what a broadcast is — reads the value it meant to.
+                let l0 = vm_reg[s0 + (s1 & 3u)];
+                let l1 = vm_reg[s0 + ((s1 >> 2u) & 3u)];
+                let l2 = vm_reg[s0 + ((s1 >> 4u) & 3u)];
+                let l3 = vm_reg[s0 + ((s1 >> 6u) & 3u)];
+                if (w > 0u) { vm_reg[dst] = l0; }
+                if (w > 1u) { vm_reg[dst + 1u] = l1; }
+                if (w > 2u) { vm_reg[dst + 2u] = l2; }
+                if (w > 3u) { vm_reg[dst + 3u] = l3; }
             }
 
-            case ${VM_OP.CMP_LT}u: { vm_reg[dst] = select(vec4<f32>(0.0), vec4<f32>(1.0), vm_reg[s0] < vm_reg[s1]); }
-            case ${VM_OP.CMP_LE}u: { vm_reg[dst] = select(vec4<f32>(0.0), vec4<f32>(1.0), vm_reg[s0] <= vm_reg[s1]); }
-            case ${VM_OP.CMP_GT}u: { vm_reg[dst] = select(vec4<f32>(0.0), vec4<f32>(1.0), vm_reg[s0] > vm_reg[s1]); }
-            case ${VM_OP.CMP_GE}u: { vm_reg[dst] = select(vec4<f32>(0.0), vec4<f32>(1.0), vm_reg[s0] >= vm_reg[s1]); }
-            case ${VM_OP.CMP_EQ}u: { vm_reg[dst] = select(vec4<f32>(0.0), vec4<f32>(1.0), vm_reg[s0] == vm_reg[s1]); }
-            case ${VM_OP.SELECT}u: { vm_reg[dst] = select(vm_reg[s0], vm_reg[s1], vm_reg[s2] > vec4<f32>(0.5)); }
+            case ${VM_OP.CMP_LT}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = select(0.0, 1.0, vm_reg[s0 + c] < vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.CMP_LE}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = select(0.0, 1.0, vm_reg[s0 + c] <= vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.CMP_GT}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = select(0.0, 1.0, vm_reg[s0 + c] > vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.CMP_GE}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = select(0.0, 1.0, vm_reg[s0 + c] >= vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.CMP_EQ}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = select(0.0, 1.0, vm_reg[s0 + c] == vm_reg[s1 + c]); }
+            }
+            case ${VM_OP.SELECT}u: {
+                for (var c = 0u; c < w; c = c + 1u) {
+                    vm_reg[dst + c] = select(vm_reg[s0 + c], vm_reg[s1 + c], vm_reg[s2 + c] > 0.5);
+                }
+            }
 
-            case ${VM_OP.RANDOM}u: { vm_reg[dst] = vm_random(s0); }
-            case ${VM_OP.CURVE}u: { vm_reg[dst] = vec4<f32>(particle_vm_sample_curve(s0, vm_reg[s1].x)); }
+            // \`random()\` off the shared \`rnd_state\`, which has to match
+            // u32_to_unit_f32(pcg_next()) in ParticleVMReference.js bit-for-bit; the parity spec
+            // holds them to it. One draw per lane, so the draw count is the width.
+            case ${VM_OP.RANDOM}u: {
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = random(); }
+            }
+            case ${VM_OP.CURVE}u: {
+                let v = particle_vm_sample_curve(s0, vm_reg[s1]);
+                for (var c = 0u; c < w; c = c + 1u) { vm_reg[dst + c] = v; }
+            }
 
             default: {}
         }
@@ -241,4 +373,4 @@ fn particle_vm_execute(
  * The particle VM interpreter.
  * @type {CodeChunk}
  */
-export const chunk_particle_vm = CodeChunk.from(source);
+export const chunk_particle_vm = CodeChunk.from(source, [chunk_random]);

package/src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.d.ts

@@ -5,11 +5,10 @@
  * @param {number} input_previous_depth
  * @param {number} input_current_normal
  * @param {number} input_velocity
- * @param {number} input
  * @param {GPUCameraContext} camera_current
  * @param {GPUCameraContext} camera_previous
  * @param {number[]} jitter
  * @param {number[]} resolution
  */
-export function graph_pass_debug_reprojection({ graph, input_current_depth, input_previous_depth, input_current_normal, input_velocity, input, camera_current, camera_previous, jitter, resolution }: FrameGraph): any;
+export function graph_pass_debug_reprojection({ graph, input_current_depth, input_previous_depth, input_current_normal, input_velocity, camera_current, camera_previous, jitter, resolution }: FrameGraph): any;
 //# sourceMappingURL=graph_pass_debug_reprojection.d.ts.map

package/src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"graph_pass_debug_reprojection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.js"],"names":[],"mappings":"AA0FA;;;;;;;;;;;;GAYG;AACH,uNAyGC"}
+{"version":3,"file":"graph_pass_debug_reprojection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.js"],"names":[],"mappings":"AA0FA;;;;;;;;;;;GAWG;AACH,gNAuGC"}

package/src/shade/renderer/postprocess/denoise/debug/graph_pass_debug_reprojection.js

@@ -95,7 +95,6 @@ const pipeline_descriptor = ComputePipelineDescriptor.simplified({
  * @param {number} input_previous_depth
  * @param {number} input_current_normal
  * @param {number} input_velocity
- * @param {number} input
  * @param {GPUCameraContext} camera_current
  * @param {GPUCameraContext} camera_previous
  * @param {number[]} jitter
@@ -107,7 +106,6 @@ export function graph_pass_debug_reprojection({
                                                   input_previous_depth,
                                                   input_current_normal,
                                                   input_velocity,
-                                                  input,
                                                   camera_current,
                                                   camera_previous,
                                                   jitter = [0, 0],
@@ -166,7 +164,6 @@ export function graph_pass_debug_reprojection({
 
     const reprojection_builder = graph.add("debug reprojection", reprojection_data, execute_reproject);
 
-    reprojection_data.input = reprojection_builder.read(input);
     reprojection_data.depth_current = reprojection_builder.read(input_current_depth);
     reprojection_data.velocity = reprojection_builder.read(input_velocity);
     reprojection_data.depth_previous = reprojection_builder.read(input_previous_depth);

package/src/shade/renderer/postprocess/dof/gather/DepthOfFieldU.js

@@ -256,7 +256,7 @@ export class DepthOfFieldU {
         // Autofocus inputs. Explicit modes (manual / world-point) are projected
         // onto the camera forward axis on the CPU; auto / nearest / point are
         // resolved on the GPU from the depth buffer.
-        const m = camera.transform.matrix;
+        const m = camera.transform;
         const autofocus_params = compute_dof_autofocus_params(
             this.focus,
             [m[12], m[13], m[14]],   // camera world position

package/src/shade/renderer/postprocess/dof/raymarch/DepthOfField.js

@@ -261,7 +261,7 @@ export class DepthOfField {
         // Autofocus inputs. Explicit modes (manual / world-point) are
         // projected onto the camera forward axis on the CPU; auto / nearest
         // / point are resolved on the GPU from the depth buffer.
-        const m = camera.transform.matrix;
+        const m = camera.transform;
         const autofocus_params = compute_dof_autofocus_params(
             this.focus,
             [m[12], m[13], m[14]],   // camera world position

package/src/shade/renderer/postprocess/nss/NSS.d.ts

@@ -49,7 +49,7 @@ export class NSS {
      * @returns {number}
      */
     static recommended_jitter_sequence_size(upscale_ratio: number): number;
-    static "__#131@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
+    static "__#130@#preprocess_tensor_descriptor"(render_w: any, render_h: any): TextureResourceDescriptor;
     /**
      * @param {GraphicsContext} graphics
      */

package/src/shade/renderer/postprocess/nss/NSS.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"NSS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS.js"],"names":[],"mappings":"AA+BA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAgaI;;;;;;OAMG;IACH,uDAHW,MAAM,GACJ,MAAM,CAKlB;IA2CD,uGAQC;IAlSD;;OAEG;IACH,uCAwCC;IApOD;;;;OAIG;IACH,QAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,aAFU,MAAM,EAAE,CAEG;IAErB;;;;;OAKG;IACH,eAFU,OAAO,CAEI;IAErB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;OAWG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,gBAFU,MAAM,CAEK;IAErB;;;;;;OAMG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEI;IACpB,wCAAwC;IACxC,eAD8B,MAAM,CAChB;IAyKpB;;;;;OAKG;IACH,6BAyHC;IAED,wCAAwC;IACxC,0BAEC;IArKD;;OAEG;IACH,gBA4BC;IAkJD,sCAIC;IACD,mCAAiE;IAcjE,0BASC;IA4CD,6BAAkF;IAClF,0BAA+C;IAE/C;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAf4B,KAAK;QACT,qBAAqB,EAAlC,MAAM;QACO,qBAAqB,EAAlC,MAAM;QACO,gBAAgB,EAA7B,MAAM;QACO,+BAA+B,EAA5C,MAAM;QAKO,qBAAqB,EAAlC,MAAM;QACO,cAAc,EAA3B,MAAM;QACS,iBAAiB,EAAhC,MAAM,EAAE;QACO,iBAAiB,EAAhC,MAAM,EAAE;QACN,MAAM,CA0NlB;;CACJ;2BAjwB0B,iBAAiB;0CAtBF,oDAAoD"}
+{"version":3,"file":"NSS.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/nss/NSS.js"],"names":[],"mappings":"AAgCA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAyCG;AACH;IAgaI;;;;;;OAMG;IACH,uDAHW,MAAM,GACJ,MAAM,CAKlB;IA2CD,uGAQC;IAlSD;;OAEG;IACH,uCAwCC;IApOD;;;;OAIG;IACH,QAFU,MAAM,EAAE,CAEF;IAEhB;;;OAGG;IACH,aAFU,MAAM,EAAE,CAEG;IAErB;;;;;OAKG;IACH,eAFU,OAAO,CAEI;IAErB;;;;;;;;OAQG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;;OAOG;IACH,gBAFU,MAAM,CAEM;IAEtB;;;;;OAKG;IACH,YAFU,MAAM,CAED;IAEf;;;;;;;;;;;OAWG;IACH,mBAFU,MAAM,CAEQ;IAExB;;;;;;OAMG;IACH,gBAFU,MAAM,CAEK;IAErB;;;;;;OAMG;IACH,iBAFU,MAAM,CAEM;IAEtB;;;;;;;;;OASG;IACH,eAFU,MAAM,CAEI;IACpB,wCAAwC;IACxC,eAD8B,MAAM,CAChB;IAyKpB;;;;;OAKG;IACH,6BAyHC;IAED,wCAAwC;IACxC,0BAEC;IArKD;;OAEG;IACH,gBA4BC;IAkJD,sCAIC;IACD,mCAAiE;IAcjE,0BASC;IA4CD,6BAAkF;IAClF,0BAA+C;IAE/C;;;;;;;;;;;;;;;;;;OAkBG;IACH;QAf4B,KAAK;QACT,qBAAqB,EAAlC,MAAM;QACO,qBAAqB,EAAlC,MAAM;QACO,gBAAgB,EAA7B,MAAM;QACO,+BAA+B,EAA5C,MAAM;QAKO,qBAAqB,EAAlC,MAAM;QACO,cAAc,EAA3B,MAAM;QACS,iBAAiB,EAAhC,MAAM,EAAE;QACO,iBAAiB,EAAhC,MAAM,EAAE;QACN,MAAM,CA0NlB;;CACJ;2BAjwB0B,iBAAiB;0CAtBF,oDAAoD"}

package/src/shade/renderer/postprocess/nss/NSS.js

@@ -1,4 +1,5 @@
 import { assert } from "../../../../core/assert.js";
+import { align_4 } from "../../../../core/binary/align_4.js";
 import { halton_sequence } from "../../../../core/math/statistics/halton_sequence.js";
 import { TextureResourceDescriptor } from "../../../device/graph/TextureResourceDescriptor.js";
 import { GPUTypedBuffer } from "../../buffer/GPUTypedBuffer.js";
@@ -380,7 +381,7 @@ export class NSS {
 
         // ── Upload weights (packed int8 as u32 array) ──
         const packed_weights = value.pack_weights();
-        const weights_byte_size = (packed_weights.byteLength + 3) & ~3;
+        const weights_byte_size = align_4(packed_weights.byteLength);
         this.#weights_buffer = this.#device.createBuffer({
             label: "NSS / weights (packed int8)",
             size: weights_byte_size,
@@ -416,7 +417,7 @@ export class NSS {
 
         // ── Upload per-head transfer LUTs (packed int8 as u32 array) ──
         const packed_luts = value.pack_luts();
-        const luts_byte_size = Math.max(4, (packed_luts.byteLength + 3) & ~3);
+        const luts_byte_size = Math.max(4, align_4(packed_luts.byteLength));
         this.#luts_buffer = this.#device.createBuffer({
             label: "NSS / LUTs (packed int8)",
             size: luts_byte_size,

package/src/shade/renderer/postprocess/nss/generate_NSS_WEIGHTS_ACTUAL.js

@@ -45,6 +45,7 @@
 // Then they sum naturally with fp_acc before the rescale.
 
 import { BinaryBuffer } from "../../../../core/binary/BinaryBuffer.js";
+import { align_4 } from "../../../../core/binary/align_4.js";
 import { readFileSync, writeFileSync } from "node:fs";
 import { dirname, join, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
@@ -233,8 +234,8 @@ for (const r of records) {
     total_rescale_floats += r.rescales_f32.length;
     if (r.lut_int8 !== null) total_lut_bytes += r.lut_int8.length;
 }
-const aligned_weight_bytes = (total_weight_bytes + 3) & ~3;
-const aligned_lut_bytes = (total_lut_bytes + 3) & ~3;
+const aligned_weight_bytes = align_4(total_weight_bytes);
+const aligned_lut_bytes = align_4(total_lut_bytes);
 
 // Activation enum (mirrors NSS_LAYER_CONFIG_STRUCT.js)
 const ACT = { identity: 0, relu: 1, leaky_relu: 2 };