@woosh/meep-engine 3.11.3 → 3.12.0

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

@@ -1,183 +1,190 @@
-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(/* 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]);
-
-/**
- * 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 descriptor = ShaderDescriptor.from({ label: "Particle Billboard", body, resources });
-    const code = descriptor.compile();
-
-    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 {
+    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(/* 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;

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":"AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,+CAHU,aAAa,CAG4B;AA0DnD,qDAKG;8BAjG2B,+BAA+B"}
+{"version":3,"file":"shader_particle_simulate.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_simulate.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,+CAHU,aAAa,CAG4B;AA0DnD,qDAIG;8BAhG2B,+BAA+B"}

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

@@ -1,100 +1,99 @@
-import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
-import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
-import { ComputeShader } from "../../shader/ComputeShader.js";
-import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
-import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
-import {
-    PARTICLE_RECORD_HEADER_EMITTER,
-    PARTICLE_RECORD_WORD_COUNT,
-    PARTICLE_VM_INSTRUCTION_WORDS,
-} from "../ParticleConstants.js";
-import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
-import { chunk_particle_context, chunk_particle_curve_disabled } from "./chunk_particle_context.js";
-
-/**
- * The particle simulate pass — Destiny-style single execution shader.
- *
- * One dispatch processes the entire alive list 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.
- *
- * The input length is read from `counters[ALIVE_IN]` — the previous frame's final alive count,
- * snapshotted on the GPU by the build-indirect pass — NOT from a CPU uniform. A CPU-provided count
- * is inevitably stale (readback latency) and corrupts the pool: under-counting orphans the tail of
- * the alive list (slots leak into limbo), over-counting re-simulates stale entries and double-frees
- * their slots. Dispatch this shader with `dispatchWorkgroupsIndirect` using the args the
- * build-indirect pass wrote last frame, so thread count and bound agree by construction.
- *
- * 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.
- *
- * @type {ComputeShader}
- */
-
-export const PARTICLE_SIMULATE_WORKGROUP_SIZE = 64;
-
-const resources = new ShaderResourceSetDescriptor();
-resources.createGroup()
-    .addStorageBuffer("emitters", WebGPUArray.u32, false)
-    .addStorageBuffer("program", WebGPUArray.u32, false)
-    .addStorageBuffer("vm_constants", WebGPUArray.u32, false)
-    .addStorageBuffer("pool", WebGPUArray.u32, true)
-    .addStorageBuffer("alive_in", WebGPUArray.u32, false)
-    .addStorageBuffer("alive_out", WebGPUArray.u32, true)
-    .addStorageBuffer("dead", WebGPUArray.u32, true)
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
-    .addUniform("u_dt", f32)
-    .addUniform("u_time", f32)
-    .addUniform("u_frame", u32);
-
-const body = CodeChunk.from(/* 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;
-
-@compute @workgroup_size(${PARTICLE_SIMULATE_WORKGROUP_SIZE}, 1, 1)
-fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
-    let i = gid.x;
-    // The exact alive-list length, snapshotted on-GPU last frame — never a stale CPU value.
-    if (i >= atomicLoad(&counters[COUNTER_ALIVE_IN])) { return; }
-
-    let slot = alive_in[i];
-    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, u_dt, u_time, 0.0, 0.0, u_frame);
-    particle_vm_execute(
-        &program,
-        em.update_offset * PARTICLE_INSTRUCTION_WORDS,
-        em.update_count,
-        &vm_constants,
-        em.constant_offset,
-        &pool,
-        record_base,
-    );
-
-    if (vm_killed) {
-        let d = atomicAdd(&counters[COUNTER_DEAD], 1u);
-        dead[d] = slot;
-    } else {
-        let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
-        alive_out[a] = slot;
-    }
-}
-`, [chunk_particle_context, chunk_particle_curve_disabled]);
-
-export const shader_particle_simulate = ComputeShader.from({
-    label: "Particle Simulate",
-    resources,
-    body,
-    group_size: [PARTICLE_SIMULATE_WORKGROUP_SIZE, 1, 1],
-});
+import { atomic_u32, f32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import {
+    PARTICLE_RECORD_HEADER_EMITTER,
+    PARTICLE_RECORD_WORD_COUNT,
+    PARTICLE_VM_INSTRUCTION_WORDS,
+} from "../ParticleConstants.js";
+import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
+import { chunk_particle_context, chunk_particle_curve_disabled } from "./chunk_particle_context.js";
+
+/**
+ * The particle simulate pass — Destiny-style single execution shader.
+ *
+ * One dispatch processes the entire alive list 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.
+ *
+ * The input length is read from `counters[ALIVE_IN]` — the previous frame's final alive count,
+ * snapshotted on the GPU by the build-indirect pass — NOT from a CPU uniform. A CPU-provided count
+ * is inevitably stale (readback latency) and corrupts the pool: under-counting orphans the tail of
+ * the alive list (slots leak into limbo), over-counting re-simulates stale entries and double-frees
+ * their slots. Dispatch this shader with `dispatchWorkgroupsIndirect` using the args the
+ * build-indirect pass wrote last frame, so thread count and bound agree by construction.
+ *
+ * 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.
+ *
+ * @type {ComputeShader}
+ */
+
+export const PARTICLE_SIMULATE_WORKGROUP_SIZE = 64;
+
+const resources = new ShaderResourceSetDescriptor();
+resources.createGroup()
+    .addStorageBuffer("emitters", WebGPUArray.u32, false)
+    .addStorageBuffer("program", WebGPUArray.u32, false)
+    .addStorageBuffer("vm_constants", WebGPUArray.u32, false)
+    .addStorageBuffer("pool", WebGPUArray.u32, true)
+    .addStorageBuffer("alive_in", WebGPUArray.u32, false)
+    .addStorageBuffer("alive_out", WebGPUArray.u32, true)
+    .addStorageBuffer("dead", WebGPUArray.u32, true)
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    .addUniform("u_dt", f32)
+    .addUniform("u_time", f32)
+    .addUniform("u_frame", u32);
+
+const body = CodeChunk.from(/* 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;
+
+@compute @workgroup_size(${PARTICLE_SIMULATE_WORKGROUP_SIZE}, 1, 1)
+fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
+    let i = gid.x;
+    // The exact alive-list length, snapshotted on-GPU last frame — never a stale CPU value.
+    if (i >= atomicLoad(&counters[COUNTER_ALIVE_IN])) { return; }
+
+    let slot = alive_in[i];
+    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, u_dt, u_time, 0.0, 0.0, u_frame);
+    particle_vm_execute(
+        &program,
+        em.update_offset * PARTICLE_INSTRUCTION_WORDS,
+        em.update_count,
+        &vm_constants,
+        em.constant_offset,
+        &pool,
+        record_base,
+    );
+
+    if (vm_killed) {
+        let d = atomicAdd(&counters[COUNTER_DEAD], 1u);
+        dead[d] = slot;
+    } else {
+        let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
+        alive_out[a] = slot;
+    }
+}
+`, [chunk_particle_context, chunk_particle_curve_disabled]);
+
+export const shader_particle_simulate = ComputeShader.from({
+    label: "Particle Simulate",
+    resources,
+    body,
+});

package/src/shade/renderer/particles/sort/shader_particle_sort.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/sort/shader_particle_sort.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,8CAA+C;AAyB/C,uDAKG;AA+DH,2DAKG;AA4BH,yDAKG;8BA9J2B,+BAA+B"}
+{"version":3,"file":"shader_particle_sort.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/sort/shader_particle_sort.js"],"names":[],"mappings":"AASA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,8CAA+C;AAyB/C,uDAIG;AA+DH,2DAIG;AA4BH,yDAIG;8BA3J2B,+BAA+B"}