@woosh/meep-engine 3.28.0 → 3.30.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.

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAuD3B,iDAIG;6BA3G0B,mCAAmC;8BAGlC,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AA2D3B,iDAIG;6BAhH0B,mCAAmC;8BAIlC,+BAA+B"}

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

@@ -3,6 +3,7 @@ import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
 import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import { chunk_grid3d_to_index } from "../../shader/chunk/grid/chunk_grid3d_to_index.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
@@ -52,9 +53,8 @@ export const EMIT_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
-//      value into a transient uniform, so no call site changes.
+resources.setImmediate('settings', EMIT_SETTINGS);
+
 resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
@@ -63,9 +63,7 @@ resources.createGroup()
     .addStorageBuffer("pool", WebGPUArray.u32, true)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // last in the group, so the storage bindings keep the indices the specs read by
-    .addUniform('settings', EMIT_SETTINGS);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
 
 const body = CodeChunk.from(
     /* language=wgsl */
@@ -74,8 +72,14 @@ const COUNTER_ALIVE : u32 = ${PARTICLE_COUNTER.ALIVE}u;
 const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
 
 @compute @workgroup_size(${PARTICLE_EMIT_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
-    let i = gid.x;
+fn main(
+    @builtin(workgroup_id) workgroup_id : vec3<u32>,
+    @builtin(num_workgroups) group_count : vec3<u32>,
+    @builtin(local_invocation_index) local_index : u32,
+) {
+    // shader_prefix_sum_to_command folds its count over three dimensions, so the newborn this lane
+    // belongs to is the flattened workgroup, not gid.x. Identical while y and z are 1.
+    let i = grid3d_to_index(workgroup_id, group_count.xy) * ${PARTICLE_EMIT_WORKGROUP_SIZE}u + local_index;
 
     let assignment = particle_emit_assignment(&spawn_prefix.elements, spawn_prefix.count, i);
     if (!assignment.valid) { return; }
@@ -99,6 +103,7 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     alive_out[a] = slot;
 }
 `, [
+    chunk_grid3d_to_index,
     chunk_particle_emit_step,
     chunk_particle_vm_registers_fast,
 ]);

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

@@ -0,0 +1,31 @@
+/**
+ * The free list as a fresh pool leaves it: every slot free, `dead[i] = i`, bottom to top.
+ *
+ * It is a stack of slot indices — the emit pass pops `dead[--DEAD]` — so the order within it is
+ * arbitrary and identity is simply the cheapest arrangement to write. What matters is that every
+ * slot appears exactly once: a repeat hands two particles one record, and a gap strands a slot for
+ * the lifetime of the system.
+ *
+ * ## Why this is a pass and not a host write
+ *
+ * Zero is not a valid free list — `dead[i] = 0` for every `i` is the same slot half a million times
+ * over — so the buffer WebGPU hands back has to be written before the first emit. Writing it from
+ * the host means a typed array the size of the list (2 MiB at the default capacity), a loop over
+ * every element of it, and a staged upload, all on the frame the system is constructed. Here it is
+ * one store per slot with no host memory involved at all, and it leaves the free list `STORAGE`
+ * only: nothing else ever writes it from the host, so it needs no `COPY_DST` and stays off the
+ * driver's upload-friendly — and slower — path.
+ *
+ * ## Bounded launch, strided loop
+ *
+ * The pool capacity belongs to whoever constructs the system, and `capacity / workgroup_size` can
+ * pass `maxComputeWorkgroupsPerDimension` — a validation error for a direct dispatch, and worse
+ * than that for the indirect ones elsewhere in the engine, which simply do not run. So the caller
+ * clamps the launch and every lane strides through the list by the whole grid: the fill covers any
+ * capacity, and a grid that happens to cover it in one pass costs one comparison to find out.
+ */
+/** Lanes per workgroup. One store each, so this is sized for occupancy and nothing else. */
+export const PARTICLE_INIT_FREE_LIST_WORKGROUP_SIZE: 256;
+export const shader_particle_init_free_list: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_particle_init_free_list.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_particle_init_free_list.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_init_free_list.js"],"names":[],"mappings":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,4FAA4F;AAC5F,yDAA0D;AAQ1D,2DAmBG;8BA3D2B,+BAA+B"}

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

@@ -0,0 +1,62 @@
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+
+/**
+ * The free list as a fresh pool leaves it: every slot free, `dead[i] = i`, bottom to top.
+ *
+ * It is a stack of slot indices — the emit pass pops `dead[--DEAD]` — so the order within it is
+ * arbitrary and identity is simply the cheapest arrangement to write. What matters is that every
+ * slot appears exactly once: a repeat hands two particles one record, and a gap strands a slot for
+ * the lifetime of the system.
+ *
+ * ## Why this is a pass and not a host write
+ *
+ * Zero is not a valid free list — `dead[i] = 0` for every `i` is the same slot half a million times
+ * over — so the buffer WebGPU hands back has to be written before the first emit. Writing it from
+ * the host means a typed array the size of the list (2 MiB at the default capacity), a loop over
+ * every element of it, and a staged upload, all on the frame the system is constructed. Here it is
+ * one store per slot with no host memory involved at all, and it leaves the free list `STORAGE`
+ * only: nothing else ever writes it from the host, so it needs no `COPY_DST` and stays off the
+ * driver's upload-friendly — and slower — path.
+ *
+ * ## Bounded launch, strided loop
+ *
+ * The pool capacity belongs to whoever constructs the system, and `capacity / workgroup_size` can
+ * pass `maxComputeWorkgroupsPerDimension` — a validation error for a direct dispatch, and worse
+ * than that for the indirect ones elsewhere in the engine, which simply do not run. So the caller
+ * clamps the launch and every lane strides through the list by the whole grid: the fill covers any
+ * capacity, and a grid that happens to cover it in one pass costs one comparison to find out.
+ */
+
+/** Lanes per workgroup. One store each, so this is sized for occupancy and nothing else. */
+export const PARTICLE_INIT_FREE_LIST_WORKGROUP_SIZE = 256;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer holding one u32
+resources.setImmediate("u_capacity", u32);
+resources.createGroup().addStorageBuffer("dead", WebGPUArray.u32, true);
+
+export const shader_particle_init_free_list = ComputeShader.from({
+    label: "Particle Init Free List",
+    resources,
+    body: CodeChunk.from(
+        /* language=wgsl */
+        `
+@compute @workgroup_size(${PARTICLE_INIT_FREE_LIST_WORKGROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(global_invocation_id) global_id : vec3<u32>,
+    @builtin(num_workgroups) group_count : vec3<u32>,
+) {
+    // The grid may be smaller than the list; every lane keeps taking the next slot a whole grid on.
+    let stride = group_count.x * ${PARTICLE_INIT_FREE_LIST_WORKGROUP_SIZE}u;
+
+    for (var slot = global_id.x; slot < u_capacity; slot += stride) {
+        dead[slot] = slot;
+    }
+}
+`),
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAyD/B,qDAIG;iDAvH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":";AAuDA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAsD/B,qDAIG;iDApH8C,yBAAyB;6BAJ7C,mCAAmC;8BAClC,+BAA+B"}

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

@@ -67,9 +67,8 @@ export const SIMULATE_SETTINGS = WebGPUStruct.from({
 
 const resources = new ShaderResourceSetDescriptor();
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads garbage. The graph pass turns the plain
-//      value into a transient uniform, so no call site changes.
+resources.setImmediate('settings', SIMULATE_SETTINGS);
+
 resources.createGroup()
     .addStorageBuffer("scene_database", WebGPUArray.u32, false)
     .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
@@ -78,9 +77,7 @@ resources.createGroup()
     .addStorageBuffer("sim_list", WebGPUArray.u32, false)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    // last in the group, so the storage bindings keep the indices the specs read by
-    .addUniform('settings', SIMULATE_SETTINGS);
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
 
 
 const body = CodeChunk.from(/* language=wgsl */ `

package/src/shade/renderer/particles/vm/ParticleVMReference.d.ts

@@ -29,6 +29,19 @@ export function u32_to_unit_f32(u: number): number;
  * so a source may overlap the destination in any way and still mean what it held before the
  * instruction.
  *
+ * ## Every step is an f32 step
+ *
+ * The register file is `f32`, and so is the shader's. An opcode that takes more than one arithmetic
+ * step to reach its result therefore rounds at every one of them, through `Math.fround`, rather
+ * than computing wide and rounding on the way out. Rounding only at the end gives f32 RESULTS
+ * without f32 RANGE, and the range is where the two executors part company: a product that is
+ * `inf` on the device is an ordinary number in `f64`, a difference that saturates there is finite
+ * here, and neither is a rounding apart. `CROSS` answered 0 where the device answers NaN, and
+ * `SMOOTHSTEP` answered the midpoint where the device answers the near edge.
+ *
+ * Two opcodes are deliberately outside that rule, and each says why where it is written: `MAD`,
+ * which models the fused product, and `FRACT`, whose subtraction cannot round twice.
+ *
  * @param {object} params
  * @param {Uint32Array} params.words instruction words for the section (SPAWN or UPDATE)
  * @param {Float32Array} params.constants constant pool, one float per word

package/src/shade/renderer/particles/vm/ParticleVMReference.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleVMReference.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/ParticleVMReference.js"],"names":[],"mappings":"AA0BA;;;;;;;GAOG;AACH,gCAHW,MAAM,GACJ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAW5C;AAED;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AA8DD;;;;;;;;;;;;;;;;;;;;GAoBG;AACH;IAR+B,KAAK,EAAzB,WAAW;IACU,SAAS,EAA9B,YAAY;IACG,cAAc,EAA7B,MAAM;IACc,MAAM,EAA1B,WAAW;IACS,QAAQ,GAA5B,MAAM,EAAE,EAAE;IACM,SAAS,GAAzB,MAAM;IACJ;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAuRlD"}
+{"version":3,"file":"ParticleVMReference.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/ParticleVMReference.js"],"names":[],"mappings":"AA0BA;;;;;;;GAOG;AACH,gCAHW,MAAM,GACJ;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAW5C;AAED;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AA8DD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH;IAR+B,KAAK,EAAzB,WAAW;IACU,SAAS,EAA9B,YAAY;IACG,cAAc,EAA7B,MAAM;IACc,MAAM,EAA1B,WAAW;IACS,QAAQ,GAA5B,MAAM,EAAE,EAAE;IACM,SAAS,GAAzB,MAAM;IACJ;IAAE,MAAM,EAAE,OAAO,CAAC;IAAC,SAAS,EAAE,MAAM,CAAA;CAAE,CAyUlD"}

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

@@ -125,6 +125,19 @@ const LITERAL_U32 = new Uint32Array(LITERAL_F32.buffer);
  * so a source may overlap the destination in any way and still mean what it held before the
  * instruction.
  *
+ * ## Every step is an f32 step
+ *
+ * The register file is `f32`, and so is the shader's. An opcode that takes more than one arithmetic
+ * step to reach its result therefore rounds at every one of them, through `Math.fround`, rather
+ * than computing wide and rounding on the way out. Rounding only at the end gives f32 RESULTS
+ * without f32 RANGE, and the range is where the two executors part company: a product that is
+ * `inf` on the device is an ordinary number in `f64`, a difference that saturates there is finite
+ * here, and neither is a rounding apart. `CROSS` answered 0 where the device answers NaN, and
+ * `SMOOTHSTEP` answered the midpoint where the device answers the near edge.
+ *
+ * Two opcodes are deliberately outside that rule, and each says why where it is written: `MAD`,
+ * which models the fused product, and `FRACT`, whose subtraction cannot round twice.
+ *
  * @param {object} params
  * @param {Uint32Array} params.words instruction words for the section (SPAWN or UPDATE)
  * @param {Float32Array} params.constants constant pool, one float per word
@@ -263,6 +276,18 @@ export function execute_particle_vm({
             case DIV:
                 for (let i = 0; i < w; i++) d[i] = a[i] / b[i];
                 break;
+            // The exception to the rule above, and the only one that is a choice. `MAD` models the
+            // FUSED form: the product reaches the addition unrounded, which is what makes it more
+            // than `MUL` then `ADD`. {@link ../optimizer/pass_peephole.js} refuses to fuse that
+            // pair into a `MAD` by default for exactly this reason, and
+            // {@link ../optimizer/particle_integer_bounds.js} exists only to prove the cases where
+            // the product needs no rounding and the two forms therefore agree; rounding it here
+            // would make both of those dead weight.
+            //
+            // The shader spells this `a * b + c`, which a driver is free to contract into an FMA
+            // or not, so it is a reading rather than a certainty — `VM_OP.MAD` is INEXACT in
+            // {@link ../optimizer/particle_vm_semantics.js} to say so. Spelling the shader
+            // `fma(a, b, c)` would settle it in this reading's favour on every device.
             case MAD:
                 for (let i = 0; i < w; i++) d[i] = a[i] * b[i] + c[i];
                 break;
@@ -272,8 +297,21 @@ export function execute_particle_vm({
             case MAX:
                 for (let i = 0; i < w; i++) d[i] = Math.max(a[i], b[i]);
                 break;
+            // WGSL defines `mix(e1, e2, e3)` as `e1 * (1 - e3) + e2 * e3`, and this used to spell
+            // it as the lerp `a + (b - a) * c`. The two are the same number only where the span
+            // `b - a` loses nothing, and at the ends of the f32 range it loses everything:
+            // `mix(1e20, 1, 1)` is 1 on the device and was 0 here, because `1 - 1e20` IS `-1e20`
+            // in f32. Rounding the lerp's steps without changing its shape would have made it
+            // worse — the span of (3e38, -3e38) is not an f32 at all, so a blend both of whose
+            // ends are finite would have come out infinite. Scaling each end on its own is what
+            // the shader does and it cannot overflow where the result does not.
             case MIX:
-                for (let i = 0; i < w; i++) d[i] = a[i] + (b[i] - a[i]) * c[i];
+                for (let i = 0; i < w; i++) {
+                    const from = Math.fround(a[i] * Math.fround(1 - c[i]));
+                    const to = Math.fround(b[i] * c[i]);
+
+                    d[i] = Math.fround(from + to);
+                }
                 break;
             case CLAMP:
                 for (let i = 0; i < w; i++) d[i] = Math.min(Math.max(a[i], b[i]), c[i]);
@@ -288,6 +326,12 @@ export function execute_particle_vm({
             case FLOOR:
                 for (let i = 0; i < w; i++) d[i] = Math.floor(a[i]);
                 break;
+            // The other exception, and this one is free: `a - floor(a)` cannot round twice. For
+            // |a| >= 1 the fractional part is a run of at most 23 of a's own mantissa bits and is
+            // an f32 exactly; for |a| < 1 it is a itself, or `1 + a`, which only becomes inexact
+            // in f64 once |a| falls below about 2^-29 — by which point it is far inside the last
+            // f32 step below 1 and rounds to 1.0 either way. The two conditions a double rounding
+            // would need cannot hold at once, which the spec checks rather than assumes.
             case FRACT:
                 for (let i = 0; i < w; i++) d[i] = a[i] - Math.floor(a[i]);
                 break;
@@ -316,9 +360,13 @@ export function execute_particle_vm({
                 for (let i = 0; i < w; i++) d[i] = smoothstep(a[i], b[i], c[i]);
                 break;
             // WGSL's `inverseSqrt`. Spelled as the reciprocal of a root rather than approximated,
-            // because the reference is the definition the hardware's estimate is measured against.
+            // because the reference is the definition the hardware's estimate is measured against
+            // — which is also why the root is rounded before the division reads it. A definition
+            // carried out in f64 is not the thing `inverseSqrt` is allowed to be 2 ULP away from:
+            // 1 / sqrt(0.0009) is 33.33333206176758 taken wide and 33.333335876464844 taken the
+            // way the device takes it, and the slack is measured from the second.
             case RSQRT:
-                for (let i = 0; i < w; i++) d[i] = 1 / Math.sqrt(a[i]);
+                for (let i = 0; i < w; i++) d[i] = Math.fround(1 / Math.fround(Math.sqrt(a[i])));
                 break;
             case TAN:
                 for (let i = 0; i < w; i++) d[i] = Math.tan(a[i]);
@@ -336,40 +384,55 @@ export function execute_particle_vm({
 
             // The reductions write a single lane; whatever wants the result wider reads it through
             // an `.xxxx` swizzle.
+            //
+            // Every step goes through `Math.fround`, because a plain `let sum = 0` is an f64
+            // accumulator and only the store into the register file rounds — which gives f32
+            // RESULTS without f32 RANGE, and the range is not recovered at the end. The shader
+            // computes `dot(a, a)` entirely in f32, where 1e20 squared is already `inf` and
+            // 1e-25 squared is already zero, so the two sides answered `inf` against 1.00000002e20
+            // and, through NORMALIZE's `len > 0`, the zero vector against a unit one.
             case DOT: {
                 let dp = 0;
-                for (let i = 0; i < w; i++) dp += a[i] * b[i];
+                for (let i = 0; i < w; i++) dp = Math.fround(dp + Math.fround(a[i] * b[i]));
                 d[0] = dp;
                 break;
             }
+            // Six products and three differences, every one of them in f32. Taken wide, a lane
+            // whose two products both overflow cancelled to exactly 0 — the mathematically right
+            // answer for a vector crossed with itself — where the device subtracts `inf - inf` and
+            // gets NaN. a = b = (0, 1e20, 1e20) is the shortest witness, and a NaN that exists
+            // only on the GPU is the worst shape this takes: invisible in the editor preview, and
+            // loose in a position attribute from the first frame it appears.
             case CROSS:
-                d[0] = a[1] * b[2] - a[2] * b[1];
-                d[1] = a[2] * b[0] - a[0] * b[2];
-                d[2] = a[0] * b[1] - a[1] * b[0];
+                d[0] = Math.fround(Math.fround(a[1] * b[2]) - Math.fround(a[2] * b[1]));
+                d[1] = Math.fround(Math.fround(a[2] * b[0]) - Math.fround(a[0] * b[2]));
+                d[2] = Math.fround(Math.fround(a[0] * b[1]) - Math.fround(a[1] * b[0]));
                 // A fourth lane, if asked for, is the zero the opcode used to append.
                 d[3] = 0;
                 break;
             case LENGTH: {
                 let sum = 0;
-                for (let i = 0; i < w; i++) sum += a[i] * a[i];
-                d[0] = Math.sqrt(sum);
+                for (let i = 0; i < w; i++) sum = Math.fround(sum + Math.fround(a[i] * a[i]));
+                d[0] = Math.fround(Math.sqrt(sum));
                 break;
             }
             case NORMALIZE: {
                 let sum = 0;
-                for (let i = 0; i < w; i++) sum += a[i] * a[i];
-                const len = Math.sqrt(sum);
-                const inv = len > 0 ? 1 / len : 0;
+                for (let i = 0; i < w; i++) sum = Math.fround(sum + Math.fround(a[i] * a[i]));
+                const len = Math.fround(Math.sqrt(sum));
+                // the shader's `select(0.0, 1.0 / len, len > 0.0)` — the same test, over a length
+                // that has now underflowed on the same inputs
+                const inv = len > 0 ? Math.fround(1 / len) : 0;
                 for (let i = 0; i < w; i++) d[i] = a[i] * inv;
                 break;
             }
             case DISTANCE: {
                 let sum = 0;
                 for (let i = 0; i < w; i++) {
-                    const e = a[i] - b[i];
-                    sum += e * e;
+                    const e = Math.fround(a[i] - b[i]);
+                    sum = Math.fround(sum + Math.fround(e * e));
                 }
-                d[0] = Math.sqrt(sum);
+                d[0] = Math.fround(Math.sqrt(sum));
                 break;
             }
 
@@ -414,6 +477,18 @@ export function execute_particle_vm({
 }
 
 /**
+ * WGSL's `smoothstep`, which is `t * t * (3 - 2t)` over `t = clamp((x - low) / (high - low), 0, 1)`.
+ *
+ * Every step is an f32 step, for the reason the executor's docblock gives, and here it is the SPAN
+ * that carries it: with the edges at ±3e38 the divisor is 6e38, which is `inf` in f32, so the
+ * device divides by an infinity, gets 0, and returns the near edge. Taken wide the divisor is
+ * finite and the answer was the midpoint — a ramp authored across a range wider than f32 reaches
+ * read as half-way in the editor preview and as not started at all in the game.
+ *
+ * The equal-edges guard stands in for a division by zero the device would do instead. It is the one
+ * place this function is not the shader's arithmetic, and it only differs from it at `x === edge0`,
+ * where the device's `0 / 0` is a NaN that WGSL does not define the clamp of.
+ *
  * @param {number} edge0
  * @param {number} edge1
  * @param {number} x
@@ -421,6 +496,9 @@ export function execute_particle_vm({
  */
 function smoothstep(edge0, edge1, x) {
     if (edge0 === edge1) return x < edge0 ? 0 : 1;
-    const t = Math.min(Math.max((x - edge0) / (edge1 - edge0), 0), 1);
-    return t * t * (3 - 2 * t);
+
+    const span = Math.fround(edge1 - edge0);
+    const t = Math.min(Math.max(Math.fround(Math.fround(x - edge0) / span), 0), 1);
+
+    return Math.fround(Math.fround(t * t) * Math.fround(3 - Math.fround(2 * t)));
 }

package/src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"prepare_meshlet_draw_commands_by_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;GAeG;AACH,uKAJa;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,wBAAwB,EAAE,MAAM,CAAA;CAAC,CAwUnH"}
+{"version":3,"file":"prepare_meshlet_draw_commands_by_material.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;GAeG;AACH,uKAJa;IAAC,QAAQ,EAAE,MAAM,CAAC;IAAC,aAAa,EAAE,MAAM,CAAC;IAAC,kBAAkB,EAAE,MAAM,CAAC;IAAC,wBAAwB,EAAE,MAAM,CAAA;CAAC,CAgUnH"}

package/src/shade/renderer/rasterize/bucket/prepare_meshlet_draw_commands_by_material.js

@@ -2,7 +2,7 @@ import { assert } from "../../../../core/assert.js";
 import { ceilPowerOfTwo } from "../../../../core/binary/operations/ceilPowerOfTwo.js";
 import { round_up } from "../../../../core/math/round_up.js";
 import { BufferResourceDescriptor } from "../../../device/graph/BufferResourceDescriptor.js";
-import { u32, vec2u } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { STRUCT_UNINDEXED_DRAW_COMMAND } from "../../gpu_primitive/indirect/STRUCT_UNINDEXED_DRAW_COMMAND.js";
 import { cpu_build_hash_table } from "../../gpu_primitive/hash_table/cpu_build_hash_table.js";
 import { graph_prefix_scan_csdldf } from "../../gpu_primitive/prefix_sum/v1/graph_prefix_scan_csdldf.js";
@@ -22,7 +22,7 @@ import { shader_count_meshlets_by_material } from "./shader_count_meshlets_by_ma
 import {
     shader_make_meshlet_indirect_draw_commands_by_material
 } from "./shader_make_meshlet_indirect_draw_commands_by_material.js";
-import { PUSH_CONSTANTS, shader_read_out_bucket } from "./shader_read_out_bucket.js";
+import { shader_read_out_bucket } from "./shader_read_out_bucket.js";
 import { shader_sort_meshlets_by_material } from "./shader_sort_meshlets_by_material.js";
 
 /**
@@ -83,16 +83,11 @@ export function graph_prepare_meshlet_draw_commands_by_material({
             0
         );
 
-        // TODO(chrome-153): transient uniform, not an immediate value — see the shader.
-        const u_settings = encoder.allocateTransientValueBuffer(PUSH_CONSTANTS, {
-            bucket_id,
-        });
-
         shader_read_out_bucket.dispatchIndirect({
             encoder,
             command,
             bindings: {
-                settings: u_settings,
+                settings: { bucket_id },
                 input: buckets_buffer,
                 output,
             }
@@ -165,15 +160,12 @@ export function graph_prepare_meshlet_draw_commands_by_material({
             const hzb = resources.get(data.texture_hzb);
             const command = resources.get(data.command);
 
-            // TODO(chrome-153): transient uniform, not an immediate value — see the shader.
-            const u_resolution = encoder.allocateTransientValueBuffer(vec2u, resolution);
-
             shader_hzb_meshlet_filter_1way_full.dispatchIndirect({
                 encoder,
                 command,
                 bindings: {
                     camera: camera_state,
-                    resolution: u_resolution,
+                    resolution,
                     scene_database: scene.scene_database_buffer,
                     meshlet_metadata: scene.geometries.meshlets.buffer_metadata,
                     texture_hzb: hzb.obtainView(),

package/src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Whether the scene has anything in an opaque rasterization bucket.
+ *
+ * The opaque path clears the visibility-buffer colour attachments and the depth attachment on its
+ * first draw, and it is the only thing that does — every later pass is recorded with `load`. So a
+ * scene whose materials are all alpha-tested or transparent, which is an ordinary thing (a
+ * foliage-only vegetation view, a glass preview, a point light whose only casters are billboards),
+ * used to draw over the previous frame's contents: geometry depth-tested against stale occluders,
+ * and every pixel the alpha-tested pass did not cover keeping last frame's mesh and triangle ids for
+ * the deferred shading to resolve as real surfaces.
+ *
+ * This is what lets the composer hand the clear to the first pass that will actually run.
+ *
+ * @param {Set<number>} active_buckets bucket ids any material in the scene asks for
+ * @returns {boolean}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function rasterization_has_opaque_bucket(active_buckets: Set<number>): boolean;
+//# sourceMappingURL=rasterization_has_opaque_bucket.d.ts.map

package/src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"rasterization_has_opaque_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;GAkBG;AACH,gEANW,IAAI,MAAM,CAAC,GACT,OAAO,CAWnB"}

package/src/shade/renderer/rasterize/bucket/rasterization_has_opaque_bucket.js

@@ -0,0 +1,28 @@
+import { rasterization_opaque_buckets } from "./rasterization_opaque_buckets.js";
+
+/**
+ * Whether the scene has anything in an opaque rasterization bucket.
+ *
+ * The opaque path clears the visibility-buffer colour attachments and the depth attachment on its
+ * first draw, and it is the only thing that does — every later pass is recorded with `load`. So a
+ * scene whose materials are all alpha-tested or transparent, which is an ordinary thing (a
+ * foliage-only vegetation view, a glass preview, a point light whose only casters are billboards),
+ * used to draw over the previous frame's contents: geometry depth-tested against stale occluders,
+ * and every pixel the alpha-tested pass did not cover keeping last frame's mesh and triangle ids for
+ * the deferred shading to resolve as real surfaces.
+ *
+ * This is what lets the composer hand the clear to the first pass that will actually run.
+ *
+ * @param {Set<number>} active_buckets bucket ids any material in the scene asks for
+ * @returns {boolean}
+ *
+ * @author Alex Goldring
+ * @copyright Company Named Limited (c) 2026
+ */
+export function rasterization_has_opaque_bucket(active_buckets) {
+    for (const _bucket of rasterization_opaque_buckets(active_buckets)) {
+        return true;
+    }
+
+    return false;
+}

package/src/shade/renderer/rasterize/bucket/shader_read_out_bucket.d.ts

@@ -1,5 +1,3 @@
-export const PUSH_CONSTANTS: WebGPUStruct;
 export const shader_read_out_bucket: ComputeShader;
-import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_read_out_bucket.d.ts.map

package/src/shade/renderer/rasterize/bucket/shader_read_out_bucket.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_read_out_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/shader_read_out_bucket.js"],"names":[],"mappings":"AAcA,0CAEG;AAsCH,mDAIE;6BAzD2B,mCAAmC;8BAIlC,+BAA+B"}
+{"version":3,"file":"shader_read_out_bucket.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/rasterize/bucket/shader_read_out_bucket.js"],"names":[],"mappings":"AAqDA,mDAIE;8BApD4B,+BAA+B"}

package/src/shade/renderer/rasterize/bucket/shader_read_out_bucket.js

@@ -12,14 +12,13 @@ import {
 
 const resources = new ShaderResourceSetDescriptor();
 
-export const PUSH_CONSTANTS = WebGPUStruct.from({
+const PUSH_CONSTANTS = WebGPUStruct.from({
     bucket_id: u32,
 });
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads 65535 and culls everything. Revert 7c9700b87.
-resources.createGroup()
-    .addUniform("settings", PUSH_CONSTANTS);
+// per-dispatch, four bytes, read-only: immediate data rather than a pooled buffer, a staging copy
+// and a bind group of its own
+resources.setImmediate("settings", PUSH_CONSTANTS);
 
 resources.createGroup()
     .addStorageBuffer("input", RASTERIZATION_BUCKET_SORT_OUTPUT_STRUCT_READ)

package/src/shade/renderer/rasterize/cull/hzb/shader_hzb_mesh_filter_2way.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_hzb_mesh_filter_2way.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/cull/hzb/shader_hzb_mesh_filter_2way.js"],"names":[],"mappings":"AA4GA,wDAIG;8BA/F2B,kCAAkC"}
+{"version":3,"file":"shader_hzb_mesh_filter_2way.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/cull/hzb/shader_hzb_mesh_filter_2way.js"],"names":[],"mappings":"AA8GA,wDAIG;8BAjG2B,kCAAkC"}

package/src/shade/renderer/rasterize/cull/hzb/shader_hzb_mesh_filter_2way.js

@@ -21,10 +21,12 @@ import { ShaderResourceSetDescriptor } from "../../../shader/resource/ShaderReso
 
 const resources = new ShaderResourceSetDescriptor();
 
-// TODO(chrome-153): uniform, not immediate — Dawn 153 overwrites immediate data on
-//      dispatchWorkgroupsIndirect, so this reads 65535 and culls everything. Revert 22893f0a7.
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer — the same
+// shape shader_read_out_bucket already uses. camera_previous stays a uniform: it is a scene buffer,
+// not a per-dispatch value.
+resources.setImmediate("bucket_index", U32_CONTAINER_STRUCT);
+
 resources.createGroup()
-    .addUniform("bucket_index", U32_CONTAINER_STRUCT)
     .addStorageBuffer("bucket_data", RASTERIZATION_BUCKET_SORT_OUTPUT_STRUCT_READ)
 
 resources.createGroup()

package/src/shade/renderer/rasterize/cull/hzb/shader_hzb_meshlet_filter_1way.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_hzb_meshlet_filter_1way.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/cull/hzb/shader_hzb_meshlet_filter_1way.js"],"names":[],"mappings":"AAyFA,2DAIG;8BA/E2B,kCAAkC"}
+{"version":3,"file":"shader_hzb_meshlet_filter_1way.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/rasterize/cull/hzb/shader_hzb_meshlet_filter_1way.js"],"names":[],"mappings":"AAgGA,2DAIG;8BArF2B,kCAAkC"}