@woosh/meep-engine 3.15.0 → 3.17.0

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

@@ -0,0 +1,124 @@
+import { atomic_u32, u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { chunk_cluster_depth_to_z_slice } from "../../light/cluster/chunk_cluster_depth_to_z_slice.js";
+import { AVBOIT_OCCUPANCY_WORDS, AVBOIT_VIRTUAL_SLICES_MAX } from "../../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
+import { chunk_avboit_occupancy_range } from "../../rasterize/native/avboit/chunk_avboit_occupancy_range.js";
+import { chunk_avboit_occupancy_word_mask } from "../../rasterize/native/avboit/chunk_avboit_occupancy_word_mask.js";
+import { AVBOIT_OCCUPANCY_SETTINGS_STRUCT } from "../../rasterize/native/avboit/shader_avboit_occupancy.js";
+import { chunk_scene_database_access } from "../../scene/chunk_scene_database_access.js";
+import { ComputeShader } from "../../shader/ComputeShader.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { PARTICLE_EMITTER_TICK_WORKGROUP_SIZE } from "../ParticleConstants.js";
+import { PARTICLE_EMITTER_DESCRIPTOR } from "../data/PARTICLE_DATABASE_SPEC.js";
+import { EMITTER_BLEND } from "../data/PARTICLE_EMITTER_STRUCT.js";
+import { chunk_particle_emitter_world_sphere } from "./chunk_particle_emitter_world_sphere.js";
+
+/**
+ * The particles' AVBOIT occupancy: one thread per emitter table row, marking the virtual depth
+ * slices the emitter's bounds sphere spans, so the warp keeps resolution where the particles are.
+ * The particle counterpart of `shader_avboit_occupancy`, which does the same per meshlet AABB.
+ *
+ * Per emitter rather than per particle: the sphere is the bound the author gave the emitter (the
+ * one the tick culls with), it is one thread per row instead of one per live particle contending
+ * for the same few words, and a particle that strays past it is not lost — it lands on the
+ * boundary of the nearest run, the warp's flat-in-a-gap property. Emitters that only add light
+ * (`EMITTER_BLEND.ADDITIVE`) splat no extinction and mark nothing: a slice reserved for them would
+ * be a slice the surfaces do not get.
+ *
+ * The sphere goes to view space through the node's `global`; the camera looks down −Z, so the
+ * depth interval is `[-(c.z) - r, -(c.z) + r]`, clamped at the near plane, through the same depth
+ * curve and dilation the meshlet pass uses.
+ *
+ * Walks the table with its page iterator, read-only: the rows are the tick's output of this frame.
+ *
+ * @type {ComputeShader}
+ */
+
+const GROUP_SIZE = PARTICLE_EMITTER_TICK_WORKGROUP_SIZE;
+
+const PG = PARTICLE_EMITTER_DESCRIPTOR.page_iterator_symbol_prefix(GROUP_SIZE);
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addUniform("settings", AVBOIT_OCCUPANCY_SETTINGS_STRUCT)
+    .addStorageBuffer("scene_database", WebGPUArray.from(u32))
+    .addStorageBuffer("emitter_database", WebGPUArray.from(u32))
+    .addStorageBuffer("occupancy", WebGPUArray.from(atomic_u32, AVBOIT_OCCUPANCY_WORDS), true);
+
+const body = CodeChunk.from(
+    //language=WGSL
+    `
+const PARTICLE_BLEND_ADDITIVE : u32 = ${EMITTER_BLEND.ADDITIVE}u;
+
+@compute @workgroup_size(${GROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(workgroup_id) wg_id : vec3<u32>,
+    @builtin(local_invocation_index) local_id : u32,
+) {
+    // page_address is uniform across the workgroup, so this branch is uniform.
+    if (!${PG}_setup(&emitter_database, wg_id.x, local_id)) {
+        return;
+    }
+
+    let slot_in_page = ${PG}_slot_in_page(local_id);
+
+    if (slot_in_page >= ${PG}_ELEMENTS_PER_PAGE || !${PG}_is_occupied(slot_in_page)) {
+        return;
+    }
+
+    let em = ${PG}_read(&emitter_database, slot_in_page);
+
+    if (particle_emitter_blend(em.flags) == PARTICLE_BLEND_ADDITIVE) {
+        // adds light, occludes nothing: no extinction to place
+        return;
+    }
+
+    let node = scene_read_node(&scene_database, em.node);
+    let sphere = particle_emitter_world_sphere(em, node.global);
+
+    let center_view = (camera.view_matrix * vec4<f32>(sphere.xyz, 1.0)).xyz;
+
+    // camera looks down -Z
+    let depth_min = -center_view.z - sphere.w;
+    let depth_max = -center_view.z + sphere.w;
+
+    if (depth_max < camera.clip_near_far.x) {
+        // entirely in front of the near plane
+        return;
+    }
+
+    let limit = ${AVBOIT_VIRTUAL_SLICES_MAX}.0;
+    let slice_near = cluster_depth_to_z_slice(max(depth_min, camera.clip_near_far.x), settings.cluster_parameters, limit);
+    let slice_far = cluster_depth_to_z_slice(depth_max, settings.cluster_parameters, limit);
+
+    let range = avboit_occupancy_range(slice_near, slice_far);
+
+    let word_first = u32(range.x) >> 5u;
+    let word_last = u32(range.y) >> 5u;
+
+    for (var word = word_first; word <= word_last; word++) {
+        let mask = avboit_occupancy_word_mask(word, range.x, range.y);
+        if (mask != 0u) {
+            atomicOr(&occupancy[word], mask);
+        }
+    }
+}
+    `, [
+        PARTICLE_EMITTER_DESCRIPTOR.chunk_iterate(GROUP_SIZE),
+        chunk_particle_emitter_world_sphere,
+        chunk_scene_database_access,
+        chunk_cluster_depth_to_z_slice,
+        chunk_avboit_occupancy_range,
+        chunk_avboit_occupancy_word_mask,
+    ]
+);
+
+export const shader_particle_avboit_occupancy = ComputeShader.from({
+    label: "Particle AVBOIT Occupancy",
+    resources,
+    body,
+});

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

@@ -0,0 +1,19 @@
+/**
+ * Bind group of the volume atomics; group 0 is everything the billboard vertex stage and the atlas
+ * need.
+ * @type {number}
+ */
+export const PARTICLE_AVBOIT_SPLAT_BIND_GROUP_VOLUME: number;
+/**
+ * The splat pipeline: no depth, one never-written attachment to size the raster.
+ * @type {RenderPipelineDescriptor}
+ */
+export const PARTICLE_AVBOIT_SPLAT_PIPELINE: RenderPipelineDescriptor;
+/** The splat shader's resource set, for building its bind groups against the layout above. */
+export const PARTICLE_AVBOIT_SPLAT_RESOURCES: ShaderResourceSetDescriptor;
+/** The assembled shader, for the validity tier. */
+export const shader_particle_avboit_splat: ShaderDescriptor;
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+//# sourceMappingURL=shader_particle_avboit_splat.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"shader_particle_avboit_splat.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_avboit_splat.js"],"names":[],"mappings":"AAoBA;;;;GAIG;AACH,sDAFU,MAAM,CAEyC;AAqGzD;;;GAGG;AACH,6CAFU,wBAAwB,CAY/B;AAEH,8FAA8F;AAC9F,0EAAyD;AAEzD,mDAAmD;AACnD,4DAAuD;yCAjJd,iEAAiE;4CAY9D,sDAAsD;iCAFjE,kCAAkC"}

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

@@ -0,0 +1,147 @@
+import { PipelineLayoutDescriptor } from "../../../descriptor/pipeline/PipelineLayoutDescriptor.js";
+import { RenderPipelineDescriptor } from "../../../descriptor/pipeline/render/RenderPipelineDescriptor.js";
+import { atomic_u32 } from "../../shader/type/WEBGPU_WGSL_PRIMITIVE_TYPES.js";
+import { WebGPUArray } from "../../shader/type/WebGPUArray.js";
+import { CAMERA_UNIFORM_STRUCT } from "../../camera/CAMERA_UNIFORM_STRUCT.js";
+import { OIT_COVERAGE_MAX } from "../../rasterize/native/oit/OIT_CONSTANTS.js";
+import { AVBOIT_WARP_STRUCT } from "../../rasterize/native/avboit/AVBOIT_WARP_STRUCT.js";
+import { chunk_avboit_splat_slice } from "../../rasterize/native/avboit/chunk_avboit_splat_slice.js";
+import { chunk_avboit_transmittance_to_extinction } from "../../rasterize/native/avboit/chunk_avboit_transmittance_to_extinction.js";
+import { chunk_avboit_view_depth_to_physical } from "../../rasterize/native/avboit/chunk_avboit_view_depth_to_physical.js";
+import { AVBOIT_SPLAT_DUMMY_FORMAT } from "../../rasterize/native/avboit/shader_avboit_splat.js";
+import { ShaderDescriptor } from "../../shader/ShaderDescriptor.js";
+import { CodeChunk } from "../../shader/compiler/CodeChunk.js";
+import { ShaderResourceSetDescriptor } from "../../shader/resource/ShaderResourceSetDescriptor.js";
+import { PARTICLE_SOFT_FADE_RANGE } from "../ParticleConstants.js";
+import { EMITTER_FLAG } from "../data/PARTICLE_EMITTER_STRUCT.js";
+import { AVBOIT_VOXEL_DOWNSCALE } from "../../rasterize/native/avboit/AVBOIT_CONSTANTS.js";
+import { chunk_particle_billboard_vertex } from "./chunk_particle_billboard_vertex.js";
+import { chunk_particle_scene_view_depth } from "./chunk_particle_scene_view_depth.js";
+
+/**
+ * Bind group of the volume atomics; group 0 is everything the billboard vertex stage and the atlas
+ * need.
+ * @type {number}
+ */
+export const PARTICLE_AVBOIT_SPLAT_BIND_GROUP_VOLUME = 1;
+
+/**
+ * The particles' AVBOIT splat: the billboard quads rasterized at the volume's resolution, each
+ * fragment's extinction added into the voxel volume through `avboit_splat_slice` — the same write
+ * path as the meshlet splat, so a particle and a surface at one depth pile up in one field.
+ *
+ * Coverage is the sampled atlas alpha times the particle's colour alpha, capped like a surface's;
+ * `T_self = 1 - coverage`, untinted. An additive particle (`particle_premultiply` would give it
+ * alpha 0) covers nothing and writes nothing.
+ *
+ * Depth is the fragment's own view depth, from the vertex stage, through curve → warp → physical
+ * and the two-slice linear splat. No depth attachment, for the reason the meshlet splat has none.
+ *
+ * The `draw_list` this binds is the alive list, unsorted: the volume does not care about order.
+ */
+
+const resources = new ShaderResourceSetDescriptor();
+
+resources.createGroup()
+    .addUniform("camera", CAMERA_UNIFORM_STRUCT)
+    .addStorageBuffer("warp", AVBOIT_WARP_STRUCT)
+    .addStorageBuffer("pool", WebGPUArray.u32, false)
+    .addStorageBuffer("draw_list", WebGPUArray.u32, false)
+    .addStorageBuffer("emitter_database", WebGPUArray.u32, false)
+    .addTexture("atlas", "float")
+    .addSampler("atlas_sampler", "filtering")
+    .addTexture("scene_depth", "unfilterable-float");
+
+resources.createGroup()
+    .addStorageBuffer("extinction_volume", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("overflow_slice", WebGPUArray.from(atomic_u32), true);
+
+const body = CodeChunk.from(
+    /* language=wgsl */ `
+@vertex
+fn vs_main(@builtin(vertex_index) vi : u32, @builtin(instance_index) ii : u32) -> ParticleVertexOut {
+    return particle_billboard_vertex(vi, ii);
+}
+
+const PARTICLE_FLAG_SOFT_DEPTH : u32 = ${EMITTER_FLAG.SOFT_DEPTH}u;
+
+@fragment
+fn fs_main(in : ParticleVertexOut) {
+    let premultiplied = particle_premultiply(textureSample(atlas, atlas_sampler, in.uv) * in.color, in.blend);
+
+    var alpha = premultiplied.a;
+
+    if ((in.flags & PARTICLE_FLAG_SOFT_DEPTH) != 0u) {
+        /*
+         The same fade the draw applies to the same fragment, so the volume records the coverage the
+         accumulators are weighted by. Sampled once per voxel: this pass rasterizes at the volume's
+         resolution, so the scene texel under the fragment is the downscale factor times out.
+        */
+        let scene_texel = vec2<i32>(in.clip.xy) * ${AVBOIT_VOXEL_DOWNSCALE};
+        let scene_vd = particle_scene_view_depth(textureLoad(scene_depth, scene_texel, 0).r, camera);
+
+        alpha = alpha * particle_soft_fade(scene_vd, in.view_depth, ${PARTICLE_SOFT_FADE_RANGE});
+    }
+
+    let coverage = clamp(alpha, 0.0, ${OIT_COVERAGE_MAX});
+
+    if (coverage <= 0.0) {
+        // additive, faded out against the surface behind it, or fully transparent: occludes nothing
+        return;
+    }
+
+    let extinction = avboit_transmittance_to_extinction(vec3<f32>(1.0 - coverage));
+
+    let p = avboit_view_depth_to_physical(&warp, in.view_depth);
+
+    // in.clip is @builtin(position): .xy the low-resolution pixel
+    let texel = vec2<u32>(in.clip.xy);
+    let column = (texel.y * warp.voxel_width + texel.x) * warp.physical_count;
+
+    // linear splat between the two slices around the fragment
+    let c = p - 0.5;
+    let slice = i32(floor(c));
+    let fraction = c - floor(c);
+
+    avboit_splat_slice(column, slice, extinction * (1.0 - fraction), texel);
+    avboit_splat_slice(column, slice + 1, extinction * fraction, texel);
+}
+`, [
+    chunk_particle_billboard_vertex,
+    chunk_particle_scene_view_depth,
+    chunk_avboit_transmittance_to_extinction,
+    chunk_avboit_view_depth_to_physical,
+    chunk_avboit_splat_slice,
+]);
+
+const descriptor = ShaderDescriptor.from({ label: "Particle AVBOIT Splat", body, resources });
+
+// Built group by group: the atomics are fragment-only, and WebGPU refuses a read-write storage
+// buffer that is visible to the vertex stage.
+const groups = resources.groups;
+const layout = PipelineLayoutDescriptor.from([
+    groups[0].generateBindGroupLayoutDescriptor(GPUShaderStage.VERTEX | GPUShaderStage.FRAGMENT),
+    groups[PARTICLE_AVBOIT_SPLAT_BIND_GROUP_VOLUME].generateBindGroupLayoutDescriptor(GPUShaderStage.FRAGMENT),
+], resources.immediateSize);
+
+/**
+ * The splat pipeline: no depth, one never-written attachment to size the raster.
+ * @type {RenderPipelineDescriptor}
+ */
+export const PARTICLE_AVBOIT_SPLAT_PIPELINE = RenderPipelineDescriptor.from({
+    label: "Particle AVBOIT Splat",
+    layout,
+    vertex: { module: { code: descriptor.source }, entryPoint: "vs_main" },
+    fragment: {
+        module: { code: descriptor.source },
+        entryPoint: "fs_main",
+        targets: [{ format: AVBOIT_SPLAT_DUMMY_FORMAT, writeMask: 0 }],
+    },
+    primitive: { topology: "triangle-list", cullMode: "none" },
+});
+
+/** The splat shader's resource set, for building its bind groups against the layout above. */
+export const PARTICLE_AVBOIT_SPLAT_RESOURCES = resources;
+
+/** The assembled shader, for the validity tier. */
+export const shader_particle_avboit_splat = descriptor;

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

@@ -1,17 +1,36 @@
 /**
- * The particle emit (spawn) pass.
+ * The particle emit pass: one thread per particle born this frame.
  *
- * Input is a flat list of spawn requests (one packed emitter-index + batch-fraction per particle
- * to create; built by ParticleSpawnScheduler). Per request: pop a free slot from the dead
- * list, clear the record, stamp the owning emitter, run that emitter's compiled SPAWN program to
- * initialise the particle's user-defined state, then append the slot to the new alive list.
+ * Its input is the prefix scan of the emitter tick pass's per-row spawn counts; thread `i` finds the
+ * emitter it belongs to by binary search over the inclusive sums, and its place within that
+ * emitter's batch from the sum before. Then: pop a free slot from the dead list, clear the record,
+ * stamp the header, run the emitter's INIT program, and append the slot to the new alive list.
  *
- * Runs after simulate in the frame so newly born particles join the same alive list the survivors
- * were compacted into. Shares the VM + context + emitter chunks with simulate.
+ * The per-newborn work is {@link ./chunk_particle_emit_step.js}, shared with
+ * {@link ./shader_particle_emit_wide.js}. What this file is, is the *fast* register backing plus the
+ * one-lane-per-newborn dispatch that suits it.
+ *
+ * Runs before simulate in the frame so newborns join the same alive list survivors are compacted
+ * into. Shares the VM + context + emitter chunks with simulate.
  *
  * @type {ComputeShader}
  */
-export const PARTICLE_EMIT_WORKGROUP_SIZE: ComputeShader;
+/**
+ * Sized by `shader_prefix_sum_to_command`, which turns the scan's total into workgroups of this
+ * size — so the two must agree, and the constant it uses is the one it is.
+ */
+export const PARTICLE_EMIT_WORKGROUP_SIZE: number;
+/**
+ * Per-dispatch, 16 bytes, read-only.
+ *
+ * These were separate uniforms, which meant a transient buffer, a staging copy and a bind group
+ * entry each for a few bytes of frame state. WGSL allows one immediate per entry point, so carrying
+ * them as immediate data means carrying them together.
+ *
+ * @type {WebGPUStruct}
+ */
+export const EMIT_SETTINGS: WebGPUStruct;
 export const shader_particle_emit: ComputeShader;
+import { WebGPUStruct } from "../../shader/type/WebGPUStruct.js";
 import { ComputeShader } from "../../shader/ComputeShader.js";
 //# sourceMappingURL=shader_particle_emit.d.ts.map

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":"AAoBA;;;;;;;;;;;;GAYG;AAEH,2CAHU,aAAa,CAGwB;AA+F/C,iDAIG;8BAlI2B,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAaA;;;;;;;;;;;;;;;;GAgBG;AAEH;;;GAGG;AACH,kDAA8E;AAE9E;;;;;;;;GAQG;AACH,4BAFU,YAAY,CAOK;AAqD3B,iDAIG;6BA1G0B,mCAAmC;8BAGlC,+BAA+B"}

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

@@ -1,53 +1,53 @@
 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 { COLLECTION_U32_STRUCT_READ } from "../../gpu_primitive/COLLECTION_U32_STRUCT_READ.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
 import { 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_USER_WORD_START,
-    PARTICLE_RECORD_WORD_COUNT,
-    PARTICLE_VM_INSTRUCTION_WORDS,
-} from "../ParticleConstants.js";
 import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
-import {
-    SPAWN_REQUEST_EMITTER_MASK,
-    SPAWN_REQUEST_FRACTION_MAX,
-    SPAWN_REQUEST_FRACTION_SHIFT,
-} from "../runtime/spawn_request_encoding.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_emit_step } from "./chunk_particle_emit_step.js";
 
 /**
- * The particle emit (spawn) pass.
+ * The particle emit pass: one thread per particle born this frame.
  *
- * Input is a flat list of spawn requests (one packed emitter-index + batch-fraction per particle
- * to create; built by ParticleSpawnScheduler). Per request: pop a free slot from the dead
- * list, clear the record, stamp the owning emitter, run that emitter's compiled SPAWN program to
- * initialise the particle's user-defined state, then append the slot to the new alive list.
+ * Its input is the prefix scan of the emitter tick pass's per-row spawn counts; thread `i` finds the
+ * emitter it belongs to by binary search over the inclusive sums, and its place within that
+ * emitter's batch from the sum before. Then: pop a free slot from the dead list, clear the record,
+ * stamp the header, run the emitter's INIT program, and append the slot to the new alive list.
  *
- * Runs after simulate in the frame so newly born particles join the same alive list the survivors
- * were compacted into. Shares the VM + context + emitter chunks with simulate.
+ * The per-newborn work is {@link ./chunk_particle_emit_step.js}, shared with
+ * {@link ./shader_particle_emit_wide.js}. What this file is, is the *fast* register backing plus the
+ * one-lane-per-newborn dispatch that suits it.
+ *
+ * Runs before simulate in the frame so newborns join the same alive list survivors are compacted
+ * into. Shares the VM + context + emitter chunks with simulate.
  *
  * @type {ComputeShader}
  */
 
-export const PARTICLE_EMIT_WORKGROUP_SIZE = 64;
+/**
+ * Sized by `shader_prefix_sum_to_command`, which turns the scan's total into workgroups of this
+ * size — so the two must agree, and the constant it uses is the one it is.
+ */
+export const PARTICLE_EMIT_WORKGROUP_SIZE = COMPUTE_SHADER_DEFAULT_GROUP_SIZE;
 
 /**
- * Per-dispatch, 20 bytes, read-only.
+ * Per-dispatch, 16 bytes, read-only.
  *
- * These were five separate uniforms, which meant five transient buffers, five staging copies and
- * five bind group entries for twenty bytes of frame state. WGSL allows one immediate per entry
- * point, so carrying them as immediate data means carrying them together.
+ * These were separate uniforms, which meant a transient buffer, a staging copy and a bind group
+ * entry each for a few bytes of frame state. WGSL allows one immediate per entry point, so carrying
+ * them as immediate data means carrying them together.
  *
  * @type {WebGPUStruct}
  */
-const EMIT_SETTINGS = WebGPUStruct.from({
+export const EMIT_SETTINGS = WebGPUStruct.from({
     u_dt: f32,
     u_time: f32,
     u_frame: u32,
-    u_count: u32,
     u_capacity: u32,
 }, 'ParticleEmitSettings');
 
@@ -56,76 +56,51 @@ const resources = new ShaderResourceSetDescriptor();
 resources.setImmediate('settings', EMIT_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("spawn_prefix", COLLECTION_U32_STRUCT_READ, false)
     .addStorageBuffer("pool", WebGPUArray.u32, true)
-    .addStorageBuffer("spawn_requests", WebGPUArray.u32, false)
     .addStorageBuffer("alive_out", WebGPUArray.u32, true)
     .addStorageBuffer("dead", WebGPUArray.u32, true)
     .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
+
 const body = CodeChunk.from(
     /* language=wgsl */
     `
-const PARTICLE_RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
-const PARTICLE_USER_WORD_START : u32 = ${PARTICLE_RECORD_USER_WORD_START}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;
 
 @compute @workgroup_size(${PARTICLE_EMIT_WORKGROUP_SIZE}, 1, 1)
 fn main(@builtin(global_invocation_id) gid : vec3<u32>) {
     let i = gid.x;
-    if (i >= settings.u_count) { return; }
 
-    // Packed request: low 16 bits = emitter index, high 16 = batch fraction (see
-    // spawn_request_encoding.js). The fraction is LOCAL to this emitter's batch this frame
-    // (SPAWN_FRACTION contract: n / spawn_count), not the global request index / settings.u_count.
-    let request = spawn_requests[i];
-    let emitter_index = request & ${SPAWN_REQUEST_EMITTER_MASK}u;
-    let spawn_fraction = f32(request >> ${SPAWN_REQUEST_FRACTION_SHIFT}u) / ${SPAWN_REQUEST_FRACTION_MAX}.0;
+    let assignment = particle_emit_assignment(&spawn_prefix.elements, spawn_prefix.count, i);
+    if (!assignment.valid) { return; }
 
-    // Pop a free slot off the dead-list stack; drop the spawn if the pool is exhausted.
-    //
-    // The guard must catch WRAPPED values, not just 0: when many threads race an empty stack, the
-    // first over-pop wraps the counter to 0xFFFFFFFF before its undo lands, and a concurrent thread
-    // then observes a huge old value. Checking only ==0 would let it index dead[old-1] with garbage
-    // and hand out a bogus slot, corrupting a live record. The dead count can never legitimately
-    // exceed the pool capacity, so >settings.u_capacity identifies every wrapped state; each thread that
-    // subtracted also adds back exactly once, so the counter converges to 0.
+    // Pop a free slot off the dead-list stack; drop the spawn if the pool is exhausted. The guard
+    // catches WRAPPED values, not just 0 — see chunk_particle_emit_step for why that matters.
     let old_dead = atomicSub(&counters[COUNTER_DEAD], 1u);
     if (old_dead == 0u || old_dead > settings.u_capacity) {
         atomicAdd(&counters[COUNTER_DEAD], 1u); // undo the over-pop
         return;
     }
     let slot = dead[old_dead - 1u];
-    let record_base = slot * PARTICLE_RECORD_WORDS;
-
-    // Clear stale user state from a recycled slot (each write targets a distinct word).
-    for (var w = PARTICLE_USER_WORD_START; w < PARTICLE_RECORD_WORDS; w = w + 1u) {
-        pool[record_base + w] = 0u;
-    }
-    pool[record_base + PARTICLE_HEADER_EMITTER] = emitter_index;
-
-    let em = particle_emitter_read(&emitters, emitter_index);
 
-    particle_vm_reset();
-    particle_setup_context(em, slot, settings.u_dt, settings.u_time, 0.0, spawn_fraction, settings.u_frame);
-    particle_vm_execute(
-        &program,
-        em.spawn_offset * PARTICLE_INSTRUCTION_WORDS,
-        em.spawn_count,
-        &vm_constants,
-        em.constant_offset,
-        &pool,
-        record_base,
+    particle_emit_one(
+        &scene_database, &emitter_database, &program, &pool,
+        assignment.emitter_row, slot, assignment.spawn_fraction,
+        settings.u_dt, settings.u_time, settings.u_frame,
     );
 
     let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
     alive_out[a] = slot;
 }
-`, [chunk_particle_context, chunk_particle_curve_disabled]);
+`, [
+    chunk_particle_emit_step,
+    chunk_particle_vm_registers_fast,
+    chunk_particle_curve_disabled,
+]);
 
 export const shader_particle_emit = ComputeShader.from({
     label: "Particle Emit",

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

@@ -0,0 +1,33 @@
+/**
+ * The emit pass over the WIDE register file — the fallback interpreter's spawn half.
+ *
+ * Same emission as {@link ./shader_particle_emit.js}, down to the shared
+ * {@link ./chunk_particle_emit_step.js}. It differs in the same way
+ * {@link ./shader_particle_simulate_wide.js} does: a bounded launch of
+ * {@link ../ParticleConstants.js PARTICLE_VM_WIDE_LAUNCH_LANES} lanes with a grid-stride loop, so
+ * the storage register file is sized by a constant rather than by how many particles happen to be
+ * born this frame.
+ *
+ * It therefore does not consume the indirect command the prefix scan produces for the fast pass. The
+ * scan's total is read in the shader as the loop bound instead, which is the same number from the
+ * same buffer — just used as a bound rather than as a dispatch size.
+ *
+ * The register file is indexed by launch lane, so it is reused across the loop's iterations. That is
+ * sound for the same reason it is never cleared: an INIT program writes a register before it reads
+ * it, so nothing carries between one newborn and the next. See
+ * {@link ../vm/chunk_particle_vm_registers_wide.js}.
+ *
+ * Emit's waves span emitters by construction, so — unlike simulate — there was never a wave-uniform
+ * decode here to lose.
+ *
+ * @type {ComputeShader}
+ */
+/**
+ * Workgroups this pass dispatches. Constant: the launch does not depend on how many particles are
+ * born this frame.
+ * @type {number}
+ */
+export const PARTICLE_EMIT_WIDE_WORKGROUP_COUNT: number;
+export const shader_particle_emit_wide: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_particle_emit_wide.d.ts.map

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

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