@woosh/meep-engine 3.11.2 → 3.12.0

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

@@ -50,7 +50,6 @@ import {
  */
 
 const CAPACITY = 1 << 15; // 32k particles
-const EMIT_WG = 64;
 const NEAR = 0.2;
 
 async function main() {
@@ -195,10 +194,10 @@ async function main() {
         // --- emit + simulate (simulate is sized by LAST frame's GPU-written dispatch args) ---
         shader_particle_reset_counters.dispatch({ encoder: cmd, bindings: { counters }, group_count_x: 1 });
         if (requests.length > 0) {
-            shader_particle_emit.dispatch({
+            shader_particle_emit.dispatchThreads({
                 encoder: cmd,
                 bindings: { emitters, program, vm_constants: constants, pool, spawn_requests: spawnRequests, alive_out: aliveWrite, dead, counters, u_dt: u(f32, dt), u_time: u(f32, now / 1000), u_frame: u(u32, system.frame), u_count: u(u32, requests.length), u_capacity: u(u32, CAPACITY) },
-                group_count_x: Math.ceil(requests.length / EMIT_WG),
+                thread_count_x: requests.length,
             });
         }
         shader_particle_simulate.dispatchIndirect({

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":"AAmBA;;;;;;;;;;;;GAYG;AAEH,2CAHU,aAAa,CAGwB;AA+E/C,iDAKG;8BAnH2B,+BAA+B"}
+{"version":3,"file":"shader_particle_emit.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_emit.js"],"names":[],"mappings":"AAmBA;;;;;;;;;;;;GAYG;AAEH,2CAHU,aAAa,CAGwB;AA+E/C,iDAIG;8BAlH2B,+BAA+B"}

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

@@ -1,118 +1,117 @@
-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_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";
-
-/**
- * The particle emit (spawn) pass.
- *
- * 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.
- *
- * 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.
- *
- * @type {ComputeShader}
- */
-
-export const PARTICLE_EMIT_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("spawn_requests", 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)
-    .addUniform("u_count", u32)
-    .addUniform("u_capacity", u32);
-
-const body = CodeChunk.from(/* 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 >= 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 / 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;
-
-    // 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 >u_capacity identifies every wrapped state; each thread that
-    // subtracted also adds back exactly once, so the counter converges to 0.
-    let old_dead = atomicSub(&counters[COUNTER_DEAD], 1u);
-    if (old_dead == 0u || old_dead > 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, u_dt, u_time, 0.0, spawn_fraction, u_frame);
-    particle_vm_execute(
-        &program,
-        em.spawn_offset * PARTICLE_INSTRUCTION_WORDS,
-        em.spawn_count,
-        &vm_constants,
-        em.constant_offset,
-        &pool,
-        record_base,
-    );
-
-    let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
-    alive_out[a] = slot;
-}
-`, [chunk_particle_context, chunk_particle_curve_disabled]);
-
-export const shader_particle_emit = ComputeShader.from({
-    label: "Particle Emit",
-    resources,
-    body,
-    group_size: [PARTICLE_EMIT_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_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";
+
+/**
+ * The particle emit (spawn) pass.
+ *
+ * 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.
+ *
+ * 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.
+ *
+ * @type {ComputeShader}
+ */
+
+export const PARTICLE_EMIT_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("spawn_requests", 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)
+    .addUniform("u_count", u32)
+    .addUniform("u_capacity", u32);
+
+const body = CodeChunk.from(/* 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 >= 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 / 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;
+
+    // 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 >u_capacity identifies every wrapped state; each thread that
+    // subtracted also adds back exactly once, so the counter converges to 0.
+    let old_dead = atomicSub(&counters[COUNTER_DEAD], 1u);
+    if (old_dead == 0u || old_dead > 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, u_dt, u_time, 0.0, spawn_fraction, u_frame);
+    particle_vm_execute(
+        &program,
+        em.spawn_offset * PARTICLE_INSTRUCTION_WORDS,
+        em.spawn_count,
+        &vm_constants,
+        em.constant_offset,
+        &pool,
+        record_base,
+    );
+
+    let a = atomicAdd(&counters[COUNTER_ALIVE], 1u);
+    alive_out[a] = slot;
+}
+`, [chunk_particle_context, chunk_particle_curve_disabled]);
+
+export const shader_particle_emit = ComputeShader.from({
+    label: "Particle Emit",
+    resources,
+    body,
+});

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_finalize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_finalize.js"],"names":[],"mappings":"AA4BA,2DAYG;AAWH,2DAyBG;;8BA1E2B,+BAA+B;iDAIZ,+BAA+B"}
+{"version":3,"file":"shader_particle_finalize.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_finalize.js"],"names":[],"mappings":"AA4BA,2DAWG;AAWH,2DAwBG;;8BAxE2B,+BAA+B;iDAIZ,+BAA+B"}

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

@@ -1,79 +1,77 @@
-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 { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
-import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "./shader_particle_simulate.js";
-
-/**
- * Small housekeeping passes that keep the pipeline GPU-driven:
- *
- * - {@link shader_particle_reset_counters} — zero the alive / spawn / sorted counters at the top of
- *   the frame (the dead count and the ALIVE_IN snapshot persist across frames).
- * - {@link shader_particle_build_indirect} — read the frame's final alive count and (a) snapshot it
- *   into {@link PARTICLE_COUNTER.ALIVE_IN} — the exact input length for NEXT frame's simulate, (b)
- *   write the indirect dispatch args next frame's simulate consumes, and (c) write the indirect draw
- *   args for THIS frame's billboard render. Nothing round-trips to the CPU. Sizing the dispatch or
- *   draw from a stale CPU readback instead is a correctness bug: when the alive count grows the tail
- *   of the list is never simulated (slots leak into limbo), and when it shrinks stale entries beyond
- *   the written range get re-simulated — a dead slot is pushed to the free list twice and later
- *   popped twice, leaving two live particles sharing one record.
- */
-
-// --- reset ---
-
-const reset_resources = new ShaderResourceSetDescriptor();
-reset_resources.createGroup().addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
-
-export const shader_particle_reset_counters = ComputeShader.from({
-    label: "Particle Reset Counters",
-    resources: reset_resources,
-    body: CodeChunk.from(/* wgsl */ `
-@compute @workgroup_size(1, 1, 1)
-fn main() {
-    atomicStore(&counters[${PARTICLE_COUNTER.ALIVE}u], 0u);
-    atomicStore(&counters[${PARTICLE_COUNTER.SPAWN}u], 0u);
-    atomicStore(&counters[${PARTICLE_COUNTER.SORTED}u], 0u);
-}
-`),
-    group_size: [1, 1, 1],
-});
-
-// --- build indirect args ---
-
-const indirect_resources = new ShaderResourceSetDescriptor();
-indirect_resources.createGroup()
-    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true) // atomics require a read_write binding even for atomicLoad
-    .addStorageBuffer("dispatch_args", WebGPUArray.u32, true) // {x,y,z}
-    .addStorageBuffer("draw_args", WebGPUArray.u32, true)     // {vertexCount, instanceCount, firstVertex, firstInstance}
-    .addUniform("u_workgroup_size", u32);
-
-export const shader_particle_build_indirect = ComputeShader.from({
-    label: "Particle Build Indirect",
-    resources: indirect_resources,
-    body: CodeChunk.from(/* wgsl */ `
-@compute @workgroup_size(1, 1, 1)
-fn main() {
-    let alive = atomicLoad(&counters[${PARTICLE_COUNTER.ALIVE}u]);
-
-    // Snapshot: this frame's final alive count is next frame's exact simulate input length.
-    atomicStore(&counters[${PARTICLE_COUNTER.ALIVE_IN}u], alive);
-
-    // Simulate dispatch (consumed NEXT frame): one thread per alive particle, whole workgroups.
-    let groups = (alive + u_workgroup_size - 1u) / max(u_workgroup_size, 1u);
-    dispatch_args[0] = groups;
-    dispatch_args[1] = 1u;
-    dispatch_args[2] = 1u;
-
-    // Instanced billboard draw (consumed THIS frame): 6 verts per particle, one instance per alive.
-    draw_args[0] = 6u;
-    draw_args[1] = alive;
-    draw_args[2] = 0u;
-    draw_args[3] = 0u;
-}
-`),
-    group_size: [1, 1, 1],
-});
-
-export { PARTICLE_SIMULATE_WORKGROUP_SIZE };
+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 { PARTICLE_COUNTER } from "../data/PARTICLE_COUNTERS.js";
+import { PARTICLE_SIMULATE_WORKGROUP_SIZE } from "./shader_particle_simulate.js";
+
+/**
+ * Small housekeeping passes that keep the pipeline GPU-driven:
+ *
+ * - {@link shader_particle_reset_counters} — zero the alive / spawn / sorted counters at the top of
+ *   the frame (the dead count and the ALIVE_IN snapshot persist across frames).
+ * - {@link shader_particle_build_indirect} — read the frame's final alive count and (a) snapshot it
+ *   into {@link PARTICLE_COUNTER.ALIVE_IN} — the exact input length for NEXT frame's simulate, (b)
+ *   write the indirect dispatch args next frame's simulate consumes, and (c) write the indirect draw
+ *   args for THIS frame's billboard render. Nothing round-trips to the CPU. Sizing the dispatch or
+ *   draw from a stale CPU readback instead is a correctness bug: when the alive count grows the tail
+ *   of the list is never simulated (slots leak into limbo), and when it shrinks stale entries beyond
+ *   the written range get re-simulated — a dead slot is pushed to the free list twice and later
+ *   popped twice, leaving two live particles sharing one record.
+ */
+
+// --- reset ---
+
+const reset_resources = new ShaderResourceSetDescriptor();
+reset_resources.createGroup().addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true);
+
+export const shader_particle_reset_counters = ComputeShader.from({
+    label: "Particle Reset Counters",
+    resources: reset_resources,
+    body: CodeChunk.from(/* wgsl */ `
+@compute @workgroup_size(1, 1, 1)
+fn main() {
+    atomicStore(&counters[${PARTICLE_COUNTER.ALIVE}u], 0u);
+    atomicStore(&counters[${PARTICLE_COUNTER.SPAWN}u], 0u);
+    atomicStore(&counters[${PARTICLE_COUNTER.SORTED}u], 0u);
+}
+`),
+});
+
+// --- build indirect args ---
+
+const indirect_resources = new ShaderResourceSetDescriptor();
+indirect_resources.createGroup()
+    .addStorageBuffer("counters", WebGPUArray.from(atomic_u32), true) // atomics require a read_write binding even for atomicLoad
+    .addStorageBuffer("dispatch_args", WebGPUArray.u32, true) // {x,y,z}
+    .addStorageBuffer("draw_args", WebGPUArray.u32, true)     // {vertexCount, instanceCount, firstVertex, firstInstance}
+    .addUniform("u_workgroup_size", u32);
+
+export const shader_particle_build_indirect = ComputeShader.from({
+    label: "Particle Build Indirect",
+    resources: indirect_resources,
+    body: CodeChunk.from(/* wgsl */ `
+@compute @workgroup_size(1, 1, 1)
+fn main() {
+    let alive = atomicLoad(&counters[${PARTICLE_COUNTER.ALIVE}u]);
+
+    // Snapshot: this frame's final alive count is next frame's exact simulate input length.
+    atomicStore(&counters[${PARTICLE_COUNTER.ALIVE_IN}u], alive);
+
+    // Simulate dispatch (consumed NEXT frame): one thread per alive particle, whole workgroups.
+    let groups = (alive + u_workgroup_size - 1u) / max(u_workgroup_size, 1u);
+    dispatch_args[0] = groups;
+    dispatch_args[1] = 1u;
+    dispatch_args[2] = 1u;
+
+    // Instanced billboard draw (consumed THIS frame): 6 verts per particle, one instance per alive.
+    draw_args[0] = 6u;
+    draw_args[1] = alive;
+    draw_args[2] = 0u;
+    draw_args[3] = 0u;
+}
+`),
+});
+
+export { PARTICLE_SIMULATE_WORKGROUP_SIZE };

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

@@ -1 +1 @@
-{"version":3,"file":"shader_particle_render.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_render.js"],"names":[],"mappings":"AAqJA;;;;;;;;;GASG;AACH;IAP4B,YAAY,GAA7B,MAAM;IACgB,YAAY,GAAlC,MAAM,GAAC,IAAI;IAEkB,aAAa;IAExC,wBAAwB,CAsBpC;;;;;;;;;;;;;;;;AAED,yFAAyF;AACzF,uEAAsD;yCAtLb,iEAAiE;4CAO9D,sDAAsD"}
+{"version":3,"file":"shader_particle_render.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/shaders/shader_particle_render.js"],"names":[],"mappings":"AA6JA;;;;;;;;;GASG;AACH;IAP4B,YAAY,GAA7B,MAAM;IACgB,YAAY,GAAlC,MAAM,GAAC,IAAI;IAEkB,aAAa;IAExC,wBAAwB,CAqBpC;;;;;;;;;;;;;;;;AAED,yFAAyF;AACzF,uEAAsD;yCA7Lb,iEAAiE;4CAO9D,sDAAsD"}