@woosh/meep-engine 3.14.4 → 3.14.5

package/src/shade/renderer/particles/graph/ParticleNodeDescription.d.ts

@@ -0,0 +1,43 @@
+/**
+ * A particle node type: a {@link NodeDescription} that additionally knows how to lower an instance
+ * of itself into VM instructions.
+ *
+ * Ports carry all the structure the compiler needs — input ports name the operands, the presence of
+ * an output port says whether the node produces a value — so nothing about the graph's shape is
+ * duplicated outside the description.
+ */
+export class ParticleNodeDescription extends NodeDescription {
+    /**
+     * Lower one instance of this node into the target instruction stream.
+     *
+     * `context` provides:
+     * - `context.in(port_name)` → the register holding that input's value (resolved by the compiler),
+     * - `context.out` → the output register (value-producing nodes only, `undefined` for sinks),
+     * - `context.parameters` → the {@link NodeInstance}'s parameters,
+     * - `context.layout` → the {@link ../layout/ParticleLayout.js} for attribute offsets,
+     * - `context.asm` → the {@link ../isa/ParticleAssembler.js} for interning constants.
+     *
+     * @type {function(InstructionStream, {in: function(string):number, out: number|undefined, parameters: object, layout: ParticleLayout, asm: ParticleAssembler}):void}
+     */
+    emit: (arg0: InstructionStream, arg1: {
+        in: (arg0: string) => number;
+        out: number | undefined;
+        parameters: object;
+        layout: ParticleLayout;
+        asm: ParticleAssembler;
+    }) => void;
+    /**
+     * A node with no output ports produces no value, so nothing can consume it; the only reason to
+     * emit it is its side effect (an attribute write, a kill). Such nodes are the roots the compiler
+     * traverses from.
+     * @returns {boolean}
+     */
+    get is_sink(): boolean;
+    /**
+     * @readonly
+     * @type {boolean}
+     */
+    readonly isParticleNodeDescription: boolean;
+}
+import { NodeDescription } from "../../../../core/model/node-graph/node/NodeDescription.js";
+//# sourceMappingURL=ParticleNodeDescription.d.ts.map

package/src/shade/renderer/particles/graph/ParticleNodeDescription.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ParticleNodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeDescription.js"],"names":[],"mappings":"AAIA;;;;;;;GAOG;AACH;IAEI;;;;;;;;;;;OAWG;IACH,sCAFsC;QAAC,EAAE,SAAW,MAAM,KAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,GAAC,SAAS,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,iBAAiB;QAAC,GAAG,oBAAmB;KAAC,KAAE,IAAI,CAExJ;IAEZ;;;;;OAKG;IACH,uBAEC;IAGL;;;OAGG;IACH,oCAFU,OAAO,CAE0C;CAN1D;gCApC+B,2DAA2D"}

package/src/shade/renderer/particles/graph/ParticleNodeDescription.js

@@ -0,0 +1,44 @@
+import { noop } from "../../../../core/function/noop.js";
+import { NodeDescription } from "../../../../core/model/node-graph/node/NodeDescription.js";
+import { PortDirection } from "../../../../core/model/node-graph/node/PortDirection.js";
+
+/**
+ * A particle node type: a {@link NodeDescription} that additionally knows how to lower an instance
+ * of itself into VM instructions.
+ *
+ * Ports carry all the structure the compiler needs — input ports name the operands, the presence of
+ * an output port says whether the node produces a value — so nothing about the graph's shape is
+ * duplicated outside the description.
+ */
+export class ParticleNodeDescription extends NodeDescription {
+
+    /**
+     * Lower one instance of this node into the target instruction stream.
+     *
+     * `context` provides:
+     * - `context.in(port_name)` → the register holding that input's value (resolved by the compiler),
+     * - `context.out` → the output register (value-producing nodes only, `undefined` for sinks),
+     * - `context.parameters` → the {@link NodeInstance}'s parameters,
+     * - `context.layout` → the {@link ../layout/ParticleLayout.js} for attribute offsets,
+     * - `context.asm` → the {@link ../isa/ParticleAssembler.js} for interning constants.
+     *
+     * @type {function(InstructionStream, {in: function(string):number, out: number|undefined, parameters: object, layout: ParticleLayout, asm: ParticleAssembler}):void}
+     */
+    emit = noop;
+
+    /**
+     * A node with no output ports produces no value, so nothing can consume it; the only reason to
+     * emit it is its side effect (an attribute write, a kill). Such nodes are the roots the compiler
+     * traverses from.
+     * @returns {boolean}
+     */
+    get is_sink() {
+        return !this.hasPortsByDirection(PortDirection.Out);
+    }
+}
+
+/**
+ * @readonly
+ * @type {boolean}
+ */
+ParticleNodeDescription.prototype.isParticleNodeDescription = true;

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.d.ts

@@ -1,60 +1,34 @@
-export namespace PARTICLE_NODE_TYPES {
-    export namespace _const {
-        export { inputs };
-        export let produces_value: boolean;
-        export let is_sink: boolean;
-        export { emit };
-    }
-    export { _const as const };
-    export namespace builtin { }
-    export namespace attribute { }
-    export namespace random { }
-    export namespace setAttribute {
-        export { inputs };
-        let produces_value_1: boolean;
-        export { produces_value_1 as produces_value };
-        let is_sink_1: boolean;
-        export { is_sink_1 as is_sink };
-        export { emit };
-    }
-    export namespace kill { }
-    export namespace add {
-        export { inputs };
-        let produces_value_2: boolean;
-        export { produces_value_2 as produces_value };
-        let is_sink_2: boolean;
-        export { is_sink_2 as is_sink };
-        export { emit };
-    }
-    export namespace sub { }
-    export namespace mul { }
-    export namespace div { }
-    export namespace min { }
-    export namespace max { }
-    export namespace pow { }
-    export namespace step { }
-    export namespace mad { }
-    export namespace mix { }
-    export namespace clamp { }
-    export namespace smoothstep { }
-    export namespace scale { }
-    export namespace neg { }
-    export namespace abs { }
-    export namespace floor { }
-    export namespace fract { }
-    export namespace sqrt { }
-    export namespace sin { }
-    export namespace cos { }
-    export namespace exp { }
-    export namespace log { }
-    export namespace normalize { }
-    export namespace length { }
-    export namespace dot { }
-    export namespace cross { }
-    export namespace distance { }
-    export namespace swizzle { }
-    export namespace compare { }
-    export namespace select { }
-    export namespace curve { }
-}
+/**
+ * Look up a node type by name.
+ * @param {string} name
+ * @returns {ParticleNodeDescription}
+ * @throws if no such node type exists
+ */
+export function get_particle_node_description(name: string): ParticleNodeDescription;
+/**
+ * Standard particle-node library, expressed as {@link ParticleNodeDescription}s in a
+ * {@link NodeRegistry}. Nodes are value-producing operations (constants, builtins, attribute reads,
+ * math, curves, random) or sinks (attribute writes, kill).
+ *
+ * These lower to the same opcodes the JS reference + WGSL interpreter agree on, so any effect
+ * authored here is executable and testable end-to-end on the CPU before it ever hits the GPU.
+ */
+/**
+ * Every value the particle VM computes lives in a `vec4f` register, so a single data type describes
+ * every port in the library: any output may drive any input.
+ * @type {DataType}
+ */
+export const PARTICLE_VALUE_TYPE: DataType;
+/**
+ * Name of the single output port carried by every value-producing node.
+ * @type {string}
+ */
+export const PARTICLE_NODE_OUTPUT_PORT: string;
+/**
+ * @type {NodeRegistry}
+ */
+export const PARTICLE_NODE_REGISTRY: NodeRegistry;
+import { ParticleNodeDescription } from "./ParticleNodeDescription.js";
+import { DataType } from "../../../../core/model/node-graph/type/DataType.js";
+import { NodeRegistry } from "../../../../core/model/node-graph/node/NodeRegistry.js";
 //# sourceMappingURL=ParticleNodeRegistry.d.ts.map

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"ParticleNodeRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeRegistry.js"],"names":[],"mappings":""}
+{"version":3,"file":"ParticleNodeRegistry.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeRegistry.js"],"names":[],"mappings":"AA0KA;;;;;GAKG;AACH,oDAJW,MAAM,GACJ,uBAAuB,CAWnC;AAlLD;;;;;;;GAOG;AAEH;;;;GAIG;AACH,kCAFU,QAAQ,CAE0C;AAE5D;;;GAGG;AACH,wCAFU,MAAM,CAE+B;AAE/C;;GAEG;AACH,qCAFU,YAAY,CAEmC;wCA3BjB,8BAA8B;yBAF7C,oDAAoD;6BAFhD,wDAAwD"}

package/src/shade/renderer/particles/graph/ParticleNodeRegistry.js

@@ -1,118 +1,185 @@
-import { pack_swizzle, VM_OP } from "../isa/ParticleVMISA.js";
-
-/**
- * Standard particle-node library. Each entry describes a node type's input ports and whether it
- * produces a value or is a sink, plus an `emit(stream, ctx)` that lowers it to VM instructions.
- *
- * `ctx` provides:
- * - `ctx.in(port)` → the register holding that input's value (resolved by the compiler),
- * - `ctx.out` → the output register (value-producing nodes only),
- * - `ctx.params` → the node's static params,
- * - `ctx.layout` → the {@link ../layout/ParticleLayout.js} for attribute offsets,
- * - `ctx.asm` → the {@link ../isa/ParticleAssembler.js} for interning constants.
- *
- * These lower to the same opcodes the JS reference + WGSL interpreter agree on, so any effect
- * authored here is executable and testable end-to-end on the CPU before it ever hits the GPU.
- */
-
-/** value-producing node with no inputs */
-function source(inputs, emit) {
-    return { inputs, produces_value: true, is_sink: false, emit };
-}
-
-/** value-producing node */
-function op(inputs, emit) {
-    return { inputs, produces_value: true, is_sink: false, emit };
-}
-
-/** side-effecting sink (no output) */
-function sink(inputs, emit) {
-    return { inputs, produces_value: false, is_sink: true, emit };
-}
-
-function unary(opcode) {
-    return op(["x"], (s, c) => s.emit(opcode, c.out, c.in("x")));
-}
-
-function binary(opcode) {
-    return op(["a", "b"], (s, c) => s.emit(opcode, c.out, c.in("a"), c.in("b")));
-}
-
-const COMPARE_OPCODES = {
-    lt: VM_OP.CMP_LT,
-    le: VM_OP.CMP_LE,
-    gt: VM_OP.CMP_GT,
-    ge: VM_OP.CMP_GE,
-    eq: VM_OP.CMP_EQ,
-};
-
-export const PARTICLE_NODE_TYPES = {
-    // --- sources ---
-    const: source([], (s, c) => {
-        const v = c.params.value ?? [0, 0, 0, 0];
-        s.loadConst(c.out, c.asm.constant(v[0] ?? 0, v[1] ?? 0, v[2] ?? 0, v[3] ?? 0));
-    }),
-    builtin: source([], (s, c) => s.loadBuiltin(c.out, c.params.id)),
-    attribute: source([], (s, c) => {
-        const a = c.layout.get(c.params.name);
-        s.loadAttr(c.out, a.offset, a.components);
-    }),
-    random: source([], (s, c) => s.random(c.out, c.params.mode)),
-
-    // --- sinks ---
-    setAttribute: sink(["value"], (s, c) => {
-        const a = c.layout.get(c.params.name);
-        s.storeAttr(c.in("value"), a.offset, a.components);
-    }),
-    kill: sink(["condition"], (s, c) => s.kill(c.in("condition"))),
-
-    // --- arithmetic (component-wise) ---
-    add: binary(VM_OP.ADD),
-    sub: binary(VM_OP.SUB),
-    mul: binary(VM_OP.MUL),
-    div: binary(VM_OP.DIV),
-    min: binary(VM_OP.MIN),
-    max: binary(VM_OP.MAX),
-    pow: binary(VM_OP.POW),
-    step: binary(VM_OP.STEP),
-    mad: op(["a", "b", "c"], (s, c) => s.emit(VM_OP.MAD, c.out, c.in("a"), c.in("b"), c.in("c"))),
-    mix: op(["a", "b", "t"], (s, c) => s.emit(VM_OP.MIX, c.out, c.in("a"), c.in("b"), c.in("t"))),
-    clamp: op(["x", "lo", "hi"], (s, c) => s.emit(VM_OP.CLAMP, c.out, c.in("x"), c.in("lo"), c.in("hi"))),
-    smoothstep: op(["e0", "e1", "x"], (s, c) => s.emit(VM_OP.SMOOTHSTEP, c.out, c.in("e0"), c.in("e1"), c.in("x"))),
-    scale: op(["v", "s"], (s, c) => s.emit(VM_OP.SCALE, c.out, c.in("v"), c.in("s"))),
-
-    // --- unary math ---
-    neg: unary(VM_OP.NEG),
-    abs: unary(VM_OP.ABS),
-    floor: unary(VM_OP.FLOOR),
-    fract: unary(VM_OP.FRACT),
-    sqrt: unary(VM_OP.SQRT),
-    sin: unary(VM_OP.SIN),
-    cos: unary(VM_OP.COS),
-    exp: unary(VM_OP.EXP),
-    log: unary(VM_OP.LOG),
-    normalize: unary(VM_OP.NORMALIZE),
-    length: unary(VM_OP.LENGTH),
-
-    // --- vector ---
-    dot: binary(VM_OP.DOT),
-    cross: binary(VM_OP.CROSS),
-    distance: binary(VM_OP.DISTANCE),
-    swizzle: op(["x"], (s, c) => {
-        const p = c.params.pattern ?? [0, 1, 2, 3];
-        s.emit(VM_OP.SWIZZLE, c.out, c.in("x"), pack_swizzle(p[0], p[1], p[2], p[3]));
-    }),
-
-    // --- logic ---
-    compare: op(["a", "b"], (s, c) => {
-        const opcode = COMPARE_OPCODES[c.params.op];
-        if (opcode === undefined) {
-            throw new Error(`Unknown compare op '${c.params.op}'`);
-        }
-        s.emit(opcode, c.out, c.in("a"), c.in("b"));
-    }),
-    select: op(["a", "b", "condition"], (s, c) => s.emit(VM_OP.SELECT, c.out, c.in("a"), c.in("b"), c.in("condition"))),
-
-    // --- curves ---
-    curve: op(["t"], (s, c) => s.curve(c.out, c.params.handle, c.in("t"))),
-};
+import { NodeRegistry } from "../../../../core/model/node-graph/node/NodeRegistry.js";
+import { PortDirection } from "../../../../core/model/node-graph/node/PortDirection.js";
+import { DataType } from "../../../../core/model/node-graph/type/DataType.js";
+import { pack_swizzle, VM_OP } from "../isa/ParticleVMISA.js";
+import { ParticleNodeDescription } from "./ParticleNodeDescription.js";
+
+/**
+ * Standard particle-node library, expressed as {@link ParticleNodeDescription}s in a
+ * {@link NodeRegistry}. Nodes are value-producing operations (constants, builtins, attribute reads,
+ * math, curves, random) or sinks (attribute writes, kill).
+ *
+ * These lower to the same opcodes the JS reference + WGSL interpreter agree on, so any effect
+ * authored here is executable and testable end-to-end on the CPU before it ever hits the GPU.
+ */
+
+/**
+ * Every value the particle VM computes lives in a `vec4f` register, so a single data type describes
+ * every port in the library: any output may drive any input.
+ * @type {DataType}
+ */
+export const PARTICLE_VALUE_TYPE = DataType.from(0, "vec4");
+
+/**
+ * Name of the single output port carried by every value-producing node.
+ * @type {string}
+ */
+export const PARTICLE_NODE_OUTPUT_PORT = "out";
+
+/**
+ * @type {NodeRegistry}
+ */
+export const PARTICLE_NODE_REGISTRY = new NodeRegistry();
+
+/**
+ * Node descriptions are addressed by name while authoring; the registry itself is keyed by the
+ * numeric IDs assigned below.
+ *
+ * IDs are handed out in declaration order rather than by {@link NodeDescription}'s global counter,
+ * so they do not drift with unrelated node usage elsewhere in the engine. Appending new node types
+ * at the end of the library is therefore safe; reordering or removing existing ones renumbers every
+ * node that follows, which would invalidate already-serialized graphs.
+ *
+ * @type {Map<string, ParticleNodeDescription>}
+ */
+const descriptions_by_name = new Map();
+
+/**
+ * @param {string} name
+ * @param {string[]} inputs input port names, in operand order
+ * @param {function} emit see {@link ParticleNodeDescription#emit}
+ * @param {object} [options]
+ * @param {boolean} [options.produces_value] when false the node is a sink and gets no output port
+ * @returns {ParticleNodeDescription}
+ */
+function define(name, inputs, emit, { produces_value = true } = {}) {
+    if (descriptions_by_name.has(name)) {
+        throw new Error(`Duplicate particle node type '${name}'`);
+    }
+
+    const description = new ParticleNodeDescription();
+
+    description.name = name;
+    description.id = descriptions_by_name.size;
+
+    for (const input of inputs) {
+        description.createPort(PARTICLE_VALUE_TYPE, input, PortDirection.In);
+    }
+
+    if (produces_value) {
+        description.createPort(PARTICLE_VALUE_TYPE, PARTICLE_NODE_OUTPUT_PORT, PortDirection.Out);
+    }
+
+    description.emit = emit;
+
+    PARTICLE_NODE_REGISTRY.addNode(description);
+    descriptions_by_name.set(name, description);
+
+    return description;
+}
+
+/** side-effecting sink (no output) */
+function sink(name, inputs, emit) {
+    return define(name, inputs, emit, { produces_value: false });
+}
+
+function unary(name, opcode) {
+    return define(name, ["x"], (s, c) => s.emit(opcode, c.out, c.in("x")));
+}
+
+function binary(name, opcode) {
+    return define(name, ["a", "b"], (s, c) => s.emit(opcode, c.out, c.in("a"), c.in("b")));
+}
+
+const COMPARE_OPCODES = {
+    lt: VM_OP.CMP_LT,
+    le: VM_OP.CMP_LE,
+    gt: VM_OP.CMP_GT,
+    ge: VM_OP.CMP_GE,
+    eq: VM_OP.CMP_EQ,
+};
+
+// --- sources ---
+define("const", [], (s, c) => {
+    const v = c.parameters.value ?? [0, 0, 0, 0];
+    s.loadConst(c.out, c.asm.constant(v[0] ?? 0, v[1] ?? 0, v[2] ?? 0, v[3] ?? 0));
+});
+define("builtin", [], (s, c) => s.loadBuiltin(c.out, c.parameters.id));
+define("attribute", [], (s, c) => {
+    const a = c.layout.get(c.parameters.name);
+    s.loadAttr(c.out, a.offset, a.components);
+});
+define("random", [], (s, c) => s.random(c.out, c.parameters.mode));
+
+// --- sinks ---
+sink("setAttribute", ["value"], (s, c) => {
+    const a = c.layout.get(c.parameters.name);
+    s.storeAttr(c.in("value"), a.offset, a.components);
+});
+sink("kill", ["condition"], (s, c) => s.kill(c.in("condition")));
+
+// --- arithmetic (component-wise) ---
+binary("add", VM_OP.ADD);
+binary("sub", VM_OP.SUB);
+binary("mul", VM_OP.MUL);
+binary("div", VM_OP.DIV);
+binary("min", VM_OP.MIN);
+binary("max", VM_OP.MAX);
+binary("pow", VM_OP.POW);
+binary("step", VM_OP.STEP);
+define("mad", ["a", "b", "c"], (s, c) => s.emit(VM_OP.MAD, c.out, c.in("a"), c.in("b"), c.in("c")));
+define("mix", ["a", "b", "t"], (s, c) => s.emit(VM_OP.MIX, c.out, c.in("a"), c.in("b"), c.in("t")));
+define("clamp", ["x", "lo", "hi"], (s, c) => s.emit(VM_OP.CLAMP, c.out, c.in("x"), c.in("lo"), c.in("hi")));
+define("smoothstep", ["e0", "e1", "x"], (s, c) => s.emit(VM_OP.SMOOTHSTEP, c.out, c.in("e0"), c.in("e1"), c.in("x")));
+define("scale", ["v", "s"], (s, c) => s.emit(VM_OP.SCALE, c.out, c.in("v"), c.in("s")));
+
+// --- unary math ---
+unary("neg", VM_OP.NEG);
+unary("abs", VM_OP.ABS);
+unary("floor", VM_OP.FLOOR);
+unary("fract", VM_OP.FRACT);
+unary("sqrt", VM_OP.SQRT);
+unary("sin", VM_OP.SIN);
+unary("cos", VM_OP.COS);
+unary("exp", VM_OP.EXP);
+unary("log", VM_OP.LOG);
+unary("normalize", VM_OP.NORMALIZE);
+unary("length", VM_OP.LENGTH);
+
+// --- vector ---
+binary("dot", VM_OP.DOT);
+binary("cross", VM_OP.CROSS);
+binary("distance", VM_OP.DISTANCE);
+define("swizzle", ["x"], (s, c) => {
+    const p = c.parameters.pattern ?? [0, 1, 2, 3];
+    s.emit(VM_OP.SWIZZLE, c.out, c.in("x"), pack_swizzle(p[0], p[1], p[2], p[3]));
+});
+
+// --- logic ---
+define("compare", ["a", "b"], (s, c) => {
+    const opcode = COMPARE_OPCODES[c.parameters.op];
+    if (opcode === undefined) {
+        throw new Error(`Unknown compare op '${c.parameters.op}'`);
+    }
+    s.emit(opcode, c.out, c.in("a"), c.in("b"));
+});
+define("select", ["a", "b", "condition"], (s, c) => s.emit(VM_OP.SELECT, c.out, c.in("a"), c.in("b"), c.in("condition")));
+
+// --- curves ---
+define("curve", ["t"], (s, c) => s.curve(c.out, c.parameters.handle, c.in("t")));
+
+/**
+ * Look up a node type by name.
+ * @param {string} name
+ * @returns {ParticleNodeDescription}
+ * @throws if no such node type exists
+ */
+export function get_particle_node_description(name) {
+    const description = descriptions_by_name.get(name);
+
+    if (description === undefined) {
+        throw new Error(`Unknown particle node type '${name}'`);
+    }
+
+    return description;
+}

package/src/shade/renderer/particles/graph/compile_particle_graph.d.ts

@@ -1,33 +1,38 @@
 /**
- * Lower a single-phase {@link ../graph/ParticleGraph.js} into a VM instruction stream.
+ * Lower a single-phase particle {@link ../../../../core/model/node-graph/NodeGraph.js NodeGraph}
+ * into a VM instruction stream.
+ *
+ * The graph describes one lifecycle phase (SPAWN or UPDATE) of a particle effect: nodes are
+ * {@link ParticleNodeDescription} instances, and every connection wires a producing node's `out`
+ * port to a consuming node's named input port.
  *
  * The pipeline:
  * 1. Walk the graph from its sinks (attribute writes / kill), flattening it into an SSA-style value
- *    list in dependency order. Literal input values are materialised as constant-load values, and
- *    shared sub-expressions are evaluated once (DAG sharing via memoisation).
+ *    list in dependency order. Shared sub-expressions are evaluated once (DAG sharing via
+ *    memoisation).
  * 2. Compute each value's last use.
  * 3. Linear-scan register allocation: registers are returned to the pool at a value's last use, so a
  *    result can reuse a just-consumed input register (VM ops read all sources before writing dst).
- * 4. Emit each value's opcode via its node definition.
+ * 4. Emit each value's opcode via its node description.
  *
- * @param {import("./ParticleGraph.js").ParticleGraph} graph
+ * @param {NodeGraph} graph
  * @param {import("../isa/ParticleAssembler.js").InstructionStream} stream target section
  * @param {ParticleAssembler} asm assembler owning the shared constant pool
  * @param {import("../layout/ParticleLayout.js").ParticleLayout} layout attribute schema
  */
-export function compile_particle_graph(graph: import("./ParticleGraph.js").ParticleGraph, stream: any, asm: ParticleAssembler, layout: import("../layout/ParticleLayout.js").ParticleLayout): void;
+export function compile_particle_graph(graph: NodeGraph, stream: any, asm: ParticleAssembler, layout: import("../layout/ParticleLayout.js").ParticleLayout): void;
 /**
  * Compile a full effect (SPAWN + UPDATE) into a {@link ../isa/ParticleProgram.js}.
  *
  * @param {object} params
- * @param {import("./ParticleGraph.js").ParticleGraph} [params.spawn]
- * @param {import("./ParticleGraph.js").ParticleGraph} [params.update]
+ * @param {NodeGraph} [params.spawn]
+ * @param {NodeGraph} [params.update]
  * @param {import("../layout/ParticleLayout.js").ParticleLayout} params.layout
  * @returns {import("../isa/ParticleProgram.js").ParticleProgram}
  */
 export function compile_particle_effect({ spawn, update, layout }: {
-    spawn?: import("./ParticleGraph.js").ParticleGraph;
-    update?: import("./ParticleGraph.js").ParticleGraph;
+    spawn?: NodeGraph;
+    update?: NodeGraph;
     layout: import("../layout/ParticleLayout.js").ParticleLayout;
 }): import("../isa/ParticleProgram.js").ParticleProgram;
 import { ParticleAssembler } from "../isa/ParticleAssembler.js";

package/src/shade/renderer/particles/graph/compile_particle_graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"compile_particle_graph.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/compile_particle_graph.js"],"names":[],"mappings":"AAIA;;;;;;;;;;;;;;;;GAgBG;AACH,8CALW,OAAO,oBAAoB,EAAE,aAAa,oBAE1C,iBAAiB,UACjB,OAAO,6BAA6B,EAAE,cAAc,QAqD9D;AAED;;;;;;;;GAQG;AACH;IAL+D,KAAK,GAAzD,OAAO,oBAAoB,EAAE,aAAa;IACU,MAAM,GAA1D,OAAO,oBAAoB,EAAE,aAAa;IACmB,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;IAClD,OAAO,2BAA2B,EAAE,eAAe,CAa/D;kCA7FiC,6BAA6B"}
+{"version":3,"file":"compile_particle_graph.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/compile_particle_graph.js"],"names":[],"mappings":"AAGA;;;;;;;;;;;;;;;;;;;;;GAqBG;AACH,2EAHW,iBAAiB,UACjB,OAAO,6BAA6B,EAAE,cAAc,QAqD9D;AAED;;;;;;;;GAQG;AACH;IAL8B,KAAK;IACL,MAAM;IACoC,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;IAClD,OAAO,2BAA2B,EAAE,eAAe,CAa/D;kCAjGiC,6BAA6B"}