@woosh/meep-engine 3.19.0 → 3.20.0

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

@@ -1 +1 @@
-{"version":3,"file":"particle_program_fuzz.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_fuzz.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;GAaG;AACH,oDAXuB,MAAM;IAED,WAAW,GAA5B,MAAM;IACY,IAAI,GAAtB,OAAO;IACW,MAAM,GAAxB,OAAO;IACU,cAAc,GAA/B,MAAM;oBAqHhB;AA8ED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yDALuB,MAAM;IAED,MAAM,GAAvB,MAAM;oBAmEhB"}
+{"version":3,"file":"particle_program_fuzz.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_program_fuzz.js"],"names":[],"mappings":"AAkDA;;;;;;;;;;;;;GAaG;AACH,oDAXuB,MAAM;IAED,WAAW,GAA5B,MAAM;IACY,IAAI,GAAtB,OAAO;IACW,MAAM,GAAxB,OAAO;IACU,cAAc,GAA/B,MAAM;oBAqHhB;AAuED;;;;;;;;;;;;;;;;;;GAkBG;AACH,yDALuB,MAAM;IAED,MAAM,GAAvB,MAAM;oBAmEhB"}

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

@@ -41,7 +41,7 @@ const FUZZ_OPS = [
     VM_OP.SMOOTHSTEP, VM_OP.RSQRT, VM_OP.TAN, VM_OP.ASIN, VM_OP.ACOS, VM_OP.ATAN2,
     VM_OP.DOT, VM_OP.CROSS, VM_OP.LENGTH, VM_OP.NORMALIZE, VM_OP.DISTANCE,
     VM_OP.CMP_LT, VM_OP.CMP_LE, VM_OP.CMP_GT, VM_OP.CMP_GE, VM_OP.CMP_EQ,
-    VM_OP.SELECT, VM_OP.RANDOM, VM_OP.CURVE, VM_OP.LOAD_CONST, VM_OP.LOAD_ATTR, VM_OP.LOAD_BUILTIN,
+    VM_OP.SELECT, VM_OP.RANDOM, VM_OP.LOAD_CONST, VM_OP.LOAD_ATTR, VM_OP.LOAD_BUILTIN,
     VM_OP.NOP,
 ];
 
@@ -222,13 +222,6 @@ function emit_random_instruction(stream, assembler, rand, pool) {
             return;
         }
 
-        case VM_OP.CURVE: {
-            const handle = Math.floor(rand() * 4);
-
-            stream.curve(dst, handle, source(group), width);
-            return;
-        }
-
         default: {
             // A `SELECT` whose condition is a constant is the shape the folding pass exists for, and
             // random registers hold one about never — so it is worth steering into deliberately.

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

@@ -13,7 +13,7 @@ export function vm_semantics_of(op: number): ParticleOpSemantics;
  * it — whether it can be deleted when its result is unread, narrowed when its high lanes are dead,
  * evaluated at compile time, or recognised as a recomputation of something already in a register.
  * Those are four different questions and an opcode can answer them differently: `LOAD_ATTR` is
- * removable but not shareable across a store, `RANDOM` is neither, and `CURVE` is both.
+ * removable but not shareable across a store, `RANDOM` is neither, and `LOAD_BUILTIN` is both.
  *
  * Every opcode has to appear in {@link VM_SEMANTICS} — the spec asserts it — because the safe
  * default for a new one is "assume nothing", and a table that silently omitted it would instead have
@@ -22,7 +22,7 @@ export function vm_semantics_of(op: number): ParticleOpSemantics;
  * Which lane of a source feeds which lane of the result is not a property of the opcode any more:
  * every register operand carries a swizzle, and `vm_operand_slot` in the ISA answers it per operand.
  * What is left here is per-opcode: whether lane `i` of the result depends on lane `i` of the
- * sources alone (`lanewise`), and whether every lane of the result is the same value (`broadcasts`).
+ * sources alone (`lanewise`).
  */
 /**
  * @typedef {object} ParticleOpSemantics
@@ -37,9 +37,6 @@ export function vm_semantics_of(op: number): ParticleOpSemantics;
  * @property {boolean} shareable two executions with equal operand values produce equal results, so a
  *   second one can read the first one's register instead. False for anything reading the record or
  *   the RNG.
- * @property {boolean} broadcasts every lane of the destination holds the same value, by construction
- *   rather than by what the operands happen to be. Lane `i` is then a copy of lane 0 and may be read
- *   as one.
  * @property {boolean} foldable the JS reference and the WGSL interpreter are both obliged to produce
  *   the *same bits* for this operation, so evaluating it here and baking a constant changes nothing
  *   on either. Correctly-rounded IEEE arithmetic qualifies; a transcendental does not — JS
@@ -79,12 +76,6 @@ export type ParticleOpSemantics = {
      * the RNG.
      */
     shareable: boolean;
-    /**
-     * every lane of the destination holds the same value, by construction
-     * rather than by what the operands happen to be. Lane `i` is then a copy of lane 0 and may be read
-     * as one.
-     */
-    broadcasts: boolean;
     /**
      * the JS reference and the WGSL interpreter are both obliged to produce
      * the *same bits* for this operation, so evaluating it here and baking a constant changes nothing

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

@@ -1 +1 @@
-{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AAoJA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAY/B;AAnKD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AAEH,+CAA+C;AAC/C,2BADW,IAAI,MAAM,EAAE,mBAAmB,CAAC,CACL;;;;;;;kBA7BxB,OAAO;;;;;cAGP,OAAO;;;;;;gBAEP,OAAO;;;;;;eAGP,OAAO;;;;;;gBAGP,OAAO;;;;;;;;cAGP,OAAO;;;;;;;;;;sBAKP,OAAO"}
+{"version":3,"file":"particle_vm_semantics.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/optimizer/particle_vm_semantics.js"],"names":[],"mappings":"AA4IA;;;;;;GAMG;AACH,oCAHW,MAAM,GACJ,mBAAmB,CAW/B;AA1JD;;;;;;;;;;;;;;;;;GAiBG;AAEH;;;;;;;;;;;;;;;;;;;;;;;;;GAyBG;AAEH,+CAA+C;AAC/C,2BADW,IAAI,MAAM,EAAE,mBAAmB,CAAC,CACL;;;;;;;kBA1BxB,OAAO;;;;;cAGP,OAAO;;;;;;gBAEP,OAAO;;;;;;eAGP,OAAO;;;;;;;;cAGP,OAAO;;;;;;;;;;sBAKP,OAAO"}

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

@@ -7,7 +7,7 @@ import { VM_OP } from "../isa/ParticleVMISA.js";
  * it — whether it can be deleted when its result is unread, narrowed when its high lanes are dead,
  * evaluated at compile time, or recognised as a recomputation of something already in a register.
  * Those are four different questions and an opcode can answer them differently: `LOAD_ATTR` is
- * removable but not shareable across a store, `RANDOM` is neither, and `CURVE` is both.
+ * removable but not shareable across a store, `RANDOM` is neither, and `LOAD_BUILTIN` is both.
  *
  * Every opcode has to appear in {@link VM_SEMANTICS} — the spec asserts it — because the safe
  * default for a new one is "assume nothing", and a table that silently omitted it would instead have
@@ -16,7 +16,7 @@ import { VM_OP } from "../isa/ParticleVMISA.js";
  * Which lane of a source feeds which lane of the result is not a property of the opcode any more:
  * every register operand carries a swizzle, and `vm_operand_slot` in the ISA answers it per operand.
  * What is left here is per-opcode: whether lane `i` of the result depends on lane `i` of the
- * sources alone (`lanewise`), and whether every lane of the result is the same value (`broadcasts`).
+ * sources alone (`lanewise`).
  */
 
 /**
@@ -32,9 +32,6 @@ import { VM_OP } from "../isa/ParticleVMISA.js";
  * @property {boolean} shareable two executions with equal operand values produce equal results, so a
  *   second one can read the first one's register instead. False for anything reading the record or
  *   the RNG.
- * @property {boolean} broadcasts every lane of the destination holds the same value, by construction
- *   rather than by what the operands happen to be. Lane `i` is then a copy of lane 0 and may be read
- *   as one.
  * @property {boolean} foldable the JS reference and the WGSL interpreter are both obliged to produce
  *   the *same bits* for this operation, so evaluating it here and baking a constant changes nothing
  *   on either. Correctly-rounded IEEE arithmetic qualifies; a transcendental does not — JS
@@ -62,7 +59,6 @@ function semantics(op, flags) {
         lanewise: false,
         narrowable: false,
         shareable: false,
-        broadcasts: false,
         foldable: false,
         foldable_inexact: false,
         ...flags,
@@ -141,10 +137,6 @@ semantics(VM_OP.SELECT, EXACT);
 // Ordered and side-effecting: it advances the shared RNG, and its width IS the number of draws it
 // takes. Removing, duplicating, reordering or narrowing one moves every value drawn after it.
 semantics(VM_OP.RANDOM, { side_effects: true });
-// An external WGSL symbol, but a pure function of (handle, t) — so a dead one goes and a repeated
-// one is shared. Every lane of the result is the same sample, which is what makes it narrowable —
-// and what makes it a broadcast, so a consumer reading it wide is a consumer that wants `.xxxx`.
-semantics(VM_OP.CURVE, { lanewise: true, narrowable: true, shareable: true, broadcasts: true });
 
 /**
  * What may be assumed about an opcode. An unknown one is assumed to do everything, so a new opcode
@@ -159,7 +151,6 @@ export function vm_semantics_of(op) {
         lanewise: false,
         narrowable: false,
         shareable: false,
-        broadcasts: false,
         foldable: false,
         foldable_inexact: false,
     };

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/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,+CAmBuC;0BAvBb,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,4 +21,25 @@ fn ssr_surface_history_uv(pixel: vec2f, velocity: vec2f, jitter_delta: vec2f, si
     return (pixel - velocity + jitter_delta) / size;
 }
 
+// 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_temporal_accumulate.d.ts.map

@@ -1 +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,sDAyHuH;0BApI7F,uCAAuC"}
+{"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"}

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

@@ -119,6 +119,10 @@ fn ssr_temporal_accumulate(current: vec4f, previous: vec4f, previous_age: f32,
     // well-supported long-term estimate. Do not leave it pinned to a clipped edge.
     let rectified = any(abs(previous.rgb-clipped) > vec3f(1e-5));
     if (rectified) { age = min(age, 2.0); }
+    // Confidence can force a much larger current contribution than 1/age.
+    // Carry that actual update rate into the age/variance pair too; otherwise a
+    // half-current blend can claim the uncertainty of a 65-frame accumulation.
+    age = min(age, 1.0 / max(1e-6, 1.0-saturate(confidence)));
     let weight = min(saturate(confidence), 1.0 - 1.0/age);
     let color = mix(current.rgb, clipped, weight);
     var result: SSRAccumulation;

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

@@ -1 +1 @@
-{"version":3,"file":"ssr_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_reproject_shader.js"],"names":[],"mappings":"AAoGA,+CAGG;4BAjGyB,6BAA6B"}
+{"version":3,"file":"ssr_reproject_shader.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/postprocess/ssr/ssr_reproject_shader.js"],"names":[],"mappings":"AAqGA,+CAGG;4BAlGyB,6BAA6B"}

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

@@ -65,7 +65,7 @@ fn main(@builtin(position) coord: vec4f) -> SSRTemporalOutput {
     var confidence = 0.0;
     var motion_confidence = 1.0;
     var history_uv = vec2f(0.0);
-    let virtual_eligible = settings.reprojection_mode != 1u && metadata.y >= 0.75 && metadata.x > 0.0 && is_finite(metadata.x) && roughness <= 0.2;
+    let virtual_eligible = settings.reprojection_mode != 1u && metadata.y >= 0.5 && metadata.x > 0.0 && is_finite(metadata.x) && roughness <= 0.2;
     if (virtual_eligible) {
         let uv = ssr_history_uv(virtual_position, camera_previous.view_projection_matrix);
         history_uv = uv;
@@ -81,6 +81,7 @@ fn main(@builtin(position) coord: vec4f) -> SSRTemporalOutput {
         history_uv = uv;
         history = ssr_sample_history(uv, position, normal, roughness, metadata, virtual_position, false, plane_tolerance);
         confidence = history.confidence * surface_confidence;
+        confidence *= ssr_surface_parallax_confidence(camera_position,position,metadata.x,camera_previous.view_projection_matrix,size);
         // Surface correspondence alone cannot justify a long history for a smooth finite reflection.
         if (virtual_eligible) { confidence *= 0.25; }
     }