@woosh/meep-engine 3.18.0 → 3.20.0

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,CA0Dc;0BA1EP,oCAAoC"}
+{"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"}

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

@@ -24,6 +24,19 @@ struct ParticleAVBOITContribution {
     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,

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

@@ -1,9 +1,6 @@
-/**
- * The draw pipeline: the four additive accumulators, reverse-Z depth test against the scene, no
- * depth write.
- * @type {RenderPipelineDescriptor}
- */
-export const PARTICLE_AVBOIT_DRAW_PIPELINE: RenderPipelineDescriptor;
+export const PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE: RenderPipelineDescriptor;
+export const PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE: RenderPipelineDescriptor;
+export const PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE: RenderPipelineDescriptor;
 /** The draw shader's resource set, for building its bind group. */
 export const PARTICLE_AVBOIT_DRAW_RESOURCES: ShaderResourceSetDescriptor;
 /** The assembled shader, for the validity tier. */

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAkIA;;;;GAIG;AACH,4CAFU,wBAAwB,CAa/B;AAEH,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCAxJb,iEAAiE;4CAW9D,sDAAsD;iCAFjE,kCAAkC"}
+{"version":3,"file":"shader_particle_avboit_draw.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_draw.js"],"names":[],"mappings":"AAgLA,2EAAsI;AACtI,8EAA2I;AAC3I,6EAA8I;AAE9I,mEAAmE;AACnE,yEAAwD;AAExD,mDAAmD;AACnD,2DAAsD;yCAxLb,iEAAiE;4CAW9D,sDAAsD;iCAFjE,kCAAkC"}

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

@@ -77,9 +77,28 @@ struct ParticleAVBOITDrawOutput {
     @location(3) emission : vec4<f32>,
 }
 
+// Each draw uses the same GPU-owned alive list. Clip the other modes before rasterization.
+fn particle_avboit_vertex(vi : u32, ii : u32, blend : u32) -> ParticleVertexOut {
+    var out = particle_billboard_vertex(vi, ii);
+    if (particle_avboit_draw_blend(out.color, out.blend) != blend) {
+        out.clip = vec4<f32>(2.0, 2.0, 2.0, 1.0);
+    }
+    return out;
+}
+
 @vertex
-fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    return particle_billboard_vertex(vi, ii);
+fn vs_alpha(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ALPHA);
+}
+
+@vertex
+fn vs_additive(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_ADDITIVE);
+}
+
+@vertex
+fn vs_general(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_avboit_vertex(vi, ii, PARTICLE_BLEND_PREMULTIPLIED);
 }
 
 @fragment
@@ -104,6 +123,10 @@ fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
         color = particle_apply_lighting(color, in.world_position, normalize(in.normal));
     }
 
+    if (particle_avboit_is_empty(color, in.blend)) {
+        discard;
+    }
+
     let volumetrics = sample_volumetrics(in.view_depth, screen_uv, in.clip.xy);
 
     let contribution = particle_avboit_contribution(color, in.blend, transmittance, volumetrics);
@@ -129,22 +152,31 @@ fn fs_main(in : ParticleVertexOut) -> ParticleAVBOITDrawOutput {
 const descriptor = ShaderDescriptor.from({ label: "Particle AVBOIT Draw", body, resources });
 
 /**
- * The draw pipeline: the four additive accumulators, reverse-Z depth test against the scene, no
- * depth write.
- * @type {RenderPipelineDescriptor}
+ * The variants share WGSL, bindings and attachments; only the vertex entry point and target writes
+ * differ. Disabling unused targets avoids blending zeros over every billboard pixel.
+ * @param {string} label
+ * @param {string} entryPoint
+ * @param {number[]} writeMasks
+ * @returns {RenderPipelineDescriptor}
  */
-export const PARTICLE_AVBOIT_DRAW_PIPELINE = RenderPipelineDescriptor.from({
-    label: "Particle AVBOIT Draw",
-    layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-    vertex: { module: { code: descriptor.source }, entryPoint: "vs_main" },
-    fragment: {
-        module: { code: descriptor.source },
-        entryPoint: "fs_main",
-        targets: AVBOIT_DRAW_TARGETS,
-    },
-    depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
-    primitive: { topology: "triangle-list", cullMode: "none" },
-});
+function create_draw_pipeline(label, entryPoint, writeMasks) {
+    return RenderPipelineDescriptor.from({
+        label,
+        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+        vertex: { module: { code: descriptor.source }, entryPoint },
+        fragment: {
+            module: { code: descriptor.source },
+            entryPoint: "fs_main",
+            targets: AVBOIT_DRAW_TARGETS.map((target, i) => ({ ...target, writeMask: writeMasks[i] })),
+        },
+        depthStencil: DepthStencilState.from({ format: "depth32float", depthWriteEnabled: false, depthCompare: "greater" }),
+        primitive: { topology: "triangle-list", cullMode: "none" },
+    });
+}
+
+export const PARTICLE_AVBOIT_DRAW_ALPHA_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Alpha", "vs_alpha", [0xF, 0xF, 0xF, 0]);
+export const PARTICLE_AVBOIT_DRAW_ADDITIVE_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw Additive", "vs_additive", [0, 0, 0, 0xF]);
+export const PARTICLE_AVBOIT_DRAW_GENERAL_PIPELINE = create_draw_pipeline("Particle AVBOIT Draw General", "vs_general", [0xF, 0xF, 0xF, 0xF]);
 
 /** The draw shader's resource set, for building its bind group. */
 export const PARTICLE_AVBOIT_DRAW_RESOURCES = resources;

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":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAqD3B,iDAIG;6BA1G0B,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":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAoD3B,iDAIG;6BAxG0B,mCAAmC;8BAGlC,+BAA+B"}

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

@@ -8,7 +8,6 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_fast } from "../vm/chunk_particle_vm_registers_fast.js";
-import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
 import { chunk_particle_emit_step } from "./chunk_particle_emit_step.js";
 
 /**
@@ -99,7 +98,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_emit_step,
     chunk_particle_vm_registers_fast,
-    chunk_particle_curve_disabled,
 ]);
 
 export const shader_particle_emit = ComputeShader.from({

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_emit_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit_wide.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,iDAFU,MAAM,CAGiD;AAiEjE,sDAIG;8BA9G2B,+BAA+B"}
+{"version":3,"file":"shader_particle_emit_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit_wide.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH;;;;GAIG;AACH,iDAFU,MAAM,CAGiD;AAgEjE,sDAIG;8BA5G2B,+BAA+B"}

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

@@ -7,7 +7,6 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_VM_WIDE_LAUNCH_LANES } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.js";
-import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
 import { chunk_particle_emit_step } from "./chunk_particle_emit_step.js";
 import { EMIT_SETTINGS, PARTICLE_EMIT_WORKGROUP_SIZE } from "./shader_particle_emit.js";
 
@@ -104,7 +103,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_emit_step,
     chunk_particle_vm_registers_wide,
-    chunk_particle_curve_disabled,
 ]);
 
 export const shader_particle_emit_wide = ComputeShader.from({

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":";AA0DA;;;;;GAKG;AACH,gCAFU,YAAY,CAMS;AAuD/B,qDAIG;iDAxH8C,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

@@ -8,7 +8,6 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_fast } from "../vm/chunk_particle_vm_registers_fast.js";
-import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
 import { chunk_particle_simulate_step } from "./chunk_particle_simulate_step.js";
 
 /**
@@ -47,9 +46,7 @@ import { chunk_particle_simulate_step } from "./chunk_particle_simulate_step.js"
  * frame from that same value, so thread count and bound agree by construction — and, because the
  * padded length is a whole number of workgroups, agree exactly.
  *
- * All structured reads go through `array<u32>` for emulator-testability. Curve sampling uses the
- * pluggable `particle_vm_sample_curve` — here the no-op provider; the feature swaps in the
- * animation-database-backed one.
+ * All structured reads go through `array<u32>` for emulator-testability.
  *
  * @type {ComputeShader}
  */
@@ -116,7 +113,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_simulate_step,
     chunk_particle_vm_registers_fast,
-    chunk_particle_curve_disabled,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_simulate_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate_wide.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;GAGG;AACH,qDAFU,MAAM,CAGqD;AA8DrE,0DAIG;8BAvH2B,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate_wide.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAoCG;AAEH;;;GAGG;AACH,qDAFU,MAAM,CAGqD;AA6DrE,0DAIG;8BArH2B,+BAA+B"}

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

@@ -7,7 +7,6 @@ import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourc
 import { PARTICLE_SIMULATE_WORKGROUP_SIZE, PARTICLE_VM_WIDE_LAUNCH_LANES } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
 import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.js";
-import { chunk_particle_curve_disabled } from "./chunk_particle_curve_disabled.js";
 import { chunk_particle_simulate_step } from "./chunk_particle_simulate_step.js";
 import { SIMULATE_SETTINGS } from "./shader_particle_simulate.js";
 
@@ -111,7 +110,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
     chunk_particle_simulate_step,
     chunk_particle_vm_registers_wide,
-    chunk_particle_curve_disabled,
 ]);
 
 body.addExtension(WebGPUExtensionType.Subgroups);

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

@@ -36,17 +36,15 @@ export function u32_to_unit_f32(u: number): number;
  * @param {Uint32Array} params.record particle record words (mutated in place); attributes are f32 bits
  * @param {number[][]} [params.builtins] builtin values indexed by {@link VM_BUILTIN} id, each a 4-array
  * @param {number} [params.rng_state] initial RNG state (u32)
- * @param {(handle: number, t: number) => number} [params.sampleCurve] curve evaluator for the CURVE op
  * @returns {{ killed: boolean, rng_state: number }}
  */
-export function execute_particle_vm({ words, constants, register_count, record, builtins, rng_state, sampleCurve, }: {
+export function execute_particle_vm({ words, constants, register_count, record, builtins, rng_state, }: {
     words: Uint32Array;
     constants: Float32Array;
     register_count: number;
     record: Uint32Array;
     builtins?: number[][];
     rng_state?: number;
-    sampleCurve?: (handle: number, t: number) => number;
 }): {
     killed: boolean;
     rng_state: number;

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;WACK,MAAM;WAAS,MAAM;EAW1C;AAED;;;;;GAKG;AACH,mCAHW,MAAM,GACJ,MAAM,CAIlB;AAqED;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH;WATW,WAAW;eACX,YAAY;oBACZ,MAAM;YACN,WAAW;eACX,MAAM,EAAE,EAAE;gBACV,MAAM;2BACG,MAAM,KAAK,MAAM,KAAK,MAAM;;YACzB,OAAO;eAAa,MAAM;EA+RhD"}
+{"version":3,"file":"ParticleVMReference.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/ParticleVMReference.js"],"names":[],"mappings":"AA0BA;;;;;;;GAOG;AACH,gCAHW,MAAM;WACK,MAAM;WAAS,MAAM;EAW1C;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;;YACM,OAAO;eAAa,MAAM;EAuRhD"}

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

@@ -72,17 +72,10 @@ const OP_WIDTH = new Int8Array(OP_COUNT);
 /** The lanes the opcode always writes, or `-1` for as many as it operates on. @type {Int8Array} */
 const OP_DEST = new Int8Array(OP_COUNT);
 
-/** Bit `n` set where source slot `n` is read one lane whatever the width. @type {Uint8Array} */
-const OP_SCALAR = new Uint8Array(OP_COUNT);
-
 for (const [op, meta] of VM_ISA) {
     OP_DEFINED[op] = 1;
     OP_WIDTH[op] = meta.width === VM_WIDTH.VARIABLE ? -1 : vm_operation_width(op, 0);
     OP_DEST[op] = meta.dest === VM_DEST.WIDTH ? -1 : vm_dest_width(op, 0);
-
-    for (const slot of meta.scalar_operands) {
-        OP_SCALAR[op] |= 1 << slot;
-    }
 }
 
 // --- module-local copies of what the loop reads per instruction ----------------------------------
@@ -92,7 +85,7 @@ for (const [op, meta] of VM_ISA) {
 // constants to the JIT, and the opcode switch can be a jump table.
 
 const {
-    ABS, ACOS, ADD, ASIN, ATAN2, CLAMP, CMP_EQ, CMP_GE, CMP_GT, CMP_LE, CMP_LT, COS, CROSS, CURVE,
+    ABS, ACOS, ADD, ASIN, ATAN2, CLAMP, CMP_EQ, CMP_GE, CMP_GT, CMP_LE, CMP_LT, COS, CROSS,
     DISTANCE, DIV, DOT, EXP, FLOOR, FRACT, HALT, KILL, LENGTH, LOAD_ATTR, LOAD_BUILTIN, LOAD_CONST,
     LOG, MAD, MAX, MIN, MIX, MOV, MUL, NEG, NOP, NORMALIZE, POW, RANDOM, RSQRT, SELECT, SIN,
     SMOOTHSTEP, SQRT, STEP, STORE_ATTR, SUB, TAN,
@@ -139,7 +132,6 @@ const LITERAL_U32 = new Uint32Array(LITERAL_F32.buffer);
  * @param {Uint32Array} params.record particle record words (mutated in place); attributes are f32 bits
  * @param {number[][]} [params.builtins] builtin values indexed by {@link VM_BUILTIN} id, each a 4-array
  * @param {number} [params.rng_state] initial RNG state (u32)
- * @param {(handle: number, t: number) => number} [params.sampleCurve] curve evaluator for the CURVE op
  * @returns {{ killed: boolean, rng_state: number }}
  */
 export function execute_particle_vm({
@@ -149,7 +141,6 @@ export function execute_particle_vm({
     record,
     builtins = [],
     rng_state = 0,
-    sampleCurve = () => 0,
 }) {
     // Register file: one f32 per slot. A value of width w occupies w consecutive slots.
     const reg = new Float32Array(register_count);
@@ -217,14 +208,13 @@ export function execute_particle_vm({
         const w = fixed_width < 0 ? (word0 >>> WIDTH_SHIFT) & WIDTH_MASK : fixed_width;
         const dst = (word0 >>> DST_SHIFT) & DST_MASK;
         const kinds = word0 >>> KIND_SHIFT;
-        const scalar = OP_SCALAR[op];
         const s0 = words[base + 1];
         const s1 = words[base + 2];
         const s2 = words[base + 3];
 
-        gather(a, kinds & KIND_MASK, s0, (scalar & 1) !== 0 ? 1 : w);
-        gather(b, (kinds >>> KIND_BITS) & KIND_MASK, s1, (scalar & 2) !== 0 ? 1 : w);
-        gather(c, (kinds >>> (2 * KIND_BITS)) & KIND_MASK, s2, (scalar & 4) !== 0 ? 1 : w);
+        gather(a, kinds & KIND_MASK, s0, w);
+        gather(b, (kinds >>> KIND_BITS) & KIND_MASK, s1, w);
+        gather(c, (kinds >>> (2 * KIND_BITS)) & KIND_MASK, s2, w);
 
         switch (op) {
             case HALT:
@@ -408,12 +398,6 @@ export function execute_particle_vm({
                 for (let i = 0; i < w; i++) d[i] = draw_unit();
                 break;
 
-            case CURVE: {
-                const v = sampleCurve(s0, b[0]);
-                for (let i = 0; i < w; i++) d[i] = v;
-                break;
-            }
-
             default:
                 throw new Error(`ParticleVMReference: unhandled opcode ${op} at pc ${pc}`);
         }

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

@@ -1 +1 @@
-{"version":3,"file":"chunk_particle_vm.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/chunk_particle_vm.js"],"names":[],"mappings":"AA6UA;;;GAGG;AACH,gCAFU,SAAS,CAEmG;0BAhV5F,oCAAoC"}
+{"version":3,"file":"chunk_particle_vm.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/vm/chunk_particle_vm.js"],"names":[],"mappings":"AA0UA;;;GAGG;AACH,gCAFU,SAAS,CAEmG;0BA7U5F,oCAAoC"}

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

@@ -66,8 +66,8 @@ import { PARTICLE_VM_CONTEXT_STRUCT } from "./PARTICLE_VM_CONTEXT_STRUCT.js";
  * VGPRs on RDNA2 and held the shader to 10 waves against a cap of 16.
  *
  * Where those slots LIVE is not this chunk's business. The interpreter reads and writes them through
- * `vm_reg_read` and `vm_reg_write`, which a backing chunk supplies — the same external-symbol seam
- * `particle_vm_sample_curve` uses. There are two backings and they are the two interpreters:
+ * `vm_reg_read` and `vm_reg_write`, which a backing chunk supplies. There are two backings and they
+ * are the two interpreters:
  *
  * - {@link ./chunk_particle_vm_registers_fast.js} — a `var<private>` array of
  *   {@link ../ParticleConstants.js PARTICLE_VM_FAST_REGISTER_SLOTS}. Dynamically indexed, so it
@@ -128,8 +128,6 @@ import { PARTICLE_VM_CONTEXT_STRUCT } from "./PARTICLE_VM_CONTEXT_STRUCT.js";
  *   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 source = /* language=wgsl */ `
@@ -318,7 +316,6 @@ fn particle_vm_execute(
                 if (w > 2u) { d.z = random(); }
                 if (w > 3u) { d.w = random(); }
             }
-            case ${VM_OP.CURVE}u: { d = vec4<f32>(particle_vm_sample_curve(s0, b.x)); }
 
             default: { lanes = 0u; }
         }

package/src/shade/renderer/particles/warmup/shader_particle_warmup_advance.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_warmup_advance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/shader_particle_warmup_advance.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,sCAFU,YAAY,CAMc;AAgBpC;;;;GAIG;AACH,kCAFU,MAAM,CA6Bd;AAEF,2DAeG;;6BAvG0B,mCAAmC;8BAClC,+BAA+B;gDAQb,6BAA6B"}
+{"version":3,"file":"shader_particle_warmup_advance.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/shader_particle_warmup_advance.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;;GAIG;AACH,sCAFU,YAAY,CAMc;AAgBpC;;;;GAIG;AACH,kCAFU,MAAM,CA6Bd;AAEF,2DAcG;;6BArG0B,mCAAmC;8BAClC,+BAA+B;gDAOb,6BAA6B"}

package/src/shade/renderer/particles/warmup/shader_particle_warmup_advance.js

@@ -6,7 +6,6 @@ import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
 import { PARTICLE_WARMUP_LAUNCH_LANES, PARTICLE_WARMUP_WORKGROUP_SIZE } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
-import { chunk_particle_curve_disabled } from "../shaders/chunk_particle_curve_disabled.js";
 import { chunk_particle_vm_registers_fast } from "../vm/chunk_particle_vm_registers_fast.js";
 import { chunk_particle_warmup_step } from "./chunk_particle_warmup_step.js";
 import { PARTICLE_WARMUP_WORKGROUP_COUNT } from "./shader_particle_warmup.js";
@@ -101,7 +100,6 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
         chunk_particle_warmup_step,
         chunk_particle_vm_registers_fast,
-        chunk_particle_curve_disabled,
     ]),
 });
 

package/src/shade/renderer/particles/warmup/shader_particle_warmup_advance_wide.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_warmup_advance_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/shader_particle_warmup_advance_wide.js"],"names":[],"mappings":"AAkDA,gEAmBG;8BAlE2B,+BAA+B"}
+{"version":3,"file":"shader_particle_warmup_advance_wide.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/warmup/shader_particle_warmup_advance_wide.js"],"names":[],"mappings":"AAiDA,gEAkBG;8BAhE2B,+BAA+B"}

package/src/shade/renderer/particles/warmup/shader_particle_warmup_advance_wide.js

@@ -9,7 +9,6 @@ import {
     PARTICLE_WARMUP_LAUNCH_LANES,
     PARTICLE_WARMUP_WORKGROUP_SIZE,
 } from "../ParticleConstants.js";
-import { chunk_particle_curve_disabled } from "../shaders/chunk_particle_curve_disabled.js";
 import { chunk_particle_vm_registers_wide } from "../vm/chunk_particle_vm_registers_wide.js";
 import { chunk_particle_warmup_step } from "./chunk_particle_warmup_step.js";
 import { WARMUP_ADVANCE_BODY, WARMUP_ADVANCE_SETTINGS } from "./shader_particle_warmup_advance.js";
@@ -65,6 +64,5 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 `, [
         chunk_particle_warmup_step,
         chunk_particle_vm_registers_wide,
-        chunk_particle_curve_disabled,
     ]),
 });

package/src/shade/renderer/postprocess/ssr/SSR.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IAyDI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAiB5D;IA1DD,oBAAgB;IAMhB,4CAOC;IATD,iGAAiG;IACjG,yCAA2E;IA0B3E,gCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAbnD,mCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA4C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;QAtBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QAC8B,sBAAsB,GAA1D,yBAAyB;QAC6D,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAClB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;;eACG,MAAM;eAAQ,MAAM;qBAAc,MAAM;kBAAW,MAAM;oBAAa,MAAM;MAkQ/F;;CACJ;0CAxYyC,oCAAoC"}
+{"version":3,"file":"SSR.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/SSR.js"],"names":[],"mappings":"AAiBA;IAyDI;;;OAGG;IACH,sBAFW,OAAO,0BAA0B,EAAE,eAAe,EAkB5D;IA3DD,oBAAgB;IAMhB,4CAOC;IATD,iGAAiG;IACjG,yCAA2E;IA0B3E,gCAMC;IAZD;;;;OAIG;IACH,6BAAmD;IAbnD,mCAMC;IARD,qCAAqC;IACrC,gCAA2D;IA6C3D;;;;OAIG;IACH,UAHW,MAAM,KACN,MAAM,QAUhB;IAED;;;;;;;;;;;;;;;;;;;;;;;;OAwBG;IACH;QAtBsG,KAAK,EAAhG,OAAO,8DAA8D,EAAE,UAAU;QACjE,WAAW,EAA3B,MAAM;QACW,oBAAoB,GAArC,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,iBAAiB,EAAjC,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,SAAS,EAAzB,MAAM;QACU,YAAY,EAA5B,MAAM;QACU,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QACW,iBAAiB,GAAlC,MAAM;QACqB,UAAU,EAArC,UAAU,MAAM,CAAC;QACD,cAAc,EAA9B,MAAM;QACU,eAAe,EAA/B,MAAM;QAC8B,sBAAsB,GAA1D,yBAAyB;QAC6D,MAAM,GAA5F,OAAO,oDAAoD,EAAE,cAAc;QACkB,GAAG,GAAhG,OAAO,sDAAsD,EAAE,mBAAmB;QAClB,QAAQ,GAAxE,OAAO,8BAA8B,EAAE,cAAc;QACzB,MAAM,GAAlC,UAAU,MAAM,CAAC;QACA,GAAG,GAApB,MAAM;;eACG,MAAM;eAAQ,MAAM;qBAAc,MAAM;kBAAW,MAAM;oBAAa,MAAM;MAkQ/F;;CACJ;0CAzYyC,oCAAoC"}

package/src/shade/renderer/postprocess/ssr/SSR.js

@@ -80,7 +80,8 @@ export class SSR {
 
         for (const [history, format, label] of [
             [this.#history, "rgba16float", "radiance"],
-            [this.#metadata, "rg32float", "metadata"],
+            // xy: reflected distance/support, z: history age, w: short-term luminance.
+            [this.#metadata, "rgba32float", "metadata"],
             [this.#geometry, "rgba16float", "geometry"],
         ]) {
             for (let i = 0; i < 2; i++) {

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_reprojection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ssr_reprojection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_reprojection.js"],"names":[],"mappings":"AAIA,+CAyBuC;0BA7Bb,uCAAuC"}
+{"version":3,"file":"chunk_ssr_reprojection.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_reprojection.js"],"names":[],"mappings":"AAIA,+CAwCuC;0BA5Cb,uCAAuC"}

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_reprojection.js

@@ -21,10 +21,25 @@ fn ssr_surface_history_uv(pixel: vec2f, velocity: vec2f, jitter_delta: vec2f, si
     return (pixel - velocity + jitter_delta) / size;
 }
 
-// Apply confidence LAST. Variance and clamp heuristics cannot resurrect rejected history.
-fn ssr_history_weight(current_variance: f32, history_variance: f32, current_blend: f32, confidence: f32) -> f32 {
-    let c = current_blend / (1.0 + max(current_variance, 0.0));
-    let h = (1.0 - current_blend) / (1.0 + max(history_variance, 0.0));
-    return h / max(c + h, 1e-20) * saturate(confidence);
+// Surface motion does not include reflection parallax. Bound the expected lag of
+// an exponential history to one internal pixel when this correspondence is used.
+// Rotation and raster jitter cancel between the two projections; translation does not.
+fn ssr_surface_parallax_confidence(camera_position: vec3f, position: vec3f, distance: f32,
+    previous_view_projection: mat4x4f, size: vec2f) -> f32 {
+    let surface_uv = ssr_history_uv(position, previous_view_projection);
+    var reflected_uv: vec2f;
+    if (is_finite(distance) && distance > 0.0) {
+        reflected_uv = ssr_history_uv(ssr_virtual_position(camera_position,position,distance),previous_view_projection);
+    } else {
+        // A miss has no finite reflected depth. Infinity bounds the parallax of
+        // a stale finite reflection that can still be present in this history.
+        let clip = previous_view_projection * vec4f(position-camera_position,0.0);
+        if (!is_finite(clip.w) || clip.w <= 1e-6) { return 0.0; }
+        reflected_uv = ndc_to_uv(clip.xy/clip.w);
+    }
+    let displacement = length((reflected_uv-surface_uv)*size);
+    if (!is_finite(displacement)) { return 0.0; }
+    return 1.0/(1.0+displacement);
 }
+
 `, [chunk_ndc_to_uv, chunk_is_finite]);

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_ssr_sample_history.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.js"],"names":[],"mappings":"AAUA,8FAA8F;AAC9F,iDA0DkD;0BArExB,uCAAuC"}
+{"version":3,"file":"chunk_ssr_sample_history.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.js"],"names":[],"mappings":"AAUA,8FAA8F;AAC9F,iDAwEkD;0BAnFxB,uCAAuC"}

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_sample_history.js

@@ -13,6 +13,8 @@ export const chunk_ssr_sample_history = CodeChunk.from(/* language=WGSL */ `
 struct SSRHistorySample {
     radiance: vec4f,
     confidence: f32,
+    age: f32,
+    short_luma: f32,
 }
 
 fn ssr_sample_history(
@@ -43,10 +45,12 @@ fn ssr_sample_history(
             texel_coordinate_to_uv(vec2f(coord), size), depth, camera_previous.view_projection_matrix_inverse);
         let plane_distance = abs(point_distance_above_plane(previous_position, plane));
         if (!is_finite(plane_distance) || plane_distance > plane_tolerance) { continue; }
-        let previous_metadata = textureLoad(tHistoryMetadata, coord, 0).rg;
+        let previous_metadata = textureLoad(tHistoryMetadata, coord, 0);
         if (!is_finite(previous_metadata.x) || !is_finite(previous_metadata.y)) { continue; }
-        // A source/support transition must not preserve the previous, unrelated reflection.
-        if (abs(previous_metadata.y - metadata.y) > 0.25) { continue; }
+        if (!is_finite(previous_metadata.z) || !is_finite(previous_metadata.w)) { continue; }
+        // On a rough reflector, hit/miss support is itself a stochastic sample. It is
+        // not evidence that the receiving surface or the reflected scene has moved.
+        if (roughness <= 0.2 && abs(previous_metadata.y - metadata.y) > 0.25) { continue; }
         var support = 1.0;
         if (virtual_candidate) {
             if (previous_metadata.y < 0.5 || previous_metadata.x <= 0.0) { continue; }
@@ -59,10 +63,20 @@ fn ssr_sample_history(
         let radiance = textureLoad(tHistory, coord, 0);
         if (!is_finite(radiance.x) || !is_finite(radiance.y) || !is_finite(radiance.z) || !is_finite(radiance.w)) { continue; }
         let w = weights[i] * support;
-        result.radiance += max(radiance, vec4f(0.0)) * w;
+        let age = clamp(previous_metadata.z, 1.0, 128.0);
+        // Reconstruct each tap's distribution variance BEFORE interpolation.
+        // E[variance/age] * E[age] can wildly inflate noise at an age boundary.
+        result.radiance += max(radiance, vec4f(0.0)) * vec4f(w,w,w,w*age);
+        result.age += age * w;
+        result.short_luma += previous_metadata.w * w;
         result.confidence += w;
     }
-    if (result.confidence > 1e-6) { result.radiance /= result.confidence; }
+    if (result.confidence > 1e-6) {
+        result.radiance /= result.confidence;
+        result.age /= result.confidence;
+        result.radiance.w /= result.age;
+        result.short_luma /= result.confidence;
+    }
     return result;
 }
 `, [chunk_project_position_from_depth, chunk_is_background, chunk_plane_from_normal_and_point,

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_temporal_accumulate.d.ts

@@ -0,0 +1,4 @@
+/** Linear radiance accumulation. Spatial contrast and single stochastic hits are not motion. */
+export const chunk_ssr_temporal_accumulate: CodeChunk;
+import { CodeChunk } from "../../../shader/compiler/CodeChunk.js";
+//# sourceMappingURL=chunk_ssr_temporal_accumulate.d.ts.map

package/src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_temporal_accumulate.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"chunk_ssr_temporal_accumulate.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/postprocess/ssr/reproject/chunk_ssr_temporal_accumulate.js"],"names":[],"mappings":"AAUA,gGAAgG;AAChG,sDA6HuH;0BAxI7F,uCAAuC"}