@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -1,197 +1,132 @@
-import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
-import { ColorTargetState } from "../../../descriptor/pipeline/render/ColorTargetState.js";
-import { DepthStencilState } from "../../../descriptor/pipeline/render/DepthStencilState.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
-import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    PARTICLE_RECORD_HEADER_EMITTER,
-    PARTICLE_RECORD_WORD_COUNT,
-} from "../ParticleConstants.js";
-import { EMITTER_ATTRIBUTE_ABSENT, EMITTER_FLAG } from "../data/PARTICLE_EMITTER_LAYOUT.js";
-import { chunk_particle_emitter } from "../data/chunk_particle_emitter.js";
-import { chunk_particle_lighting_unlit } from "./chunk_particle_lighting.js";
-import { chunk_particle_render_math } from "./chunk_particle_render_math.js";
-
-/**
- * The billboard renderer.
- *
- * One instanced draw covers every visible particle: `instance_index` indexes the depth-`sorted` slot
- * list, `vertex_index` (0..5) picks a quad corner. The vertex stage reads the particle's render-bound
- * attributes (position / size / colour / rotation / flipbook frame), expands the corner per the
- * emitter's projection mode, and projects with the camera. The fragment stage samples the atlas
- * sub-rect + flipbook cell, applies an optional soft-depth fade against the scene depth, runs the
- * pluggable lighting hook (unlit by default; the feature swaps in the shading-chunk-backed one when
- * an emitter enables lighting), and emits premultiplied colour.
- *
- * A single blend state — `src*1 + dst*(1-srcAlpha)` on both channels — expresses alpha and additive
- * blending; the shader chooses per particle by how it premultiplies (see `particle_premultiply`), so
- * the whole draw stays GPU-driven with no pipeline switches.
- *
- * The math (billboard expansion, atlas/flipbook UV, soft fade, premultiply) is unit-tested in
- * {@link ./chunk_particle_render_math.spec.js}; this module assembles it into a render pipeline.
- */
-
-/** Premultiplied blend: additive when a=0 (dst preserved, colour adds), over-blend when a=srcAlpha. */
-export const PARTICLE_BILLBOARD_BLEND = {
-    color: { operation: "add", srcFactor: "one", dstFactor: "one-minus-src-alpha" },
-    alpha: { operation: "add", srcFactor: "one", dstFactor: "one-minus-src-alpha" },
-};
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
-    .addStorageBuffer("pool", WebGPUArray.u32, false)
-    .addStorageBuffer("sorted", WebGPUArray.u32, false)
-    .addStorageBuffer("emitters", WebGPUArray.u32, false)
-    // Sampled with a filtering sampler, so the atlas must be a filterable float texture.
-    .addTexture("atlas", "float")
-    .addSampler("atlas_sampler", "filtering")
-    // Only textureLoad-ed (soft depth), so it can be unfilterable — matches an r32float scene depth.
-    .addTexture("scene_depth", "unfilterable-float");
-
-const body = CodeChunk.from(
-    /* language=wgsl */ `
-const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
-const PARTICLE_HEADER_EMITTER : u32 = ${PARTICLE_RECORD_HEADER_EMITTER}u;
-const PARTICLE_ATTRIBUTE_ABSENT : u32 = ${EMITTER_ATTRIBUTE_ABSENT}u;
-const PARTICLE_FLAG_SOFT_DEPTH : u32 = ${EMITTER_FLAG.SOFT_DEPTH}u;
-const PARTICLE_FLAG_LIGHTING : u32 = ${EMITTER_FLAG.LIGHTING}u;
-const PARTICLE_SOFT_FADE_RANGE : f32 = 0.5;
-
-struct ParticleVertexOut {
-    @builtin(position) clip : vec4<f32>,
-    @location(0) uv : vec2<f32>,
-    @location(1) color : vec4<f32>,
-    @location(2) world_position : vec3<f32>,
-    @location(3) normal : vec3<f32>,
-    @location(4) view_depth : f32,
-    @location(5) @interpolate(flat) flags : u32,
-    @location(6) @interpolate(flat) blend : u32,
-}
-
-fn particle_read_vec(base : u32, offset : u32, count : u32) -> vec4<f32> {
-    var v = vec4<f32>(0.0);
-    if (count > 0u) { v.x = bitcast<f32>(pool[base + offset]); }
-    if (count > 1u) { v.y = bitcast<f32>(pool[base + offset + 1u]); }
-    if (count > 2u) { v.z = bitcast<f32>(pool[base + offset + 2u]); }
-    if (count > 3u) { v.w = bitcast<f32>(pool[base + offset + 3u]); }
-    return v;
-}
-
-@vertex
-fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
-    var corners = array<vec2<f32>, 6>(
-        vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, -1.0), vec2<f32>(1.0, 1.0),
-        vec2<f32>(-1.0, -1.0), vec2<f32>(1.0, 1.0), vec2<f32>(-1.0, 1.0),
-    );
-    let corner = corners[vi];
-
-    let slot = sorted[ii];
-    let base = slot * PARTICLE_RECORD_WORDS;
-    let emitter_index = pool[base + PARTICLE_HEADER_EMITTER];
-    let em = particle_emitter_read(&emitters, emitter_index);
-
-    var world_center = vec3<f32>(0.0);
-    if (em.render_position != PARTICLE_ATTRIBUTE_ABSENT) { world_center = particle_read_vec(base, em.render_position, 3u).xyz; }
-    var size = 1.0;
-    if (em.render_size != PARTICLE_ATTRIBUTE_ABSENT) { size = bitcast<f32>(pool[base + em.render_size]); }
-    var color = vec4<f32>(1.0);
-    if (em.render_color != PARTICLE_ATTRIBUTE_ABSENT) { color = particle_read_vec(base, em.render_color, 4u); }
-    var rotation = 0.0;
-    if (em.render_rotation != PARTICLE_ATTRIBUTE_ABSENT) { rotation = bitcast<f32>(pool[base + em.render_rotation]); }
-    var frame = 0.0;
-    if (em.render_frame != PARTICLE_ATTRIBUTE_ABSENT) { frame = bitcast<f32>(pool[base + em.render_frame]); }
-    var velocity = vec3<f32>(0.0);
-    if (em.render_velocity != PARTICLE_ATTRIBUTE_ABSENT) { velocity = particle_read_vec(base, em.render_velocity, 3u).xyz; }
-
-    let cam_right = camera.transform[0].xyz;
-    let cam_up = camera.transform[1].xyz;
-    let cam_forward = -camera.transform[2].xyz;
-
-    let offset = particle_billboard_offset(corner, size, rotation, cam_right, cam_up, cam_forward, velocity, particle_emitter_projection(em.flags));
-    let world = world_center + offset;
-
-    var out : ParticleVertexOut;
-    out.clip = camera.view_projection_matrix * vec4<f32>(world, 1.0);
-    out.uv = particle_atlas_uv(corner * 0.5 + vec2<f32>(0.5), em.atlas_region, em.flipbook, frame);
-    out.color = color;
-    out.world_position = world;
-    out.normal = -cam_forward;
-    out.view_depth = -(camera.view_matrix * vec4<f32>(world, 1.0)).z;
-    out.flags = em.flags;
-    out.blend = particle_emitter_blend(em.flags);
-    return out;
-}
-
-@fragment
-fn fs_main(in : ParticleVertexOut) -> @location(0) vec4<f32> {
-    let sampled = textureSample(atlas, atlas_sampler, in.uv);
-    var color = sampled * in.color;
-
-    if ((in.flags & PARTICLE_FLAG_SOFT_DEPTH) != 0u) {
-        let scene_dev = textureLoad(scene_depth, vec2<i32>(in.clip.xy), 0).r;
-        // Reverse-Z hyperbolic linearisation: view_depth = A / (device_depth + B).
-        let A = camera.device_depth_to_view_space.y;
-        let B = camera.device_depth_to_view_space.x;
-        let scene_vd = select(A / (scene_dev + B), 1e9, scene_dev <= 0.0);
-        color.a = color.a * particle_soft_fade(scene_vd, in.view_depth, PARTICLE_SOFT_FADE_RANGE);
-    }
-
-    if ((in.flags & PARTICLE_FLAG_LIGHTING) != 0u) {
-        color = particle_apply_lighting(color, in.world_position, normalize(in.normal));
-    }
-
-    return particle_premultiply(color, in.blend);
-}
-`, [chunk_particle_emitter, chunk_particle_render_math, chunk_particle_lighting_unlit]);
-
-/**
- * The shader itself. One compilation, shared by every pipeline built from it — the options below
- * vary the pipeline state, never the WGSL.
- *
- * @type {ShaderDescriptor}
- */
-const descriptor = ShaderDescriptor.from({ label: "Particle Billboard", body, resources });
-
-/**
- * Build the billboard render pipeline descriptor.
- * @param {object} [options]
- * @param {string} [options.color_format] colour target format
- * @param {string|null} [options.depth_format] scene depth format (test-only, no write); pass null to
- *   render without a depth attachment (e.g. an additive-only prototype with no scene geometry)
- * @param {GPUCompareFunction} [options.depth_compare] depth test — "greater"/"greater-equal" for
- *   reverse-Z scenes (the engine convention), "less"/"less-equal" for a standard-Z scene
- * @returns {RenderPipelineDescriptor}
- */
-export function create_particle_billboard_pipeline({
-                                                       color_format = "rgba16float",
-                                                       depth_format = "depth32float",
-                                                       depth_compare = "greater"
-} = {}) {
-
-    const code = descriptor.source;
-
-    return RenderPipelineDescriptor.from({
-        label: "Particle Billboard",
-        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
-        vertex: { module: { code }, entryPoint: "vs_main" },
-        fragment: {
-            module: { code },
-            entryPoint: "fs_main",
-            targets: [ColorTargetState.from({ format: color_format, blend: PARTICLE_BILLBOARD_BLEND })],
-        },
-        // Depth-test against the scene, but never write (transparent). Omitted entirely when no depth
-        // attachment is bound.
-        depthStencil: depth_format == null
-            ? undefined
-            : DepthStencilState.from({ format: depth_format, depthWriteEnabled: false, depthCompare: depth_compare }),
-        primitive: { topology: "triangle-list", cullMode: "none" },
-    });
-
-}
-
-/** The billboard shader's resource set (for building bind groups + the draw command). */
-export const PARTICLE_BILLBOARD_RESOURCES = resources;
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { ColorTargetState } from "../../../descriptor/pipeline/render/ColorTargetState.js";
+import { DepthStencilState } from "../../../descriptor/pipeline/render/DepthStencilState.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
+import { chunk_particle_billboard_vertex } from "./chunk_particle_billboard_vertex.js";
+import { chunk_particle_lighting_unlit } from "./chunk_particle_lighting.js";
+
+/**
+ * The standalone billboard renderer: particles drawn straight over the scene colour, back to
+ * front, with fixed-function blending. This is the path a page without the renderer's transparency
+ * pipeline uses; under the renderer the particles go through AVBOIT instead
+ * (`../graph_particles_avboit.js`), where order does not matter and they composite against the
+ * transparent meshes.
+ *
+ * One instanced draw covers every visible particle: `instance_index` indexes the depth-sorted
+ * `draw_list`, `vertex_index` (0..5) picks a quad corner. The vertex stage is `chunk_particle_billboard_vertex`,
+ * shared with the AVBOIT particle passes. The fragment stage samples the atlas sub-rect + flipbook
+ * cell, applies an optional soft-depth fade against the scene depth, runs the pluggable lighting hook
+ * (unlit by default; the feature swaps in the shading-chunk-backed one when an emitter enables
+ * lighting), and emits premultiplied colour.
+ *
+ * A single blend state — `src*1 + dst*(1-srcAlpha)` on both channels — expresses alpha and additive
+ * blending; the shader chooses per particle by how it premultiplies (see `particle_premultiply`), so
+ * the whole draw stays GPU-driven with no pipeline switches.
+ *
+ * The math (billboard expansion, atlas/flipbook UV, soft fade, premultiply) is unit-tested in
+ * {@link ./chunk_particle_render_math.spec.js}; this module assembles it into a render pipeline.
+ */
+
+/** Premultiplied blend: additive when a=0 (dst preserved, colour adds), over-blend when a=srcAlpha. */
+export const PARTICLE_BILLBOARD_BLEND = {
+    color: { operation: "add", srcFactor: "one", dstFactor: "one-minus-src-alpha" },
+    alpha: { operation: "add", srcFactor: "one", dstFactor: "one-minus-src-alpha" },
+};
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addStorageBuffer("pool", WebGPUArray.u32, false)
+    .addStorageBuffer("draw_list", WebGPUArray.u32, false)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
+    // Sampled with a filtering sampler, so the atlas must be a filterable float texture.
+    .addTexture("atlas", "float")
+    .addSampler("atlas_sampler", "filtering")
+    // Only textureLoad-ed (soft depth), so it can be unfilterable — matches an r32float scene depth.
+    .addTexture("scene_depth", "unfilterable-float");
+
+const body = CodeChunk.from(
+    /* language=wgsl */ `
+const PARTICLE_FLAG_SOFT_DEPTH : u32 = ${EMITTER_FLAG.SOFT_DEPTH}u;
+const PARTICLE_FLAG_LIGHTING : u32 = ${EMITTER_FLAG.LIGHTING}u;
+const PARTICLE_SOFT_FADE_RANGE : f32 = 0.5;
+
+@vertex
+fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_billboard_vertex(vi, ii);
+}
+
+@fragment
+fn fs_main(in : ParticleVertexOut) -> @location(0) vec4<f32> {
+    let sampled = textureSample(atlas, atlas_sampler, in.uv);
+    var color = sampled * in.color;
+
+    if ((in.flags & PARTICLE_FLAG_SOFT_DEPTH) != 0u) {
+        let scene_dev = textureLoad(scene_depth, vec2<i32>(in.clip.xy), 0).r;
+        // Reverse-Z hyperbolic linearisation: view_depth = A / (device_depth + B).
+        let A = camera.device_depth_to_view_space.y;
+        let B = camera.device_depth_to_view_space.x;
+        let scene_vd = select(A / (scene_dev + B), 1e9, scene_dev <= 0.0);
+        color.a = color.a * particle_soft_fade(scene_vd, in.view_depth, PARTICLE_SOFT_FADE_RANGE);
+    }
+
+    if ((in.flags & PARTICLE_FLAG_LIGHTING) != 0u) {
+        color = particle_apply_lighting(color, in.world_position, normalize(in.normal));
+    }
+
+    return particle_premultiply(color, in.blend);
+}
+`, [chunk_particle_billboard_vertex, chunk_particle_lighting_unlit]);
+
+/**
+ * The shader itself. One compilation, shared by every pipeline built from it — the options below
+ * vary the pipeline state, never the WGSL.
+ *
+ * @type {ShaderDescriptor}
+ */
+const descriptor = ShaderDescriptor.from({ label: "Particle Billboard", body, resources });
+
+/**
+ * Build the billboard render pipeline descriptor.
+ * @param {object} [options]
+ * @param {string} [options.color_format] colour target format
+ * @param {string|null} [options.depth_format] scene depth format (test-only, no write); pass null to
+ *   render without a depth attachment (e.g. an additive-only prototype with no scene geometry)
+ * @param {GPUCompareFunction} [options.depth_compare] depth test — "greater"/"greater-equal" for
+ *   reverse-Z scenes (the engine convention), "less"/"less-equal" for a standard-Z scene
+ * @returns {RenderPipelineDescriptor}
+ */
+export function create_particle_billboard_pipeline({
+                                                       color_format = "rgba16float",
+                                                       depth_format = "depth32float",
+                                                       depth_compare = "greater"
+} = {}) {
+
+    const code = descriptor.source;
+
+    return RenderPipelineDescriptor.from({
+        label: "Particle Billboard",
+        layout: resources.generatePipelineLayout(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+        vertex: { module: { code }, entryPoint: "vs_main" },
+        fragment: {
+            module: { code },
+            entryPoint: "fs_main",
+            targets: [ColorTargetState.from({ format: color_format, blend: PARTICLE_BILLBOARD_BLEND })],
+        },
+        // Depth-test against the scene, but never write (transparent). Omitted entirely when no depth
+        // attachment is bound.
+        depthStencil: depth_format == null
+            ? undefined
+            : DepthStencilState.from({ format: depth_format, depthWriteEnabled: false, depthCompare: depth_compare }),
+        primitive: { topology: "triangle-list", cullMode: "none" },
+    });
+
+}
+
+/** The billboard shader's resource set (for building bind groups + the draw command). */
+export const PARTICLE_BILLBOARD_RESOURCES = resources;

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

@@ -1,5 +1,13 @@
 export { PARTICLE_SIMULATE_WORKGROUP_SIZE };
+/**
+ * Per-dispatch, 12 bytes, read-only — see shader_particle_emit for why the three travel
+ * together rather than as three uniforms.
+ *
+ * @type {WebGPUStruct}
+ */
+export const SIMULATE_SETTINGS: WebGPUStruct;
 export const shader_particle_simulate: ComputeShader;
 import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "../ParticleConstants.js";
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_particle_simulate.d.ts.map

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":";AAyIA,qDAIG;iDAjII,yBAAyB;8BATF,+BAA+B"}
+{"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"}

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

@@ -1,43 +1,41 @@
+import { WebGPUExtensionType } from "../../../descriptor/WebGPUExtensionType.js";
 import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
 import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
 import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
 import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    PARTICLE_RECORD_HEADER_EMITTER,
-    PARTICLE_RECORD_WORD_COUNT,
-    PARTICLE_SIMULATE_WORKGROUP_SIZE,
-    PARTICLE_SIM_PAD_SLOT,
-    PARTICLE_VM_INSTRUCTION_WORDS,
-} from "../ParticleConstants.js";
+import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
-import { chunk_particle_context, chunk_particle_curve_disabled } from "./chunk_particle_context.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";
 
 /**
  * The particle simulate pass — Destiny-style single execution shader.
  *
- * One dispatch processes every live particle across every emitter. Per particle: read its owning
- * emitter, set up the VM context + RNG, run that emitter's compiled UPDATE program over the record,
- * then compact — killed particles are pushed back to the dead (free) list, survivors are appended to
- * the new alive list. There is exactly one pipeline regardless of how many distinct effects exist,
- * because behaviour is data (the bytecode program), not code.
+ * One dispatch processes every live particle across every emitter, one invocation each. Per
+ * particle: read its owning emitter, set up the VM context + RNG, run that emitter's compiled UPDATE
+ * program over the record, then compact — killed particles are pushed back to the dead (free) list,
+ * survivors are appended to the new alive list. There is exactly one pipeline regardless of how many
+ * distinct effects exist, because behaviour is data (the bytecode program), not code.
+ *
+ * The per-particle work is {@link ./chunk_particle_simulate_step.js}, shared with
+ * {@link ./shader_particle_simulate_wide.js}. What this file is, is the *fast* register backing plus
+ * the one-lane-per-particle dispatch that suits it. See
+ * {@link ../vm/chunk_particle_vm_registers_fast.js} for what "fast" costs and buys, and
+ * {@link ../ParticleConstants.js PARTICLE_VM_FAST_REGISTER_SLOTS} for when the system runs the other
+ * one instead.
  *
  * ## The input list
  *
  * `sim_list` is NOT the raw alive list. It is the program-coherent indirection list the coherence
  * pass (`../coherence/`) built at the end of last frame: the same pool slots, reordered so that
  * particles running one VM program sit together, each run padded out to a whole workgroup. That is
- * what keeps a wave from spanning two programs, which would make the interpreter's opcode `switch`
- * diverge and multiply the register file's `v_movrels` waterfall by the number of distinct register
- * indices in the wave.
- *
- * Padding entries carry {@link PARTICLE_SIM_PAD_SLOT} and are dropped BEFORE the compaction
- * atomics, so a padding lane never appends to the alive list and never pushes a slot onto the free
- * list — pushing the sentinel would put `0xffffffff` on the free list for a later emit to hand out
- * as a record base. Returning early is safe for the lanes that remain: padding only ever appears in
- * the tail of a bucket, and every real lane in that wave belongs to that one bucket, so the `switch`
- * the survivors execute is uniform regardless.
+ * what keeps a wave from spanning two programs — and this shader leans on it rather than merely
+ * benefiting from it: the section parameters are read from the wave's first lane, so a wave that
+ * held two programs would run one of them over the other's particles. The coherence pass is part of
+ * this shader's correctness, not only of its speed.
  *
  * ## Sizing
  *
@@ -64,7 +62,7 @@ export { PARTICLE_SIMULATE_WORKGROUP_SIZE };
  *
  * @type {WebGPUStruct}
  */
-const SIMULATE_SETTINGS = WebGPUStruct.from({
+export const SIMULATE_SETTINGS = WebGPUStruct.from({
     u_dt: f32,
     u_time: f32,
     u_frame: u32,
@@ -75,9 +73,9 @@ const resources = new ShaderResourceSetDescriptor();
 resources.setImmediate('settings', SIMULATE_SETTINGS);
 
 resources.createGroup()
-    .addStorageBuffer("emitters", WebGPUArray.u32, false)
+    .addStorageBuffer("scene_database", WebGPUArray.u32, false)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
     .addStorageBuffer("program", WebGPUArray.u32, false)
-    .addStorageBuffer("vm_constants", WebGPUArray.u32, false)
     .addStorageBuffer("pool", WebGPUArray.u32, true)
     .addStorageBuffer("sim_list", WebGPUArray.u32, false)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
@@ -86,13 +84,9 @@ resources.createGroup()
 
 
 const body = CodeChunk.from(/* language=wgsl */ `
-const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
-const PARTICLE_HEADER_EMITTER : u32 = ${PARTICLE_RECORD_HEADER_EMITTER}u;
-const PARTICLE_INSTRUCTION_WORDS : u32 = ${PARTICLE_VM_INSTRUCTION_WORDS}u;
 const COUNTER_ALIVE : u32 = ${PARTICLE_COUNTER.ALIVE}u;
 const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
 const COUNTER_ALIVE_IN : u32 = ${PARTICLE_COUNTER.ALIVE_IN}u;
-const PARTICLE_SIM_PAD_SLOT : u32 = ${PARTICLE_SIM_PAD_SLOT}u;
 
 @compute @workgroup_size(${PARTICLE_SIMULATE_WORKGROUP_SIZE}, 1, 1)
 fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
@@ -102,38 +96,30 @@ fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
 
     let slot = sim_list[i];
 
-    // A lane the coherence pass padded the bucket out with. Leave BEFORE the compaction atomics
-    // below: appending here would put the sentinel on the alive or the free list, and the free list
-    // would then hand 0xffffffff to an emit as a record base. The lanes that stay all belong to the
-    // one bucket this wave covers, so their program — and the interpreter's switch — is uniform.
-    if (slot == PARTICLE_SIM_PAD_SLOT) { return; }
-
-    let record_base = slot * PARTICLE_RECORD_WORDS;
-    let emitter_index = pool[record_base + PARTICLE_HEADER_EMITTER];
-
-    let em = particle_emitter_read(&emitters, emitter_index);
-
-    particle_vm_reset();
-    particle_setup_context(em, slot, settings.u_dt, settings.u_time, 0.0, 0.0, settings.u_frame);
-    particle_vm_execute(
-        &program,
-        em.update_offset * PARTICLE_INSTRUCTION_WORDS,
-        em.update_count,
-        &vm_constants,
-        em.constant_offset,
-        &pool,
-        record_base,
+    let verdict = particle_simulate_one(
+        &scene_database, &emitter_database, &program, &pool,
+        slot,
+        settings.u_dt, settings.u_time, settings.u_frame,
     );
 
-    if (vm_killed) {
-        let d = atomicAdd(&counters[COUNTER_DEAD], 1u);
-        dead[d] = slot;
-    } else {
+    // A padding lane's verdict is SKIP and books nothing. Appending it would put the padding
+    // sentinel on the alive or the free list, and the free list would then hand 0xffffffff to a
+    // later emit as a record base.
+    if (verdict == PARTICLE_SIM_ALIVE) {
         let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
         alive_out[a] = slot;
+    } else if (verdict == PARTICLE_SIM_KILLED) {
+        let d = atomicAdd(&counters[COUNTER_DEAD], 1u);
+        dead[d] = slot;
     }
 }
-`, [chunk_particle_context, chunk_particle_curve_disabled]);
+`, [
+    chunk_particle_simulate_step,
+    chunk_particle_vm_registers_fast,
+    chunk_particle_curve_disabled,
+]);
+
+body.addExtension(WebGPUExtensionType.Subgroups);
 
 export const shader_particle_simulate = ComputeShader.from({
     label: "Particle Simulate",

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

@@ -0,0 +1,45 @@
+/**
+ * The simulate pass over the WIDE register file — the fallback interpreter.
+ *
+ * Same simulation as {@link ./shader_particle_simulate.js}, down to the shared
+ * {@link ./chunk_particle_simulate_step.js}: one dispatch, every live particle, the emitter's UPDATE
+ * program, compaction into the alive and free lists. Two things differ, and both follow from the
+ * register file living in a storage buffer.
+ *
+ * ## The launch is bounded, and the loop is grid-stride
+ *
+ * The fast pass runs one invocation per particle and sizes its dispatch indirectly from
+ * `counters[ALIVE_IN]`. This one cannot: it needs a register file per invocation in flight, so
+ * one-lane-per-particle would size the register buffer by pool capacity — a gigabyte at a million
+ * particles.
+ *
+ * So it launches exactly {@link ../ParticleConstants.js PARTICLE_VM_WIDE_LAUNCH_LANES} lanes,
+ * whatever the particle count, and each walks `sim_list` in strides of that. The register buffer is
+ * then sized by a constant this engine chose rather than by a number the pool decides. There is no
+ * indirect command and no CPU-side count: the launch is fixed, and the loop bound is still the
+ * on-GPU `counters[ALIVE_IN]` snapshot, read in the shader exactly as before. Every guarantee the
+ * fast pass's sizing comment describes holds here for the same reason.
+ *
+ * The stride is a whole number of workgroups, which is what keeps the coherence pass's bucketing
+ * intact: each iteration covers a workgroup-aligned span of `sim_list`, so a wave still sees one
+ * program and the wave-uniform section decode is still sound. That decode is worth keeping even
+ * here — it is what makes the instruction fetch and the opcode switch scalar. Only the register
+ * indexing goes per-lane, because in this backing it always is.
+ *
+ * ## Nine storage buffers
+ *
+ * The fast passes fit in the eight a stage gets by default; this one adds `vm_registers` and needs
+ * nine. That is inside what the engine already demands of an adapter — {@link
+ * ../../Renderer.js} refuses one offering fewer than ten — so it costs no new capability, but it is
+ * why the particle system's "everything fits in eight" note does not cover this shader.
+ *
+ * @type {ComputeShader}
+ */
+/**
+ * Workgroups this pass dispatches. Constant: the launch does not depend on the particle count.
+ * @type {number}
+ */
+export const PARTICLE_SIMULATE_WIDE_WORKGROUP_COUNT: number;
+export const shader_particle_simulate_wide: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_particle_simulate_wide.d.ts.map

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

@@ -0,0 +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"}