@woosh/meep-engine 3.60.9 → 3.61.1

package/src/shade/renderer/particles/GPUParticleSystem.js

@@ -35,6 +35,17 @@ import { WARMUP_QUEUE } from "./warmup/shader_particle_warmup.js";
 import { warmup_schedule } from "./warmup/warmup_schedule.js";
 import { GPUTextureContext } from "../texture/GPUTextureContext.js";
 import { inspect_gpu_buffer } from "../buffer/inspect_gpu_buffer.js";
+import { shader_buffer_copy_storage_to_storage } from "../buffer/util/shader_buffer_copy_storage_to_storage.js";
+import { COMPUTE_SHADER_DEFAULT_GROUP_SIZE } from "../shader/COMPUTE_SHADER_DEFAULT_GROUP_SIZE.js";
+import {
+    SLOT_STACK_PUSH_RANGE_WORKGROUP_SIZE,
+    shader_slot_stack_push_range,
+} from "../gpu_primitive/slot_stack/shader_slot_stack_push_range.js";
+import {
+    PARTICLE_SHRINK_WORKGROUP_SIZE,
+    shader_particle_shrink_free_list,
+} from "./resize/shader_particle_shrink_free_list.js";
+import { shader_particle_shrink_alive_list } from "./resize/shader_particle_shrink_alive_list.js";
 
 const WORD = Uint32Array.BYTES_PER_ELEMENT;
 
@@ -162,6 +173,17 @@ const DEFAULT_CAPACITY = 65536;
  * and a set of accumulators that are sums — so the particles need no depth ordering at all, and
  * none is ever built.
  *
+ * ## Capacity
+ *
+ * {@link capacity} may be set at any time and takes effect on the next {@link execute}, which is
+ * where every buffer it sizes is replaced — never while a recorded graph may still read the old
+ * ones. Growing keeps every live particle: the pool and the free list are copied into the larger
+ * buffers and the new slots pushed onto the free list. Shrinking keeps every live particle the
+ * smaller pool can hold: a particle in a slot past the new capacity moves into a free slot below
+ * it, and when there are more particles than slots, the excess is dropped. A particle that moves
+ * reads a new `PARTICLE_INDEX`, and the frame that applies a shrink rebuilds the simulation order
+ * from the moved list before it simulates.
+ *
  * ## Allocation
  *
  * The per-frame path allocates the frame graph's records and nothing else: emitter rows are
@@ -185,10 +207,31 @@ export class GPUParticleSystem {
     scene_context;
 
     /**
-     * Maximum number of simultaneously live particles.
+     * Maximum number of simultaneously live particles, as last set. See {@link capacity}.
+     * @type {number}
+     */
+    #capacity;
+
+    /**
+     * The capacity the pool's buffers are built for: {@link #capacity} as of the last
+     * {@link execute}, which is where a new one is applied.
      * @type {number}
      */
-    capacity;
+    #pool_capacity;
+
+    /**
+     * Set by a shrink, which moves particles and so leaves the simulation order naming slots that
+     * are gone: the frame it is applied in rebuilds the order from the moved list, as for a program
+     * edit.
+     * @type {boolean}
+     */
+    #rebucket_pending = false;
+
+    /**
+     * The new slots a grow pushes onto the free list. Reused.
+     * @type {{first: number, count: number, counter: number}}
+     */
+    #push_settings = { first: 0, count: 0, counter: PARTICLE_COUNTER.DEAD };
 
     /**
      * @type {EmitterRegistry}
@@ -367,7 +410,8 @@ export class GPUParticleSystem {
 
         this.graphics = graphics;
         this.scene_context = scene_context;
-        this.capacity = capacity;
+        this.#capacity = capacity;
+        this.#pool_capacity = capacity;
 
         this.registry = new EmitterRegistry(graphics.device);
 
@@ -378,6 +422,26 @@ export class GPUParticleSystem {
         this.#create_default_atlas();
     }
 
+    /**
+     * Maximum number of simultaneously live particles.
+     * @returns {number}
+     */
+    get capacity() {
+        return this.#capacity;
+    }
+
+    /**
+     * Raise or lower the number of particles the pool holds. Applied by the next {@link execute};
+     * see the class doc for what happens to the particles already live.
+     *
+     * @param {number} value
+     */
+    set capacity(value) {
+        assert.isPositiveInteger(value, "capacity");
+
+        this.#capacity = value;
+    }
+
     /**
      * The buffer the emitter table lives in — what every emitter-reading pass binds.
      * @returns {GPUBuffer}
@@ -493,8 +557,10 @@ export class GPUParticleSystem {
         frame.index = this.frame;
         frame.max_catchup = this.max_catchup_seconds;
         frame.spawn_command_count = this.#spawn_command_count;
-        frame.rebucket = this.#program_assignment_version !== this.registry.program_assignment_version;
+        frame.rebucket = this.#rebucket_pending
+            || this.#program_assignment_version !== this.registry.program_assignment_version;
         this.#program_assignment_version = this.registry.program_assignment_version;
+        this.#rebucket_pending = false;
 
         const table = this.registry.table;
         const emitters = this.#emitters;
@@ -524,7 +590,7 @@ export class GPUParticleSystem {
             wind: this.scene_context.wind,
             gpu: buffers,
             emitters,
-            capacity: this.capacity,
+            capacity: this.#pool_capacity,
             bucket_count: this.bucketCount(),
             // Whose register file the VM runs on is decided here, once, for the whole system: the
             // registry reports what the hungriest registered effect needs and this compares it
@@ -709,14 +775,17 @@ export class GPUParticleSystem {
     }
 
     /**
-     * Push everything the CPU changed to the GPU: dirty emitter and binding rows, the state buffer's
-     * growth, the program buffer rebuilt or its changed field span, the spawn-command ring, and the
-     * coherence scratch's growth. A command context is opened only if something needs one.
+     * Push everything the CPU changed to the GPU: a new pool capacity, dirty emitter and binding
+     * rows, the state buffer's growth, the program buffer rebuilt or its changed field span, the
+     * spawn-command ring, and the coherence scratch's growth. A command context is opened only if
+     * something needs one.
      */
     #upload() {
         const registry = this.registry;
         const device = this.graphics.device;
 
+        this.#apply_capacity();
+
         registry.flush();
 
         // All three tables stage into the one database: the emitter rows the author changed, the
@@ -850,7 +919,7 @@ export class GPUParticleSystem {
         device.queue.writeBuffer(this.buffers.warmup_queue, 0, words.buffer, words.byteOffset, bytes);
 
         frame.warmup_count = count;
-        frame.warmup_capacity = Math.max(1, Math.min(this.capacity, spawned));
+        frame.warmup_capacity = Math.max(1, Math.min(this.#pool_capacity, spawned));
         frame.warmup_schedule = warmup_schedule(max_prewarm);
     }
 
@@ -974,6 +1043,18 @@ export class GPUParticleSystem {
             return;
         }
 
+        this.#replace_sim_list(buckets, true);
+    }
+
+    /**
+     * A coherence list for `buckets` programs over the pool as it now stands, in place of the one
+     * there is.
+     *
+     * @param {number} buckets
+     * @param {boolean} carry whether the entries are copied forward — they must be whenever the
+     *   next simulate reads the list, and need not be when that frame rebuilds it first
+     */
+    #replace_sim_list(buckets, carry) {
         const device = this.graphics.device;
         const buffers = this.buffers;
 
@@ -982,20 +1063,216 @@ export class GPUParticleSystem {
         const previous = buffers.sim_list;
         buffers.sim_list = device.createBuffer({
             label: "particles/sim_list",
-            size: (this.capacity + buckets * PARTICLE_SIMULATE_WORKGROUP_SIZE) * WORD,
+            size: (this.#pool_capacity + buckets * PARTICLE_SIMULATE_WORKGROUP_SIZE) * WORD,
             usage: STORAGE_GROWABLE,
         });
 
         if (previous !== undefined) {
-            const cmd = ShadeGPUCommandContext.create(this.graphics, "particles/coherence grow");
-            cmd.gpu_encoder.copyBufferToBuffer(previous, 0, buffers.sim_list, 0, previous.size);
-            cmd.finish();
+            if (carry) {
+                const cmd = ShadeGPUCommandContext.create(this.graphics, "particles/coherence grow");
+                cmd.gpu_encoder.copyBufferToBuffer(previous, 0, buffers.sim_list, 0, previous.size);
+                cmd.finish();
+            }
+
             previous.destroy();
         }
 
         this.#sim_bucket_capacity = buckets;
     }
 
+    /**
+     * Rebuild the pool at {@link #capacity} if it was set to something else since the last frame.
+     * Here, at the top of {@link execute}, because the last frame's graph has been submitted and
+     * nothing recorded reads the buffers being replaced.
+     */
+    #apply_capacity() {
+        const capacity = this.#capacity;
+        const previous_capacity = this.#pool_capacity;
+
+        if (capacity === previous_capacity) {
+            return;
+        }
+
+        this.#pool_capacity = capacity;
+        this.#alive_descriptor = BufferResourceDescriptor.from(capacity * WORD, STORAGE);
+
+        if (capacity > previous_capacity) {
+            this.#grow_pool(previous_capacity, capacity);
+        } else {
+            this.#shrink_pool(previous_capacity, capacity);
+        }
+    }
+
+    /**
+     * Every live particle keeps its slot, and the free list keeps its order: both are copied into
+     * buffers of the larger size, and the slots the pool gains are pushed on top of the free list.
+     * The coherence list is carried forward too, so the next simulate reads the list and the count
+     * the last frame left, exactly as it would have.
+     *
+     * The alive list needs nothing: the last frame's is read, if at all, only up to its count, and
+     * the next one is asked for at the new size.
+     *
+     * @param {number} previous_capacity
+     * @param {number} capacity
+     */
+    #grow_pool(previous_capacity, capacity) {
+        const device = this.graphics.device;
+        const buffers = this.buffers;
+        const pool = buffers.pool;
+        const dead = buffers.dead;
+
+        const grown_pool = device.createBuffer({ label: "particles/pool", size: capacity * PARTICLE_RECORD_WORD_COUNT * WORD, usage: STORAGE });
+        const grown_dead = device.createBuffer({ label: "particles/dead", size: capacity * WORD, usage: STORAGE });
+
+        const cmd = ShadeGPUCommandContext.create(this.graphics, "particles/pool grow");
+
+        this.#copy_words(cmd, pool, grown_pool, previous_capacity * PARTICLE_RECORD_WORD_COUNT);
+        this.#copy_words(cmd, dead, grown_dead, previous_capacity);
+
+        const settings = this.#push_settings;
+        settings.first = previous_capacity;
+        settings.count = capacity - previous_capacity;
+
+        shader_slot_stack_push_range.dispatch({
+            encoder: cmd,
+            group_count_x: this.#launch(settings.count, SLOT_STACK_PUSH_RANGE_WORKGROUP_SIZE),
+            bindings: { settings, counts: buffers.counters, slots: grown_dead },
+        });
+
+        cmd.finish();
+
+        pool.destroy();
+        dead.destroy();
+
+        buffers.pool = grown_pool;
+        buffers.dead = grown_dead;
+
+        if (buffers.sim_list !== undefined) {
+            this.#replace_sim_list(this.#sim_bucket_capacity, true);
+        }
+    }
+
+    /**
+     * The smaller pool is built beside the larger one and every list is rebuilt into it, on the GPU,
+     * since only the GPU knows which slots are live: the records below the new capacity are copied
+     * across, the free slots below it make the new free list, and the particles past it move into
+     * free slots below it ({@link shader_particle_shrink_alive_list}). The counters move to a buffer
+     * of their own for the same reason — the passes count the new lists while reading the old
+     * lengths — carrying everything else in them across.
+     *
+     * The coherence list names slots that are gone, so it is replaced empty and the next frame
+     * rebuilds it from the new alive list before it simulates.
+     *
+     * @param {number} previous_capacity
+     * @param {number} capacity
+     */
+    #shrink_pool(previous_capacity, capacity) {
+        const graphics = this.graphics;
+        const device = graphics.device;
+        const allocator = graphics.buffer_allocator_main;
+        const buffers = this.buffers;
+
+        const pool = buffers.pool;
+        const dead = buffers.dead;
+        const counters = buffers.counters;
+        const alive = this.#alive;
+
+        const shrunk_pool = device.createBuffer({ label: "particles/pool", size: capacity * PARTICLE_RECORD_WORD_COUNT * WORD, usage: STORAGE });
+        const shrunk_dead = device.createBuffer({ label: "particles/dead", size: capacity * WORD, usage: STORAGE });
+        const shrunk_counters = device.createBuffer({ label: "particles/counters", size: counters.size, usage: STORAGE_GROWABLE });
+        // Taken before the old list goes back, so the pool cannot answer with the list being read.
+        const shrunk_alive = allocator.get(this.#alive_descriptor);
+
+        const cmd = ShadeGPUCommandContext.create(graphics, "particles/pool shrink");
+        const encoder = cmd.gpu_encoder;
+
+        // The two lists' lengths start at zero and the passes count them up; every other word — the
+        // counts the next frame resets or rebuilds, and the bounds accumulators — comes across.
+        encoder.copyBufferToBuffer(counters, 0, shrunk_counters, 0, counters.size);
+        encoder.clearBuffer(shrunk_counters, PARTICLE_COUNTER.ALIVE * WORD, WORD);
+        encoder.clearBuffer(shrunk_counters, PARTICLE_COUNTER.DEAD * WORD, WORD);
+
+        this.#copy_words(cmd, pool, shrunk_pool, capacity * PARTICLE_RECORD_WORD_COUNT);
+
+        // The lists are as long as the old pool at most; the lanes that find nothing past the GPU's
+        // count return at once.
+        const group_count_x = this.#launch(previous_capacity, PARTICLE_SHRINK_WORKGROUP_SIZE);
+
+        shader_particle_shrink_free_list.dispatch({
+            encoder: cmd,
+            group_count_x,
+            bindings: {
+                capacity,
+                previous_counters: counters, previous_dead: dead,
+                counters: shrunk_counters, dead: shrunk_dead,
+            },
+        });
+
+        shader_particle_shrink_alive_list.dispatch({
+            encoder: cmd,
+            group_count_x,
+            bindings: {
+                capacity,
+                previous_counters: counters, previous_alive: alive, previous_pool: pool,
+                counters: shrunk_counters, dead: shrunk_dead, pool: shrunk_pool, alive: shrunk_alive,
+            },
+        });
+
+        cmd.finish();
+
+        pool.destroy();
+        dead.destroy();
+        counters.destroy();
+        allocator.release(alive);
+
+        buffers.pool = shrunk_pool;
+        buffers.dead = shrunk_dead;
+        buffers.counters = shrunk_counters;
+
+        this.#alive = shrunk_alive;
+        buffers.alive = shrunk_alive;
+        buffers.alive_write = shrunk_alive;
+
+        if (buffers.sim_list !== undefined) {
+            this.#replace_sim_list(this.#sim_bucket_capacity, false);
+        }
+
+        this.#rebucket_pending = true;
+    }
+
+    /**
+     * Copy the first `words` words of `source` into `destination`. On the GPU, because the pool and
+     * the free list are written by shaders alone and carry no copy usage — see the usage masks at
+     * the top of this file.
+     *
+     * @param {ShadeGPUCommandContext} cmd
+     * @param {GPUBuffer} source
+     * @param {GPUBuffer} destination
+     * @param {number} words
+     */
+    #copy_words(cmd, source, destination, words) {
+        shader_buffer_copy_storage_to_storage.dispatch({
+            encoder: cmd,
+            group_count_x: this.#launch(words, COMPUTE_SHADER_DEFAULT_GROUP_SIZE),
+            bindings: { source, destination, size: words },
+        });
+    }
+
+    /**
+     * Workgroups for `threads` lanes of a grid-striding pass, clamped to what a dispatch dimension
+     * holds: past that the lanes stride through the rest.
+     *
+     * @param {number} threads
+     * @param {number} workgroup_size
+     * @returns {number}
+     */
+    #launch(threads, workgroup_size) {
+        return Math.min(
+            Math.ceil(threads / workgroup_size),
+            this.graphics.device.limits.maxComputeWorkgroupsPerDimension,
+        );
+    }
+
     /**
      * Give this frame its alive list, and hand back the ones nothing reads any more.
      *
@@ -1081,17 +1358,14 @@ export class GPUParticleSystem {
      * the caller's to choose and a dispatch past `maxComputeWorkgroupsPerDimension` is refused.
      */
     #init_free_list() {
-        const device = this.graphics.device;
+        const capacity = this.#pool_capacity;
 
         const cmd = ShadeGPUCommandContext.create(this.graphics, "particles/free list init");
 
         shader_slot_stack_fill.dispatch({
             encoder: cmd,
-            group_count_x: Math.min(
-                Math.ceil(this.capacity / SLOT_STACK_FILL_WORKGROUP_SIZE),
-                device.limits.maxComputeWorkgroupsPerDimension,
-            ),
-            bindings: { slots: this.buffers.dead, capacity: this.capacity },
+            group_count_x: this.#launch(capacity, SLOT_STACK_FILL_WORKGROUP_SIZE),
+            bindings: { slots: this.buffers.dead, capacity },
         });
 
         cmd.finish();
@@ -1102,7 +1376,7 @@ export class GPUParticleSystem {
      */
     #create_buffers() {
         const device = this.graphics.device;
-        const capacity = this.capacity;
+        const capacity = this.#pool_capacity;
         const buffers = this.buffers;
 
         buffers.pool = device.createBuffer({ label: "particles/pool", size: capacity * PARTICLE_RECORD_WORD_COUNT * WORD, usage: STORAGE });

package/src/shade/renderer/particles/resize/shader_particle_shrink_alive_list.d.ts

@@ -0,0 +1,21 @@
+/**
+ * The second half of shrinking the particle pool to `capacity` slots: the alive list of the smaller
+ * pool, out of the alive list of the larger one. A particle below `capacity` keeps its slot; one at
+ * or past it moves into a slot popped off the smaller pool's free list
+ * ({@link shader_particle_shrink_free_list}), its record copied across from `previous_pool`. A
+ * particle that finds the free list empty is dropped — the smaller pool cannot hold it.
+ *
+ * `pool` must already hold the larger pool's records below `capacity`: the ones that stay are not
+ * copied here. `counters` is the smaller pool's, its `ALIVE` count zero going in; the larger pool's
+ * alive count is read out of `previous_counters`.
+ *
+ * Every live slot below `capacity` is on neither free list, so a pop never hands out a slot a staying
+ * particle holds, and the two lists the pass leaves partition `[0, capacity)` again.
+ *
+ * The launch is the caller's to clamp; every lane strides through the list by the whole grid.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_particle_shrink_alive_list: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_particle_shrink_alive_list.d.ts.map

package/src/shade/renderer/particles/resize/shader_particle_shrink_alive_list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_particle_shrink_alive_list.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/resize/shader_particle_shrink_alive_list.js"],"names":[],"mappings":"AAwBA;;;;;;;;;;;;;;;;;GAiBG;AACH,gDAFU,aAAa,CA0CpB;8BAhF2B,+BAA+B"}

package/src/shade/renderer/particles/resize/shader_particle_shrink_alive_list.js

@@ -0,0 +1,83 @@
+import { atomic_u32, 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 { chunk_slot_stack } from "../../gpu_primitive/slot_stack/chunk_slot_stack.js";
+import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
+import { PARTICLE_RECORD_WORD_COUNT } from "../ParticleConstants.js";
+import { PARTICLE_SHRINK_WORKGROUP_SIZE } from "./shader_particle_shrink_free_list.js";
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer holding one u32
+resources.setImmediate("capacity", u32);
+
+resources.createGroup()
+    .addStorageBuffer("previous_counters", WebGPUArray.u32, false)
+    .addStorageBuffer("previous_alive", WebGPUArray.u32, false)
+    .addStorageBuffer("previous_pool", WebGPUArray.u32, false)
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("dead", WebGPUArray.u32, true)
+    .addStorageBuffer("pool", WebGPUArray.u32, true)
+    .addStorageBuffer("alive", WebGPUArray.u32, true);
+
+/**
+ * The second half of shrinking the particle pool to `capacity` slots: the alive list of the smaller
+ * pool, out of the alive list of the larger one. A particle below `capacity` keeps its slot; one at
+ * or past it moves into a slot popped off the smaller pool's free list
+ * ({@link shader_particle_shrink_free_list}), its record copied across from `previous_pool`. A
+ * particle that finds the free list empty is dropped — the smaller pool cannot hold it.
+ *
+ * `pool` must already hold the larger pool's records below `capacity`: the ones that stay are not
+ * copied here. `counters` is the smaller pool's, its `ALIVE` count zero going in; the larger pool's
+ * alive count is read out of `previous_counters`.
+ *
+ * Every live slot below `capacity` is on neither free list, so a pop never hands out a slot a staying
+ * particle holds, and the two lists the pass leaves partition `[0, capacity)` again.
+ *
+ * The launch is the caller's to clamp; every lane strides through the list by the whole grid.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_particle_shrink_alive_list = ComputeShader.from({
+    label: "Particle Shrink Alive List",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+const COUNTER_ALIVE : u32 = ${PARTICLE_COUNTER.ALIVE}u;
+const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
+const RECORD_WORDS : u32 = ${PARTICLE_RECORD_WORD_COUNT}u;
+
+@compute @workgroup_size(${PARTICLE_SHRINK_WORKGROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(global_invocation_id) global_id: vec3<u32>,
+    @builtin(num_workgroups) group_count: vec3<u32>,
+) {
+    let stride = group_count.x * ${PARTICLE_SHRINK_WORKGROUP_SIZE}u;
+    let count = previous_counters[COUNTER_ALIVE];
+
+    for (var i = global_id.x; i < count; i += stride) {
+        var slot = previous_alive[i];
+
+        if (slot >= capacity) {
+            let moved = slot_stack_pop(&counters[COUNTER_DEAD], &dead, capacity);
+
+            if (moved == SLOT_STACK_NONE) {
+                continue;
+            }
+
+            for (var word = 0u; word < RECORD_WORDS; word++) {
+                pool[moved * RECORD_WORDS + word] = previous_pool[slot * RECORD_WORDS + word];
+            }
+
+            slot = moved;
+        }
+
+        let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
+        alive[a] = slot;
+    }
+}
+`, [chunk_slot_stack]),
+});

package/src/shade/renderer/particles/resize/shader_particle_shrink_free_list.d.ts

@@ -0,0 +1,21 @@
+/** Lanes per workgroup. One free slot each, so this is sized for occupancy and nothing else. */
+export const PARTICLE_SHRINK_WORKGROUP_SIZE: 256;
+/**
+ * The first half of shrinking the particle pool to `capacity` slots: the free list of the smaller
+ * pool, out of the free list of the larger one. Every free slot below `capacity` is pushed onto
+ * `dead`; the slots at or past it go with the old pool.
+ *
+ * `counters` is the smaller pool's counters buffer, its `DEAD` count zero going in. The larger
+ * pool's free-list length is read out of `previous_counters` — a plain view, since nothing writes
+ * that buffer here. The order the slots land in is arbitrary, as it is for every push.
+ *
+ * The launch is the caller's to clamp; every lane strides through the list by the whole grid.
+ *
+ * {@link shader_particle_shrink_alive_list} pops from the list this builds, so it is a separate
+ * dispatch, after this one: a pop can read a slot a concurrent push has counted but not yet written.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_particle_shrink_free_list: ComputeShader;
+import { ComputeShader } from "../../shader/ComputeShader.js";
+//# sourceMappingURL=shader_particle_shrink_free_list.d.ts.map

package/src/shade/renderer/particles/resize/shader_particle_shrink_free_list.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"shader_particle_shrink_free_list.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/resize/shader_particle_shrink_free_list.js"],"names":[],"mappings":"AAQA,gGAAgG;AAChG,iDAAkD;AAalD;;;;;;;;;;;;;;;GAeG;AACH,+CAFU,aAAa,CA2BpB;8BA7D2B,+BAA+B"}

package/src/shade/renderer/particles/resize/shader_particle_shrink_free_list.js

@@ -0,0 +1,64 @@
+import { atomic_u32, 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 { chunk_slot_stack } from "../../gpu_primitive/slot_stack/chunk_slot_stack.js";
+import { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
+
+/** Lanes per workgroup. One free slot each, so this is sized for occupancy and nothing else. */
+export const PARTICLE_SHRINK_WORKGROUP_SIZE = 256;
+
+const resources = new ShaderResourceSetDescriptor();
+
+// per-dispatch, four bytes, read-only: immediate data rather than a uniform buffer holding one u32
+resources.setImmediate("capacity", u32);
+
+resources.createGroup()
+    .addStorageBuffer("previous_counters", WebGPUArray.u32, false)
+    .addStorageBuffer("previous_dead", WebGPUArray.u32, false)
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true)
+    .addStorageBuffer("dead", WebGPUArray.u32, true);
+
+/**
+ * The first half of shrinking the particle pool to `capacity` slots: the free list of the smaller
+ * pool, out of the free list of the larger one. Every free slot below `capacity` is pushed onto
+ * `dead`; the slots at or past it go with the old pool.
+ *
+ * `counters` is the smaller pool's counters buffer, its `DEAD` count zero going in. The larger
+ * pool's free-list length is read out of `previous_counters` — a plain view, since nothing writes
+ * that buffer here. The order the slots land in is arbitrary, as it is for every push.
+ *
+ * The launch is the caller's to clamp; every lane strides through the list by the whole grid.
+ *
+ * {@link shader_particle_shrink_alive_list} pops from the list this builds, so it is a separate
+ * dispatch, after this one: a pop can read a slot a concurrent push has counted but not yet written.
+ *
+ * @type {ComputeShader}
+ */
+export const shader_particle_shrink_free_list = ComputeShader.from({
+    label: "Particle Shrink Free List",
+    resources,
+    body: CodeChunk.from(
+        //language=WGSL
+        `
+const COUNTER_DEAD : u32 = ${PARTICLE_COUNTER.DEAD}u;
+
+@compute @workgroup_size(${PARTICLE_SHRINK_WORKGROUP_SIZE}, 1, 1)
+fn main(
+    @builtin(global_invocation_id) global_id: vec3<u32>,
+    @builtin(num_workgroups) group_count: vec3<u32>,
+) {
+    let stride = group_count.x * ${PARTICLE_SHRINK_WORKGROUP_SIZE}u;
+    let count = previous_counters[COUNTER_DEAD];
+
+    for (var i = global_id.x; i < count; i += stride) {
+        let slot = previous_dead[i];
+
+        if (slot < capacity) {
+            slot_stack_push(&counters[COUNTER_DEAD], &dead, slot);
+        }
+    }
+}
+`, [chunk_slot_stack]),
+});

package/src/shade/renderer/restir/di/chunk_restir_resolve.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"chunk_restir_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_resolve.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mCAFU,SAAS,CA+DjB;0BAvFwB,oCAAoC"}
+{"version":3,"file":"chunk_restir_resolve.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/restir/di/chunk_restir_resolve.js"],"names":[],"mappings":"AAYA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,mCAFU,SAAS,CA4DjB;0BApFwB,oCAAoC"}