@woosh/meep-engine 3.16.0 → 3.17.0

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

@@ -1,303 +1,303 @@
-import { PortDirection } from "../../../../core/model/node-graph/node/PortDirection.js";
-import { ParticleNodeGroup } from "./ParticleNodeGroup.js";
-import { get_particle_node_description, PARTICLE_NODE_OUTPUT_PORT } from "./ParticleNodeRegistry.js";
-import {
-    particle_node_default_parameters,
-    PARTICLE_NODES_WITHOUT_PARAMETERS,
-} from "./particle_node_parameters.js";
-
-/**
- * Writing a node group's body in JavaScript.
- *
- * A group like `simplex3` is two hundred nodes. Assembling that by hand — create a node, look up a
- * port id, create a connection, repeat — is unreadable and unreviewable, and the thing being written
- * is an expression, which JavaScript already spells perfectly well. So this builds the graph out of
- * calls: `g.mul(g.sub(x, low), scale)` creates three nodes and two wires, and reads as what it
- * computes.
- *
- * Every stock operation that takes no parameters of its own is a method here, taken from the library
- * rather than listed — a type added to it is callable the same day. The rest — `const`, `swizzle`,
- * `random`, `curve` and the attribute nodes — need a parameter and are reached through
- * {@link #op}, or through the shorthands below where there is an obvious one.
- *
- * A number where a value is expected becomes a literal, so `g.mul(v, 0.5)` is what it looks like.
- *
- * Each mention of a number is its own node, deliberately. Sharing one would be fewer instructions and
- * a great deal worse: a value's registers are held from where it is produced to its last reader, so a
- * `2.0` shared between the first line of a body and the last would pin its slots across the whole
- * group. The register file is the scarce thing here — see
- * {@link ../ParticleConstants.js PARTICLE_VM_REGISTER_SLOTS} — and the constant pool interns the
- * words anyway, so what the duplication costs is one `LOAD_CONST` and nothing else.
- *
- * ## What comes back
- *
- * Every call returns a **port reference** — a node and one of its output ports — which is the thing
- * wires are made between. Multi-output nodes (another group) hand back a map of them.
- */
-export class ParticleGroupBuilder {
-    /**
-     * The group being built.
-     * @type {ParticleNodeGroup}
-     */
-    group;
-
-    /**
-     * The group's inputs, by name: what the body reads its arguments from.
-     * @type {Object<string, {node: NodeInstance, port: Port}>}
-     */
-    in = {};
-
-    /**
-     * @param {object} options see {@link ParticleNodeGroup.create}
-     */
-    constructor(options) {
-        this.group = ParticleNodeGroup.create(options);
-
-        for (const port of this.group.description.inPorts) {
-            // the input block's port of the same name: inside the group, an input is read from
-            this.in[port.name] = {
-                node: this.group.inputNode,
-                port: this.group.inputNode.description.findPortByNameAndDirection(port.name, PortDirection.Out),
-            };
-        }
-
-        for (const name of PARTICLE_NODES_WITHOUT_PARAMETERS) {
-            if (this[name] !== undefined) {
-                continue;
-            }
-
-            this[name] = (...args) => this.op(name, args);
-        }
-    }
-
-    /**
-     * Create one node of a stock type, wired to the values given.
-     *
-     * Arguments are matched to the type's input ports in declaration order — which is the order the
-     * library declares its operands in, so `op("mad", [a, b, c])` is `a * b + c`. A number stands in
-     * for a literal of that number.
-     *
-     * @param {string} type node type name
-     * @param {Array<{node: NodeInstance, port: Port}|number>} [args] one per input port, in order
-     * @param {object} [parameters] overrides on top of the type's defaults
-     * @returns {{node: NodeInstance, port: Port}} the node's `out` port
-     */
-    op(type, args = [], parameters = {}) {
-        const description = get_particle_node_description(type);
-
-        const node = this.#create(description, parameters);
-
-        const ports = description.inPorts;
-
-        if (args.length !== ports.length) {
-            throw new Error(
-                `'${type}' takes ${ports.length} input${ports.length === 1 ? "" : "s"} `
-                + `(${ports.map(port => port.name).join(", ") || "none"}), given ${args.length}.`
-            );
-        }
-
-        ports.forEach((port, index) => this.#wire(this.#value(args[index]), node, port));
-
-        return { node, port: description.findPortByNameAndDirection(PARTICLE_NODE_OUTPUT_PORT, PortDirection.Out) };
-    }
-
-    /**
-     * Create one instance of another group, wired to the values given by name.
-     *
-     * How a group is built out of groups: `curl3` is twelve `simplex3`s and the arithmetic between
-     * them, and says so.
-     *
-     * @param {ParticleNodeGroup} group
-     * @param {Object<string, {node: NodeInstance, port: Port}|number>} args value per input port name
-     * @returns {Object<string, {node: NodeInstance, port: Port}>} a reference per output port name
-     */
-    call(group, args = {}) {
-        const description = group.description;
-
-        const node = this.#create(description, {});
-
-        for (const port of description.inPorts) {
-            const argument = args[port.name];
-
-            if (argument === undefined) {
-                throw new Error(`Group '${group.name}' has an input '${port.name}' and nothing was given for it.`);
-            }
-
-            this.#wire(this.#value(argument), node, port);
-        }
-
-        const result = {};
-
-        for (const port of description.outPorts) {
-            result[port.name] = { node, port };
-        }
-
-        return result;
-    }
-
-    /**
-     * A literal. One number is a scalar; several are a vector as wide as there are of them.
-     *
-     * @param {...number} components
-     * @returns {{node: NodeInstance, port: Port}}
-     */
-    f(...components) {
-        return this.op("const", [], { value: components.slice() });
-    }
-
-    /**
-     * Pick and reorder lanes, spelled the way the assembly spells it.
-     *
-     * @param {{node: NodeInstance, port: Port}|number} value
-     * @param {string} pattern one to four of `xyzw`
-     * @returns {{node: NodeInstance, port: Port}}
-     */
-    swz(value, pattern) {
-        const lanes = Array.from(pattern).map(lane => "xyzw".indexOf(lane));
-
-        if (lanes.length === 0 || lanes.some(lane => lane === -1)) {
-            throw new Error(`'${pattern}' is not a swizzle: one to four of x, y, z, w.`);
-        }
-
-        return this.op("swizzle", [value], { pattern: lanes });
-    }
-
-    /** @param {{node: NodeInstance, port: Port}|number} v @returns {{node: NodeInstance, port: Port}} */
-    x(v) {
-        return this.swz(v, "x");
-    }
-
-    /** @param {{node: NodeInstance, port: Port}|number} v @returns {{node: NodeInstance, port: Port}} */
-    y(v) {
-        return this.swz(v, "y");
-    }
-
-    /** @param {{node: NodeInstance, port: Port}|number} v @returns {{node: NodeInstance, port: Port}} */
-    z(v) {
-        return this.swz(v, "z");
-    }
-
-    /** @param {{node: NodeInstance, port: Port}|number} v @returns {{node: NodeInstance, port: Port}} */
-    w(v) {
-        return this.swz(v, "w");
-    }
-
-    /**
-     * A value read as a builtin the host provides.
-     *
-     * @param {number} id a {@link ../isa/ParticleVMISA.js VM_BUILTIN}
-     * @returns {{node: NodeInstance, port: Port}}
-     */
-    builtin(id) {
-        return this.op("builtin", [], { id });
-    }
-
-    /**
-     * Expose a value as one of the group's outputs.
-     *
-     * @param {string} name one of the group's declared output ports
-     * @param {{node: NodeInstance, port: Port}|number} value
-     * @returns {void}
-     */
-    out(name, value) {
-        const outputNode = this.group.outputNode;
-
-        const port = outputNode.description.findPortByNameAndDirection(name, PortDirection.In);
-
-        if (port === undefined) {
-            throw new Error(
-                `Group '${this.group.name}' has no output called '${name}'. It has: `
-                + `${this.group.outputs.map(o => o.name).join(", ") || "none"}.`
-            );
-        }
-
-        this.#wire(this.#value(value), outputNode, port);
-    }
-
-    /**
-     * Finish the group, having checked that it is one.
-     *
-     * Everything caught here is caught at the moment the library loads, which is where a broken
-     * built-in group should fail: a group missing an output is a node whose result is nothing, and
-     * finding that out at the far end of a compile in somebody's editor is finding it out too late.
-     *
-     * @returns {ParticleNodeGroup}
-     */
-    build() {
-        const group = this.group;
-
-        for (const port of group.outputNode.description.inPorts) {
-            const wired = group.outputNode.getEndpoint(port.id).inConnections.length;
-
-            if (wired !== 1) {
-                throw new Error(
-                    `Group '${group.name}' output '${port.name}' has ${wired} sources; it takes exactly one.`
-                );
-            }
-        }
-
-        for (const node of group.graph.getNodes()) {
-            if (node === group.inputNode || node === group.outputNode) {
-                continue;
-            }
-
-            for (const port of node.description.inPorts) {
-                if (node.getEndpoint(port.id).inConnections.length !== 1) {
-                    throw new Error(
-                        `Group '${group.name}': input '${port.name}' of a '${node.description.name}' `
-                        + "is not wired to exactly one source."
-                    );
-                }
-            }
-        }
-
-        return group;
-    }
-
-    /**
-     * @param {ParticleNodeDescription} description
-     * @param {object} parameters
-     * @returns {NodeInstance}
-     */
-    #create(description, parameters) {
-        const graph = this.group.graph;
-
-        const node = graph.getNodeSafe(graph.createNode(description));
-
-        // the type's own defaults underneath, so a body written before a type gained a parameter
-        // still builds a node that compiles
-        node.setParameters({
-            ...(description.isParticleGroupNodeDescription === true
-                ? {}
-                : particle_node_default_parameters(description.name)),
-            ...parameters,
-        });
-
-        return node;
-    }
-
-    /**
-     * @param {{node: NodeInstance, port: Port}|number} value
-     * @returns {{node: NodeInstance, port: Port}}
-     */
-    #value(value) {
-        if (typeof value === "number") {
-            return this.f(value);
-        }
-
-        if (value === undefined || value === null || value.node === undefined || value.port === undefined) {
-            throw new Error(`Group '${this.group.name}': ${value} is not a value.`);
-        }
-
-        return value;
-    }
-
-    /**
-     * @param {{node: NodeInstance, port: Port}} source
-     * @param {NodeInstance} node
-     * @param {Port} port
-     */
-    #wire(source, node, port) {
-        this.group.graph.createConnection(source.node.id, source.port.id, node.id, port.id);
-    }
-}
+import { PortDirection } from "../../../../core/model/node-graph/node/PortDirection.js";
+import { ParticleNodeGroup } from "./ParticleNodeGroup.js";
+import { get_particle_node_description, PARTICLE_NODE_OUTPUT_PORT } from "./ParticleNodeRegistry.js";
+import {
+    particle_node_default_parameters,
+    PARTICLE_NODES_WITHOUT_PARAMETERS,
+} from "./particle_node_parameters.js";
+
+/**
+ * Writing a node group's body in JavaScript.
+ *
+ * A group like `simplex3` is two hundred nodes. Assembling that by hand — create a node, look up a
+ * port id, create a connection, repeat — is unreadable and unreviewable, and the thing being written
+ * is an expression, which JavaScript already spells perfectly well. So this builds the graph out of
+ * calls: `g.mul(g.sub(x, low), scale)` creates three nodes and two wires, and reads as what it
+ * computes.
+ *
+ * Every stock operation that takes no parameters of its own is a method here, taken from the library
+ * rather than listed — a type added to it is callable the same day. The rest — `const`, `swizzle`,
+ * `random`, `curve` and the attribute nodes — need a parameter and are reached through
+ * {@link #op}, or through the shorthands below where there is an obvious one.
+ *
+ * A number where a value is expected becomes a literal, so `g.mul(v, 0.5)` is what it looks like.
+ *
+ * Each mention of a number is its own node, deliberately. Sharing one would be fewer instructions and
+ * a great deal worse: a value's registers are held from where it is produced to its last reader, so a
+ * `2.0` shared between the first line of a body and the last would pin its slots across the whole
+ * group. The fast interpreter's register file is the scarce thing here — see
+ * {@link ../ParticleConstants.js PARTICLE_VM_FAST_REGISTER_SLOTS} — and the constant pool interns
+ * the words anyway, so what the duplication costs is one `LOAD_CONST` and nothing else.
+ *
+ * ## What comes back
+ *
+ * Every call returns a **port reference** — a node and one of its output ports — which is the thing
+ * wires are made between. Multi-output nodes (another group) hand back a map of them.
+ */
+export class ParticleGroupBuilder {
+    /**
+     * The group being built.
+     * @type {ParticleNodeGroup}
+     */
+    group;
+
+    /**
+     * The group's inputs, by name: what the body reads its arguments from.
+     * @type {Object<string, {node: NodeInstance, port: Port}>}
+     */
+    in = {};
+
+    /**
+     * @param {object} options see {@link ParticleNodeGroup.create}
+     */
+    constructor(options) {
+        this.group = ParticleNodeGroup.create(options);
+
+        for (const port of this.group.description.inPorts) {
+            // the input block's port of the same name: inside the group, an input is read from
+            this.in[port.name] = {
+                node: this.group.inputNode,
+                port: this.group.inputNode.description.findPortByNameAndDirection(port.name, PortDirection.Out),
+            };
+        }
+
+        for (const name of PARTICLE_NODES_WITHOUT_PARAMETERS) {
+            if (this[name] !== undefined) {
+                continue;
+            }
+
+            this[name] = (...args) => this.op(name, args);
+        }
+    }
+
+    /**
+     * Create one node of a stock type, wired to the values given.
+     *
+     * Arguments are matched to the type's input ports in declaration order — which is the order the
+     * library declares its operands in, so `op("mad", [a, b, c])` is `a * b + c`. A number stands in
+     * for a literal of that number.
+     *
+     * @param {string} type node type name
+     * @param {Array<{node: NodeInstance, port: Port}|number>} [args] one per input port, in order
+     * @param {object} [parameters] overrides on top of the type's defaults
+     * @returns {{node: NodeInstance, port: Port}} the node's `out` port
+     */
+    op(type, args = [], parameters = {}) {
+        const description = get_particle_node_description(type);
+
+        const node = this.#create(description, parameters);
+
+        const ports = description.inPorts;
+
+        if (args.length !== ports.length) {
+            throw new Error(
+                `'${type}' takes ${ports.length} input${ports.length === 1 ? "" : "s"} `
+                + `(${ports.map(port => port.name).join(", ") || "none"}), given ${args.length}.`
+            );
+        }
+
+        ports.forEach((port, index) => this.#wire(this.#value(args[index]), node, port));
+
+        return { node, port: description.findPortByNameAndDirection(PARTICLE_NODE_OUTPUT_PORT, PortDirection.Out) };
+    }
+
+    /**
+     * Create one instance of another group, wired to the values given by name.
+     *
+     * How a group is built out of groups: `curl3` is twelve `simplex3`s and the arithmetic between
+     * them, and says so.
+     *
+     * @param {ParticleNodeGroup} group
+     * @param {Object<string, {node: NodeInstance, port: Port}|number>} args value per input port name
+     * @returns {Object<string, {node: NodeInstance, port: Port}>} a reference per output port name
+     */
+    call(group, args = {}) {
+        const description = group.description;
+
+        const node = this.#create(description, {});
+
+        for (const port of description.inPorts) {
+            const argument = args[port.name];
+
+            if (argument === undefined) {
+                throw new Error(`Group '${group.name}' has an input '${port.name}' and nothing was given for it.`);
+            }
+
+            this.#wire(this.#value(argument), node, port);
+        }
+
+        const result = {};
+
+        for (const port of description.outPorts) {
+            result[port.name] = { node, port };
+        }
+
+        return result;
+    }
+
+    /**
+     * A literal. One number is a scalar; several are a vector as wide as there are of them.
+     *
+     * @param {...number} components
+     * @returns {{node: NodeInstance, port: Port}}
+     */
+    f(...components) {
+        return this.op("const", [], { value: components.slice() });
+    }
+
+    /**
+     * Pick and reorder lanes, spelled the way the assembly spells it.
+     *
+     * @param {{node: NodeInstance, port: Port}|number} value
+     * @param {string} pattern one to four of `xyzw`
+     * @returns {{node: NodeInstance, port: Port}}
+     */
+    swz(value, pattern) {
+        const lanes = Array.from(pattern).map(lane => "xyzw".indexOf(lane));
+
+        if (lanes.length === 0 || lanes.some(lane => lane === -1)) {
+            throw new Error(`'${pattern}' is not a swizzle: one to four of x, y, z, w.`);
+        }
+
+        return this.op("swizzle", [value], { pattern: lanes });
+    }
+
+    /** @param {{node: NodeInstance, port: Port}|number} v @returns {{node: NodeInstance, port: Port}} */
+    x(v) {
+        return this.swz(v, "x");
+    }
+
+    /** @param {{node: NodeInstance, port: Port}|number} v @returns {{node: NodeInstance, port: Port}} */
+    y(v) {
+        return this.swz(v, "y");
+    }
+
+    /** @param {{node: NodeInstance, port: Port}|number} v @returns {{node: NodeInstance, port: Port}} */
+    z(v) {
+        return this.swz(v, "z");
+    }
+
+    /** @param {{node: NodeInstance, port: Port}|number} v @returns {{node: NodeInstance, port: Port}} */
+    w(v) {
+        return this.swz(v, "w");
+    }
+
+    /**
+     * A value read as a builtin the host provides.
+     *
+     * @param {number} id a {@link ../isa/ParticleVMISA.js VM_BUILTIN}
+     * @returns {{node: NodeInstance, port: Port}}
+     */
+    builtin(id) {
+        return this.op("builtin", [], { id });
+    }
+
+    /**
+     * Expose a value as one of the group's outputs.
+     *
+     * @param {string} name one of the group's declared output ports
+     * @param {{node: NodeInstance, port: Port}|number} value
+     * @returns {void}
+     */
+    out(name, value) {
+        const outputNode = this.group.outputNode;
+
+        const port = outputNode.description.findPortByNameAndDirection(name, PortDirection.In);
+
+        if (port === undefined) {
+            throw new Error(
+                `Group '${this.group.name}' has no output called '${name}'. It has: `
+                + `${this.group.outputs.map(o => o.name).join(", ") || "none"}.`
+            );
+        }
+
+        this.#wire(this.#value(value), outputNode, port);
+    }
+
+    /**
+     * Finish the group, having checked that it is one.
+     *
+     * Everything caught here is caught at the moment the library loads, which is where a broken
+     * built-in group should fail: a group missing an output is a node whose result is nothing, and
+     * finding that out at the far end of a compile in somebody's editor is finding it out too late.
+     *
+     * @returns {ParticleNodeGroup}
+     */
+    build() {
+        const group = this.group;
+
+        for (const port of group.outputNode.description.inPorts) {
+            const wired = group.outputNode.getEndpoint(port.id).inConnections.length;
+
+            if (wired !== 1) {
+                throw new Error(
+                    `Group '${group.name}' output '${port.name}' has ${wired} sources; it takes exactly one.`
+                );
+            }
+        }
+
+        for (const node of group.graph.getNodes()) {
+            if (node === group.inputNode || node === group.outputNode) {
+                continue;
+            }
+
+            for (const port of node.description.inPorts) {
+                if (node.getEndpoint(port.id).inConnections.length !== 1) {
+                    throw new Error(
+                        `Group '${group.name}': input '${port.name}' of a '${node.description.name}' `
+                        + "is not wired to exactly one source."
+                    );
+                }
+            }
+        }
+
+        return group;
+    }
+
+    /**
+     * @param {ParticleNodeDescription} description
+     * @param {object} parameters
+     * @returns {NodeInstance}
+     */
+    #create(description, parameters) {
+        const graph = this.group.graph;
+
+        const node = graph.getNodeSafe(graph.createNode(description));
+
+        // the type's own defaults underneath, so a body written before a type gained a parameter
+        // still builds a node that compiles
+        node.setParameters({
+            ...(description.isParticleGroupNodeDescription === true
+                ? {}
+                : particle_node_default_parameters(description.name)),
+            ...parameters,
+        });
+
+        return node;
+    }
+
+    /**
+     * @param {{node: NodeInstance, port: Port}|number} value
+     * @returns {{node: NodeInstance, port: Port}}
+     */
+    #value(value) {
+        if (typeof value === "number") {
+            return this.f(value);
+        }
+
+        if (value === undefined || value === null || value.node === undefined || value.port === undefined) {
+            throw new Error(`Group '${this.group.name}': ${value} is not a value.`);
+        }
+
+        return value;
+    }
+
+    /**
+     * @param {{node: NodeInstance, port: Port}} source
+     * @param {NodeInstance} node
+     * @param {Port} port
+     */
+    #wire(source, node, port) {
+        this.group.graph.createConnection(source.node.id, source.port.id, node.id, port.id);
+    }
+}

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

@@ -145,6 +145,24 @@ export class ParticleNodeDescription extends NodeDescription {
         operation_width: number;
         type: ParticleValueType | null;
     }) => number;
+    /**
+     * Build the body this node stands for, out of stock types, given its own parameters — or `null`
+     * for a type that lowers itself.
+     *
+     * A {@link ./ParticleNodeGroup.js group} is one node made of many whose body is fixed when the
+     * group is built. Some node types are one node made of many whose body is decided by the
+     * *instance*: a gradient with five stops is different arithmetic from a gradient with two, so
+     * there is no single body to build in advance and nothing for a group to hold. Such a type
+     * declares this instead, and {@link ./flatten_particle_graph.js} calls it and splices the result
+     * in exactly as it splices a group — so everything downstream sees stock arithmetic, and
+     * register allocation, sub-expression sharing and the optimizer all apply to it unchanged.
+     *
+     * The group that comes back has to carry the same port names this description does: they are
+     * what the wires around the node are re-made against.
+     *
+     * @type {function(object):import("./ParticleNodeGroup.js").ParticleNodeGroup|null}
+     */
+    expand: (arg0: object) => import("./ParticleNodeGroup.js").ParticleNodeGroup | null;
     /**
      * 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

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

@@ -1 +1 @@
-{"version":3,"file":"ParticleNodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeDescription.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH;IAEI;;;;;;;;;OASG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;;;;;;;;;;OAeG;IACH,sCAFsC;QAAC,EAAE,SAAW,MAAM,KAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,GAAC,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW;gBAAS,MAAM;UAAqB;QAAC,YAAY;gBAAS,MAAM;UAAqB;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,iBAAiB;QAAC,GAAG,oBAAmB;KAAC,KAAE,IAAI,CAEtS;IAEZ;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAFmB;QAAC,MAAM;gBAAS,MAAM,GAAE,oBAAkB,IAAI;UAAE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,iBAAe,SAAS,CAAA;KAAC,KAAE;QAAC,MAAM,EAAE,oBAAkB,IAAI,CAAC;QAAC,MAAM;gBAAS,MAAM,GAAE,oBAAkB,IAAI;UAAC;KAAC,CAYzM;IAEF;;;;;;;;;;;OAWG;IACH,wBAFmB;QAAC,IAAI,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW;gBAAS,MAAM;UAAqB;QAAC,YAAY;gBAAS,MAAM;UAAqB;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,iBAAgB;KAAC,KAAE,MAAM,CAE5I;IAE1E;;;;;;;;;OASG;IACH,qBAFmB;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW;gBAAS,MAAM;UAAqB;QAAC,YAAY;gBAAS,MAAM;UAAqB;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,iBAAgB;KAAC;YAAS,MAAM,GAAE,MAAM;MAEpN;IAE1B;;;;;OAKG;IACH,qBAFmB;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,oBAAkB,IAAI,CAAA;KAAC,KAAE,MAAM,CAE1B;IAExD;;;;;OAKG;IACH,uBAEC;IAGL;;;OAGG;IACH,oCAFU,OAAO,CAE0C;CAN1D;gCA7H+B,2DAA2D"}
+{"version":3,"file":"ParticleNodeDescription.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/ParticleNodeDescription.js"],"names":[],"mappings":"AAKA;;;;;;;;;;;;;;;GAeG;AACH;IAEI;;;;;;;;;OASG;IACH,MAFU,MAAM,CAEN;IAEV;;;;;;;;;;;;;;;OAeG;IACH,sCAFsC;QAAC,EAAE,SAAW,MAAM,KAAE,MAAM,CAAC;QAAC,GAAG,EAAE,MAAM,GAAC,SAAS,CAAC;QAAC,KAAK,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW;gBAAS,MAAM;UAAqB;QAAC,YAAY;gBAAS,MAAM;UAAqB;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,iBAAiB;QAAC,GAAG,oBAAmB;KAAC,KAAE,IAAI,CAEtS;IAEZ;;;;;;;;;;;;;;;;;OAiBG;IACH,oBAFmB;QAAC,MAAM;gBAAS,MAAM,GAAE,oBAAkB,IAAI;UAAE;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,EAAE,iBAAe,SAAS,CAAA;KAAC,KAAE;QAAC,MAAM,EAAE,oBAAkB,IAAI,CAAC;QAAC,MAAM;gBAAS,MAAM,GAAE,oBAAkB,IAAI;UAAC;KAAC,CAYzM;IAEF;;;;;;;;;;;OAWG;IACH,wBAFmB;QAAC,IAAI,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW;gBAAS,MAAM;UAAqB;QAAC,YAAY;gBAAS,MAAM;UAAqB;QAAC,MAAM,EAAE,MAAM,CAAC;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,iBAAgB;KAAC,KAAE,MAAM,CAE5I;IAE1E;;;;;;;;;OASG;IACH,qBAFmB;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,oBAAkB,IAAI,CAAC;QAAC,WAAW;gBAAS,MAAM;UAAqB;QAAC,YAAY;gBAAS,MAAM;UAAqB;QAAC,UAAU,EAAE,MAAM,CAAC;QAAC,MAAM,iBAAgB;KAAC;YAAS,MAAM,GAAE,MAAM;MAEpN;IAE1B;;;;;OAKG;IACH,qBAFmB;QAAC,eAAe,EAAE,MAAM,CAAC;QAAC,IAAI,EAAE,oBAAkB,IAAI,CAAA;KAAC,KAAE,MAAM,CAE1B;IAExD;;;;;;;;;;;;;;;;OAgBG;IACH,eAFmB,MAAM,KAAE,OAAO,wBAAwB,EAAE,iBAAiB,GAAC,IAAI,CAEpE;IAEd;;;;;OAKG;IACH,uBAEC;IAGL;;;OAGG;IACH,oCAFU,OAAO,CAE0C;CAN1D;gCAhJ+B,2DAA2D"}