@woosh/meep-engine 3.15.0 → 3.16.0

package/editor/particles/effect/ParticleReferenceSimulation.d.ts

@@ -0,0 +1,113 @@
+/**
+ * Most particles a preview will hold. A cap rather than a budget: an effect whose rate and lifetime
+ * ask for more is showing the author something about the effect, and it should be visible without
+ * the page becoming unusable.
+ *
+ * @type {number}
+ */
+export const PARTICLE_PREVIEW_CAPACITY: number;
+export class ParticleReferenceSimulation {
+    /**
+     * @param {object} [options]
+     * @param {number} [options.capacity]
+     */
+    constructor({ capacity }?: {
+        capacity?: number;
+    });
+    /**
+     * Particle records, {@link PARTICLE_RECORD_WORD_COUNT} words each. Attribute values are f32 bits
+     * — the same reinterpretation the pool buffer uses on the GPU.
+     * @type {Uint32Array}
+     */
+    pool: Uint32Array;
+    /**
+     * Slots currently holding a live particle.
+     * @type {number[]}
+     */
+    alive: number[];
+    /**
+     * Slots free to spawn into.
+     * @type {number[]}
+     */
+    free: number[];
+    /**
+     * Per-slot RNG state, carried across frames so an UPDATE that draws randomly does not repeat.
+     * @type {Uint32Array}
+     */
+    rng: Uint32Array;
+    /**
+     * Fractional particles carried over from the last frame's emission.
+     * @type {number}
+     */
+    spawn_accumulator: number;
+    /**
+     * Seconds the emitter has been running. `EMITTER_AGE`.
+     * @type {number}
+     */
+    emitter_age: number;
+    /**
+     * Seconds since the simulation started. `TIME`.
+     * @type {number}
+     */
+    time: number;
+    /**
+     * @type {number}
+     */
+    capacity: number;
+    /**
+     * Drop every live particle and start over.
+     */
+    reset(): void;
+    /**
+     * Point the simulation at a compiled effect.
+     *
+     * Particles in flight are kept when only the program changed — which is what an author editing a
+     * graph is doing every few seconds, and restarting the effect under them each time makes the
+     * preview unreadable. They are dropped when the *layout* changed, because their records were
+     * written under the old one and the same words now mean something else.
+     *
+     * @param {object} params
+     * @param {import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram} params.program
+     * @param {import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout} params.layout
+     * @param {object} params.emitter emitter settings, see {@link ParticleEffectDocument#emitter}
+     */
+    setEffect({ program, layout, emitter }: {
+        program: import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram;
+        layout: import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout;
+        emitter: object;
+    }): void;
+    /**
+     * @returns {number} live particles
+     */
+    get count(): number;
+    /**
+     * Advance by one frame: emit what the rate asks for, then update everything alive.
+     *
+     * @param {number} dt seconds
+     */
+    step(dt: number): void;
+    /**
+     * Read every live particle's render channels, in the order they were spawned.
+     *
+     * The channels are read through the emitter's bindings, exactly as the render pass reads them —
+     * by record word offset, with an unbound channel standing in for itself. A visitor rather than an
+     * array of objects: this runs per frame, and the preview has nothing to do with the values after
+     * it has drawn them.
+     *
+     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, rotation: number, frame: number})} visitor
+     */
+    forEachParticle(visitor: (arg0: {
+        x: number;
+        y: number;
+        z: number;
+        size: number;
+        r: number;
+        g: number;
+        b: number;
+        a: number;
+        rotation: number;
+        frame: number;
+    }) => any): void;
+    #private;
+}
+//# sourceMappingURL=ParticleReferenceSimulation.d.ts.map

package/editor/particles/effect/ParticleReferenceSimulation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleReferenceSimulation.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/ParticleReferenceSimulation.js"],"names":[],"mappings":"AA8BA;;;;;;GAMG;AACH,wCAFU,MAAM,CAE8B;AAE9C;IAgFI;;;OAGG;IACH;QAF4B,QAAQ,GAAzB,MAAM;OAiBhB;IAjGD;;;;OAIG;IACH,MAFU,WAAW,CAEhB;IAEL;;;OAGG;IACH,OAFU,MAAM,EAAE,CAEP;IAEX;;;OAGG;IACH,MAFU,MAAM,EAAE,CAER;IAEV;;;OAGG;IACH,KAFU,WAAW,CAEI;IAQzB;;;OAGG;IACH,mBAFU,MAAM,CAEM;IAEtB;;;OAGG;IACH,aAFU,MAAM,CAEA;IAEhB;;;OAGG;IACH,MAFU,MAAM,CAEP;IAoCL;;OAEG;IACH,UAFU,MAAM,CAEQ;IAa5B;;OAEG;IACH,cAWC;IAED;;;;;;;;;;;;OAYG;IACH;QAJ0G,OAAO,EAAtG,OAAO,8DAA8D,EAAE,eAAe;QACU,MAAM,EAAtG,OAAO,gEAAgE,EAAE,cAAc;QACxE,OAAO,EAAtB,MAAM;aAgBhB;IAED;;OAEG;IACH,oBAEC;IAED;;;;OAIG;IACH,SAFW,MAAM,QAYhB;IAmHD;;;;;;;;;OASG;IACH;WAFwB,MAAM;WAAK,MAAM;WAAK,MAAM;cAAQ,MAAM;WAAK,MAAM;WAAK,MAAM;WAAK,MAAM;WAAK,MAAM;kBAAY,MAAM;eAAS,MAAM;qBA6C9I;;CACJ"}

package/editor/particles/effect/ParticleReferenceSimulation.js

@@ -0,0 +1,377 @@
+import {
+    PARTICLE_RECORD_WORD_COUNT,
+} from "../../../src/shade/renderer/particles/ParticleConstants.js";
+import { EMITTER_ATTRIBUTE_ABSENT } from "../../../src/shade/renderer/particles/data/PARTICLE_EMITTER_STRUCT.js";
+import { VM_BUILTIN } from "../../../src/shade/renderer/particles/isa/ParticleVMISA.js";
+import { execute_particle_vm } from "../../../src/shade/renderer/particles/vm/ParticleVMReference.js";
+
+/**
+ * One emitter's worth of particles, simulated on the CPU by the reference VM.
+ *
+ * This is the editor's preview when there is no device to run the real thing on — and it is not an
+ * approximation of it. {@link execute_particle_vm} is the executor the WGSL interpreter is written
+ * to match, opcode for opcode, down to the bits of the RNG; the parity spec next to it is what holds
+ * the two together. So an effect previewed here is running the same instructions the GPU would run
+ * on the same records, and what differs is only how many of them and who draws the result.
+ *
+ * What it deliberately does not do is anything the GPU passes do *around* the VM: no coherence
+ * bucketing, no depth sort, no occupancy, no transparency pipeline. Those decide how a frame is
+ * built, not what a particle is, and a preview that reproduced them would be a second renderer to
+ * keep in step.
+ *
+ * Spawning follows the emitter's rate the way the GPU tick pass does — an accumulator carried across
+ * frames, so a rate that is not a whole number of particles per frame still averages out.
+ */
+
+/** Where the previewed emitter sits, and which way it points. Fixed: the preview has one emitter. */
+const EMITTER_POSITION = [0, 0, 0, 0];
+const EMITTER_DIRECTION = [0, 0, 1, 0];
+const EMITTER_UP = [0, 1, 0, 0];
+
+/**
+ * Most particles a preview will hold. A cap rather than a budget: an effect whose rate and lifetime
+ * ask for more is showing the author something about the effect, and it should be visible without
+ * the page becoming unusable.
+ *
+ * @type {number}
+ */
+export const PARTICLE_PREVIEW_CAPACITY = 4096;
+
+export class ParticleReferenceSimulation {
+
+    /**
+     * Particle records, {@link PARTICLE_RECORD_WORD_COUNT} words each. Attribute values are f32 bits
+     * — the same reinterpretation the pool buffer uses on the GPU.
+     * @type {Uint32Array}
+     */
+    pool;
+
+    /**
+     * Slots currently holding a live particle.
+     * @type {number[]}
+     */
+    alive = [];
+
+    /**
+     * Slots free to spawn into.
+     * @type {number[]}
+     */
+    free = [];
+
+    /**
+     * Per-slot RNG state, carried across frames so an UPDATE that draws randomly does not repeat.
+     * @type {Uint32Array}
+     */
+    rng = new Uint32Array(0);
+
+    /**
+     * {@link pool} reinterpreted as floats, for reading attribute values back out.
+     * @type {Float32Array}
+     */
+    #pool_f32;
+
+    /**
+     * Fractional particles carried over from the last frame's emission.
+     * @type {number}
+     */
+    spawn_accumulator = 0;
+
+    /**
+     * Seconds the emitter has been running. `EMITTER_AGE`.
+     * @type {number}
+     */
+    emitter_age = 0;
+
+    /**
+     * Seconds since the simulation started. `TIME`.
+     * @type {number}
+     */
+    time = 0;
+
+    /**
+     * How many spawns have happened, so two particles born in the same frame get different seeds.
+     * @type {number}
+     */
+    #spawn_counter = 0;
+
+    /**
+     * @type {import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram|null}
+     */
+    #program = null;
+
+    /**
+     * @type {import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout|null}
+     */
+    #layout = null;
+
+    /**
+     * Emitter settings, in the shape {@link ParticleEffectDocument#emitter} holds them.
+     * @type {object|null}
+     */
+    #emitter = null;
+
+    /**
+     * The attribute schema the live records were written under. A layout change invalidates every
+     * record in flight — the same words mean something else — so it is what a restart keys on.
+     * @type {string}
+     */
+    #layout_signature = "";
+
+    /**
+     * @param {object} [options]
+     * @param {number} [options.capacity]
+     */
+    constructor({ capacity = PARTICLE_PREVIEW_CAPACITY } = {}) {
+        /**
+         * @type {number}
+         */
+        this.capacity = capacity;
+
+        this.pool = new Uint32Array(capacity * PARTICLE_RECORD_WORD_COUNT);
+        this.rng = new Uint32Array(capacity);
+
+        // The pool's words reinterpreted as floats, which is how attributes are stored — the same
+        // reinterpretation the GPU does on the pool buffer. Held rather than made per call: this is
+        // read once a frame.
+        this.#pool_f32 = new Float32Array(this.pool.buffer, this.pool.byteOffset, this.pool.length);
+
+        this.reset();
+    }
+
+    /**
+     * Drop every live particle and start over.
+     */
+    reset() {
+        this.alive.length = 0;
+        this.free.length = 0;
+
+        for (let slot = this.capacity - 1; slot >= 0; slot--) {
+            this.free.push(slot);
+        }
+
+        this.pool.fill(0);
+        this.spawn_accumulator = 0;
+        this.emitter_age = 0;
+    }
+
+    /**
+     * Point the simulation at a compiled effect.
+     *
+     * Particles in flight are kept when only the program changed — which is what an author editing a
+     * graph is doing every few seconds, and restarting the effect under them each time makes the
+     * preview unreadable. They are dropped when the *layout* changed, because their records were
+     * written under the old one and the same words now mean something else.
+     *
+     * @param {object} params
+     * @param {import("../../../src/shade/renderer/particles/isa/ParticleProgram.js").ParticleProgram} params.program
+     * @param {import("../../../src/shade/renderer/particles/layout/ParticleLayout.js").ParticleLayout} params.layout
+     * @param {object} params.emitter emitter settings, see {@link ParticleEffectDocument#emitter}
+     */
+    setEffect({ program, layout, emitter }) {
+        const signature = Array.from(layout.attributes.values())
+            .map(attribute => `${attribute.name}:${attribute.offset}:${attribute.components}`)
+            .join(",");
+
+        if (signature !== this.#layout_signature) {
+            this.#layout_signature = signature;
+
+            this.reset();
+        }
+
+        this.#program = program;
+        this.#layout = layout;
+        this.#emitter = emitter;
+    }
+
+    /**
+     * @returns {number} live particles
+     */
+    get count() {
+        return this.alive.length;
+    }
+
+    /**
+     * Advance by one frame: emit what the rate asks for, then update everything alive.
+     *
+     * @param {number} dt seconds
+     */
+    step(dt) {
+        if (this.#program === null) {
+            return;
+        }
+
+        this.time += dt;
+        this.emitter_age += dt;
+
+        this.#emit(dt);
+        this.#update(dt);
+    }
+
+    /**
+     * @param {number} dt
+     */
+    #emit(dt) {
+        this.spawn_accumulator += (this.#emitter.spawn_rate ?? 0) * dt;
+
+        const wanted = Math.floor(this.spawn_accumulator);
+
+        if (wanted <= 0) {
+            return;
+        }
+
+        this.spawn_accumulator -= wanted;
+
+        const count = Math.min(wanted, this.free.length);
+
+        for (let i = 0; i < count; i++) {
+            const slot = this.free.pop();
+
+            this.pool.fill(0, slot * PARTICLE_RECORD_WORD_COUNT, (slot + 1) * PARTICLE_RECORD_WORD_COUNT);
+
+            // Two particles spawned in the same frame must not draw the same numbers, so the seed
+            // takes the running spawn count rather than the slot or the time.
+            this.rng[slot] = (this.#spawn_counter * 2654435761) >>> 0;
+            this.#spawn_counter++;
+
+            const record = this.#record(slot);
+
+            const result = execute_particle_vm({
+                words: this.#program.init,
+                constants: this.#program.constants,
+                register_count: this.#program.register_count,
+                record,
+                builtins: this.#builtins(dt, slot, count === 0 ? 0 : i / count),
+                rng_state: this.rng[slot],
+            });
+
+            this.rng[slot] = result.rng_state;
+
+            if (result.killed) {
+                // an INIT that kills is unusual but legal; the slot never joins the live set
+                this.free.push(slot);
+                continue;
+            }
+
+            this.alive.push(slot);
+        }
+    }
+
+    /**
+     * @param {number} dt
+     */
+    #update(dt) {
+        const alive = this.alive;
+
+        let write = 0;
+
+        for (let read = 0; read < alive.length; read++) {
+            const slot = alive[read];
+
+            const result = execute_particle_vm({
+                words: this.#program.update,
+                constants: this.#program.constants,
+                register_count: this.#program.register_count,
+                record: this.#record(slot),
+                builtins: this.#builtins(dt, slot, 0),
+                rng_state: this.rng[slot],
+            });
+
+            this.rng[slot] = result.rng_state;
+
+            if (result.killed) {
+                this.free.push(slot);
+                continue;
+            }
+
+            // compacted in place: the survivors keep their order, which keeps the draw stable
+            alive[write] = slot;
+            write++;
+        }
+
+        alive.length = write;
+    }
+
+    /**
+     * @param {number} slot
+     * @returns {Uint32Array} a view of the slot's record
+     */
+    #record(slot) {
+        return this.pool.subarray(slot * PARTICLE_RECORD_WORD_COUNT, (slot + 1) * PARTICLE_RECORD_WORD_COUNT);
+    }
+
+    /**
+     * @param {number} dt
+     * @param {number} slot
+     * @param {number} spawn_fraction
+     * @returns {number[][]} builtin values by {@link VM_BUILTIN} id
+     */
+    #builtins(dt, slot, spawn_fraction) {
+        const builtins = [];
+
+        builtins[VM_BUILTIN.DELTA_TIME] = [dt, dt, dt, dt];
+        builtins[VM_BUILTIN.EMITTER_AGE] = [this.emitter_age, this.emitter_age, this.emitter_age, this.emitter_age];
+        builtins[VM_BUILTIN.EMITTER_POSITION] = EMITTER_POSITION;
+        builtins[VM_BUILTIN.EMITTER_DIRECTION] = EMITTER_DIRECTION;
+        builtins[VM_BUILTIN.EMITTER_UP] = EMITTER_UP;
+        builtins[VM_BUILTIN.PARTICLE_INDEX] = [slot, 0, 0, 0];
+        builtins[VM_BUILTIN.SPAWN_FRACTION] = [spawn_fraction, 0, 0, 0];
+        builtins[VM_BUILTIN.TIME] = [this.time, this.time, this.time, this.time];
+
+        return builtins;
+    }
+
+    /**
+     * Read every live particle's render channels, in the order they were spawned.
+     *
+     * The channels are read through the emitter's bindings, exactly as the render pass reads them —
+     * by record word offset, with an unbound channel standing in for itself. A visitor rather than an
+     * array of objects: this runs per frame, and the preview has nothing to do with the values after
+     * it has drawn them.
+     *
+     * @param {function({x: number, y: number, z: number, size: number, r: number, g: number, b: number, a: number, rotation: number, frame: number})} visitor
+     */
+    forEachParticle(visitor) {
+        if (this.#layout === null) {
+            return;
+        }
+
+        const render = this.#emitter.render ?? {};
+        const layout = this.#layout;
+
+        const offset = channel => {
+            const name = render[channel];
+
+            return name !== undefined && layout.has(name) ? layout.offsetOf(name) : EMITTER_ATTRIBUTE_ABSENT;
+        };
+
+        const position = offset("position");
+        const size = offset("size");
+        const color = offset("color");
+        const rotation = offset("rotation");
+        const frame = offset("frame");
+
+        const words = this.#pool_f32;
+
+        const particle = { x: 0, y: 0, z: 0, size: 1, r: 1, g: 1, b: 1, a: 1, rotation: 0, frame: 0 };
+
+        for (const slot of this.alive) {
+            const base = slot * PARTICLE_RECORD_WORD_COUNT;
+
+            particle.x = position === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + position];
+            particle.y = position === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + position + 1];
+            particle.z = position === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + position + 2];
+
+            particle.size = size === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + size];
+
+            particle.r = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color];
+            particle.g = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 1];
+            particle.b = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 2];
+            particle.a = color === EMITTER_ATTRIBUTE_ABSENT ? 1 : words[base + color + 3];
+
+            particle.rotation = rotation === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + rotation];
+            particle.frame = frame === EMITTER_ATTRIBUTE_ABSENT ? 0 : words[base + frame];
+
+            visitor(particle);
+        }
+    }
+}

package/editor/particles/effect/actions/ParticleGroupDefineAction.d.ts

@@ -0,0 +1,35 @@
+/**
+ * Give a document a node group, or take one back.
+ *
+ * A group made out of a selection is two separate facts: the graph loses some nodes and gains one,
+ * which the existing node actions already cover, and the *document* gains a type it did not have.
+ * Only the second is this action's, and it is here so that undoing a grouping leaves no type behind
+ * — a group nobody uses would otherwise sit in the add-node menu forever, offering to build
+ * something the author had already changed their mind about.
+ *
+ * It is deliberately not the whole gesture. Composed with {@link NodeDeleteAction} and
+ * {@link NodeCreateAction} under one mark, the group and everything around it undo together; alone,
+ * it is how a group is defined without being used.
+ */
+export class ParticleGroupDefineAction extends Action<any> {
+    /**
+     * @param {import("../ParticleEffectDocument.js").ParticleEffectDocument} document
+     * @param {import("../../../../src/shade/renderer/particles/graph/ParticleNodeGroup.js").ParticleNodeGroup} group
+     */
+    constructor(document: import("../ParticleEffectDocument.js").ParticleEffectDocument, group: import("../../../../src/shade/renderer/particles/graph/ParticleNodeGroup.js").ParticleNodeGroup);
+    /**
+     * @type {import("../ParticleEffectDocument.js").ParticleEffectDocument}
+     */
+    document: import("../ParticleEffectDocument.js").ParticleEffectDocument;
+    /**
+     * Retained across a revert, so a redo restores the same group rather than a lookalike —
+     * every node that was placed with it points at this object's description.
+     *
+     * @type {import("../../../../src/shade/renderer/particles/graph/ParticleNodeGroup.js").ParticleNodeGroup}
+     */
+    group: import("../../../../src/shade/renderer/particles/graph/ParticleNodeGroup.js").ParticleNodeGroup;
+    apply(): Promise<void>;
+    revert(): Promise<void>;
+}
+import { Action } from "../../../../src/core/process/undo/Action.js";
+//# sourceMappingURL=ParticleGroupDefineAction.d.ts.map

package/editor/particles/effect/actions/ParticleGroupDefineAction.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleGroupDefineAction.d.ts","sourceRoot":"","sources":["../../../../../editor/particles/effect/actions/ParticleGroupDefineAction.js"],"names":[],"mappings":"AAEA;;;;;;;;;;;;GAYG;AACH;IACI;;;OAGG;IACH,sBAHW,OAAO,8BAA8B,EAAE,sBAAsB,SAC7D,OAAO,qEAAqE,EAAE,iBAAiB,EAiBzG;IAZG;;OAEG;IACH,UAFU,OAAO,8BAA8B,EAAE,sBAAsB,CAE/C;IAExB;;;;;OAKG;IACH,OAFU,OAAO,qEAAqE,EAAE,iBAAiB,CAEvF;IAGtB,uBAEC;IAED,wBAEC;CACJ;uBA5CsB,6CAA6C"}

package/editor/particles/effect/actions/ParticleGroupDefineAction.js

@@ -0,0 +1,45 @@
+import { Action } from "../../../../src/core/process/undo/Action.js";
+
+/**
+ * Give a document a node group, or take one back.
+ *
+ * A group made out of a selection is two separate facts: the graph loses some nodes and gains one,
+ * which the existing node actions already cover, and the *document* gains a type it did not have.
+ * Only the second is this action's, and it is here so that undoing a grouping leaves no type behind
+ * — a group nobody uses would otherwise sit in the add-node menu forever, offering to build
+ * something the author had already changed their mind about.
+ *
+ * It is deliberately not the whole gesture. Composed with {@link NodeDeleteAction} and
+ * {@link NodeCreateAction} under one mark, the group and everything around it undo together; alone,
+ * it is how a group is defined without being used.
+ */
+export class ParticleGroupDefineAction extends Action {
+    /**
+     * @param {import("../ParticleEffectDocument.js").ParticleEffectDocument} document
+     * @param {import("../../../../src/shade/renderer/particles/graph/ParticleNodeGroup.js").ParticleNodeGroup} group
+     */
+    constructor(document, group) {
+        super();
+
+        /**
+         * @type {import("../ParticleEffectDocument.js").ParticleEffectDocument}
+         */
+        this.document = document;
+
+        /**
+         * Retained across a revert, so a redo restores the same group rather than a lookalike —
+         * every node that was placed with it points at this object's description.
+         *
+         * @type {import("../../../../src/shade/renderer/particles/graph/ParticleNodeGroup.js").ParticleNodeGroup}
+         */
+        this.group = group;
+    }
+
+    async apply() {
+        this.document.addGroup(this.group);
+    }
+
+    async revert() {
+        this.document.removeGroup(this.group);
+    }
+}

package/editor/particles/effect/make_starter_particle_effect.d.ts

@@ -0,0 +1,23 @@
+/**
+ * The effect a new document starts as.
+ *
+ * An editor that opens on an empty graph asks the author to build a working effect from nothing
+ * before they can see anything at all — and a particle effect has a floor below which it shows
+ * nothing: something has to seed a position, something has to age, something has to kill. So the
+ * starting point is the smallest effect that actually runs, and every part of it is there to be
+ * changed:
+ *
+ * - INIT seeds position from the emitter with a little scatter, an upward velocity with scatter, a
+ *   zero age, a random lifetime, a size and a colour.
+ * - UPDATE ages the particle, kills it at the end of its life, integrates its position, and fades
+ *   its colour out over the same normalized age.
+ *
+ * The result is a plume. It is the same shape as the worked examples in the particle playground,
+ * built with the same authoring helpers, so an author who wants to compare the two is looking at
+ * the same kind of graph.
+ *
+ * @returns {ParticleEffectDocument}
+ */
+export function make_starter_particle_effect(): ParticleEffectDocument;
+import { ParticleEffectDocument } from "./ParticleEffectDocument.js";
+//# sourceMappingURL=make_starter_particle_effect.d.ts.map

package/editor/particles/effect/make_starter_particle_effect.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make_starter_particle_effect.d.ts","sourceRoot":"","sources":["../../../../editor/particles/effect/make_starter_particle_effect.js"],"names":[],"mappings":"AAeA;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAFa,sBAAsB,CAkBlC;uCAtCsC,6BAA6B"}