@woosh/meep-engine 3.16.0 → 3.17.1

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":"AAMA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2EAHW,iBAAiB,UACjB,OAAO,6BAA6B,EAAE,cAAc,QAmB9D;AA8PD;;;;;;;;GAQG;AACH;IAL8B,IAAI;IACJ,MAAM;IACoC,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;IAClD,OAAO,2BAA2B,EAAE,eAAe,CAa/D;kCArUiC,6BAA6B"}
+{"version":3,"file":"compile_particle_graph.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/compile_particle_graph.js"],"names":[],"mappings":"AAOA;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,2EAHW,iBAAiB,UACjB,OAAO,6BAA6B,EAAE,cAAc,QAmB9D;AAkQD;;;;;;;;GAQG;AACH;IAL8B,IAAI;IACJ,MAAM;IACoC,MAAM,EAAnE,OAAO,6BAA6B,EAAE,cAAc;IAClD,OAAO,2BAA2B,EAAE,eAAe,CAa/D;kCA1UiC,6BAA6B"}

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

@@ -1,6 +1,7 @@
 import { PARTICLE_VM_REGISTER_SLOTS } from "../ParticleConstants.js";
 import { ParticleAssembler } from "../isa/ParticleAssembler.js";
 import { VM_MAX_WIDTH } from "../isa/ParticleVMISA.js";
+import { validate_particle_program } from "../isa/validate_particle_program.js";
 import { flatten_particle_graph } from "./flatten_particle_graph.js";
 import { infer_particle_graph_types } from "./infer_particle_graph_types.js";
 
@@ -115,9 +116,13 @@ function lower(graph, stream, asm, layout) {
             ));
 
             if (out === -1) {
+                // The ISA's ceiling, not a shader's. A program that needs more than the fast
+                // interpreter's file has already been dealt with by the time it gets here — the
+                // runtime picks the wide interpreter for it — so reaching this is a graph too big
+                // for anything an instruction can address.
                 throw new Error(
-                    `Particle graph exceeds the VM register file: no run of ${span} free slots in ` +
-                    `${PARTICLE_VM_REGISTER_SLOTS}. Simplify the effect or split it.`
+                    `Particle graph exceeds what a VM instruction can address: no run of ${span} free ` +
+                    `register slots in ${PARTICLE_VM_REGISTER_SLOTS}. Simplify the effect or split it.`
                 );
             }
 
@@ -322,7 +327,7 @@ export function compile_particle_effect({ init, update, layout }) {
         compile_particle_graph(update, asm.update, asm, layout);
     }
     const program = asm.build();
-    program.validate();
+    validate_particle_program(program);
     return program;
 }
 

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

@@ -1 +1 @@
-{"version":3,"file":"flatten_particle_graph.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/flatten_particle_graph.js"],"names":[],"mappings":"AA6CA;;;;;;GAMG;AACH;IAJ4B,UAAU,GAA3B,MAAM;cAgChB"}
+{"version":3,"file":"flatten_particle_graph.d.ts","sourceRoot":"","sources":["../../../../../../src/shade/renderer/particles/graph/flatten_particle_graph.js"],"names":[],"mappings":"AA+FA;;;;;;GAMG;AACH;IAJ4B,UAAU,GAA3B,MAAM;cAgChB"}

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

@@ -1,213 +1,244 @@
-import { is_particle_group_node } from "./ParticleNodeGroup.js";
-
-/**
- * Replace every node group in a graph with the nodes it is made of, until none is left.
- *
- * The step that lets {@link ./ParticleNodeGroup.js groups} exist at all. Everything downstream of
- * here — type resolution, register allocation, lowering — works on one flat expression over the
- * stock library, exactly as it did before there were groups, and a group therefore costs precisely
- * what its contents cost. There is no call, no frame, and nothing to pay for the abstraction with.
- *
- * ## What happens to the wires
- *
- * A group node's ports are wires to nothing — the work is inside. So each is re-made against what
- * was on the other side of the boundary:
- *
- * - a wire *into* the group's input `p` is re-made to every node inside that read the input block's
- *   `p`,
- * - a wire *out of* the group's output `q` is re-made from whatever inside wrote the output block's
- *   `q`,
- * - and where the two meet — the input block wired straight to the output block, a group that passes
- *   a value through — the outer source is joined directly to the outer targets, and nothing of the
- *   group survives at all.
- *
- * A group input with nothing wired to it leaves its inner consumers unbound, which is the same
- * problem stated one level down and is what the compiler already refuses. A group output nobody
- * reads leaves its producer unreachable, which is what the compiler already drops.
- *
- * ## One level at a time
- *
- * Nesting is handled by repeating rather than by recursing: inlining a group can only introduce
- * group nodes that were in its body, and the next pass takes those. It terminates because a group's
- * body can only reference groups that already existed when it was built, so the reference graph is
- * acyclic — see {@link ParticleNodeGroup}. The pass cap is a backstop against a library assembled
- * some other way, not the reason this finishes.
- */
-
-/**
- * How many rounds of inlining to allow. Each round opens one level of nesting, so this is a limit on
- * how deeply groups may be stacked — far past anything an author would build, and low enough that a
- * library that somehow does contain a cycle fails with a sentence instead of a hung tab.
- *
- * @type {number}
- */
-const MAX_INLINE_PASSES = 32;
-
-/**
- * @param {NodeGraph} graph
- * @param {object} [options]
- * @param {number} [options.max_passes] see {@link MAX_INLINE_PASSES}
- * @returns {NodeGraph} a graph with no group nodes in it — `graph` itself when it had none, and a
- *   separate graph otherwise. The input is never modified.
- */
-export function flatten_particle_graph(graph, { max_passes = MAX_INLINE_PASSES } = {}) {
-    if (!graph.getNodes().some(is_particle_group_node)) {
-        // Nothing to open. Returned as-is rather than copied, so that a graph without groups is
-        // compiled under the ids the author sees — which is what every diagnostic naming a node
-        // depends on.
-        return graph;
-    }
-
-    const flat = graph.clone();
-
-    for (let pass = 0; ; pass++) {
-        const groups = flat.getNodes().filter(is_particle_group_node);
-
-        if (groups.length === 0) {
-            return flat;
-        }
-
-        if (pass >= max_passes) {
-            throw new Error(
-                `Node groups are nested more than ${max_passes} deep, or a group contains itself. `
-                + `'${groups[0].description.name}' is still unopened after ${max_passes} passes.`
-            );
-        }
-
-        for (const node of groups) {
-            inline_group(flat, node);
-        }
-    }
-}
-
-/**
- * Splice one group instance's body into the graph around it, and remove the instance.
- *
- * @param {NodeGraph} graph the graph being flattened, modified in place
- * @param {NodeInstance} node the group instance
- */
-function inline_group(graph, node) {
-    const group = node.description.group;
-    const body = group.graph;
-
-    // What the group is wired to, read before anything is taken apart.
-
-    /** @type {Map<string, {node: number, port: number}>} group input port name -> the outer source */
-    const sources = new Map();
-
-    for (const connection of node.inConnections) {
-        const name = connection.target.port.name;
-
-        if (sources.has(name)) {
-            // More than one source on an input is a graph the validator already refuses; taking the
-            // first keeps flattening total rather than adding a second opinion about it.
-            continue;
-        }
-
-        sources.set(name, { node: connection.source.instance.id, port: connection.source.port.id });
-    }
-
-    /** @type {Map<string, Array<{node: number, port: number}>>} group output port name -> outer targets */
-    const targets = new Map();
-
-    for (const connection of node.outConnections) {
-        const name = connection.source.port.name;
-
-        const listed = targets.get(name) ?? [];
-
-        listed.push({ node: connection.target.instance.id, port: connection.target.port.id });
-
-        targets.set(name, listed);
-    }
-
-    // A copy of every node in the body, boundary blocks excepted: those are the group's edge, and
-    // the edge is what is being dissolved.
-
-    /** @type {Map<number, NodeInstance>} body node id -> its copy in `graph` */
-    const copies = new Map();
-
-    for (const inner of body.getNodes()) {
-        if (inner === group.inputNode || inner === group.outputNode) {
-            continue;
-        }
-
-        const copy = graph.getNodeSafe(graph.createNode(inner.description));
-
-        copy.setParameters(clone_parameters(inner.parameters));
-
-        copies.set(inner.id, copy);
-    }
-
-    for (const connection of body.getConnections()) {
-        const from = connection.source;
-        const to = connection.target;
-
-        const from_boundary = from.instance === group.inputNode;
-        const to_boundary = to.instance === group.outputNode;
-
-        if (from_boundary && to_boundary) {
-            // straight through: the group contributes nothing but a rename
-            const source = sources.get(from.port.name);
-
-            for (const target of targets.get(to.port.name) ?? []) {
-                if (source !== undefined) {
-                    graph.createConnection(source.node, source.port, target.node, target.port);
-                }
-            }
-
-            continue;
-        }
-
-        if (from_boundary) {
-            const source = sources.get(from.port.name);
-
-            if (source !== undefined) {
-                const target = copies.get(to.instance.id);
-
-                graph.createConnection(source.node, source.port, target.id, to.port.id);
-            }
-
-            continue;
-        }
-
-        if (to_boundary) {
-            const source = copies.get(from.instance.id);
-
-            for (const target of targets.get(to.port.name) ?? []) {
-                graph.createConnection(source.id, from.port.id, target.node, target.port);
-            }
-
-            continue;
-        }
-
-        graph.createConnection(
-            copies.get(from.instance.id).id, from.port.id,
-            copies.get(to.instance.id).id, to.port.id
-        );
-    }
-
-    // takes the group's own wires with it; every one of them has been re-made above
-    graph.deleteNode(node.id);
-}
-
-/**
- * A node's parameters, deep enough that the copy and the original cannot write through to each
- * other. Values are numbers, strings, and arrays of numbers.
- *
- * A body's node is the template for every instance of its group, so sharing an array between them
- * would make an edit to one instance an edit to all of them — including the definition itself.
- *
- * @param {object} parameters
- * @returns {object}
- */
-function clone_parameters(parameters) {
-    const result = {};
-
-    for (const key of Object.keys(parameters)) {
-        const value = parameters[key];
-
-        result[key] = Array.isArray(value) ? value.slice() : value;
-    }
-
-    return result;
-}
+import { clone_particle_parameters } from "./particle_node_parameters.js";
+import { is_particle_group_node } from "./ParticleNodeGroup.js";
+
+/**
+ * Replace every node group in a graph with the nodes it is made of, until none is left.
+ *
+ * The step that lets {@link ./ParticleNodeGroup.js groups} exist at all. Everything downstream of
+ * here — type resolution, register allocation, lowering — works on one flat expression over the
+ * stock library, exactly as it did before there were groups, and a group therefore costs precisely
+ * what its contents cost. There is no call, no frame, and nothing to pay for the abstraction with.
+ *
+ * ## What happens to the wires
+ *
+ * A group node's ports are wires to nothing — the work is inside. So each is re-made against what
+ * was on the other side of the boundary:
+ *
+ * - a wire *into* the group's input `p` is re-made to every node inside that read the input block's
+ *   `p`,
+ * - a wire *out of* the group's output `q` is re-made from whatever inside wrote the output block's
+ *   `q`,
+ * - and where the two meet — the input block wired straight to the output block, a group that passes
+ *   a value through — the outer source is joined directly to the outer targets, and nothing of the
+ *   group survives at all.
+ *
+ * A group input with nothing wired to it leaves its inner consumers unbound, which is the same
+ * problem stated one level down and is what the compiler already refuses. A group output nobody
+ * reads leaves its producer unreachable, which is what the compiler already drops.
+ *
+ * ## Nodes that build their own body
+ *
+ * A handful of types are not groups but are made of other nodes all the same — a gradient, a curve —
+ * and their body depends on their own parameters, so there is no shared one for a group to hold.
+ * They declare {@link ./ParticleNodeDescription.js ParticleNodeDescription#expand} and are opened
+ * here by exactly the same splice: what `expand` returns is a group, built on the spot, and once it
+ * is spliced in nothing tells the two apart. They do not nest — an expansion is built out of stock
+ * types — but nothing here depends on that.
+ *
+ * ## One level at a time
+ *
+ * Nesting is handled by repeating rather than by recursing: inlining a group can only introduce
+ * group nodes that were in its body, and the next pass takes those. It terminates because a group's
+ * body can only reference groups that already existed when it was built, so the reference graph is
+ * acyclic — see {@link ParticleNodeGroup}. The pass cap is a backstop against a library assembled
+ * some other way, not the reason this finishes.
+ */
+
+/**
+ * Whether a node is made of other nodes, and so is something this has to open.
+ *
+ * Two kinds are. A {@link ./ParticleNodeGroup.js group} *has* a body — one body, shared by every
+ * instance of it. An expanding type *builds* one from the instance's own parameters, because there
+ * is no single body a gradient with any number of stops could share. Asked before
+ * {@link body_of}, and separately from it, because answering it for an expanding node is free and
+ * building the body is not.
+ *
+ * @param {NodeInstance} node
+ * @returns {boolean}
+ */
+function is_compound(node) {
+    return is_particle_group_node(node) || typeof node.description?.expand === "function";
+}
+
+/**
+ * The body one node stands for. Everything past this point treats the two kinds identically: what
+ * comes back is a group, and it is spliced in the same way.
+ *
+ * @param {NodeInstance} node one {@link is_compound} holds for
+ * @returns {import("./ParticleNodeGroup.js").ParticleNodeGroup}
+ */
+function body_of(node) {
+    if (is_particle_group_node(node)) {
+        return node.description.group;
+    }
+
+    const group = node.description.expand(node.parameters);
+
+    if (group === null || group === undefined) {
+        throw new Error(
+            `'${node.description.name}' declares an expansion and node ${node.id} produced none; `
+            + "a type that expands has to expand for every parameter value it accepts."
+        );
+    }
+
+    return group;
+}
+
+/**
+ * How many rounds of inlining to allow. Each round opens one level of nesting, so this is a limit on
+ * how deeply groups may be stacked — far past anything an author would build, and low enough that a
+ * library that somehow does contain a cycle fails with a sentence instead of a hung tab.
+ *
+ * @type {number}
+ */
+const MAX_INLINE_PASSES = 32;
+
+/**
+ * @param {NodeGraph} graph
+ * @param {object} [options]
+ * @param {number} [options.max_passes] see {@link MAX_INLINE_PASSES}
+ * @returns {NodeGraph} a graph with no group nodes in it — `graph` itself when it had none, and a
+ *   separate graph otherwise. The input is never modified.
+ */
+export function flatten_particle_graph(graph, { max_passes = MAX_INLINE_PASSES } = {}) {
+    if (!graph.getNodes().some(is_compound)) {
+        // Nothing to open. Returned as-is rather than copied, so that a graph without groups is
+        // compiled under the ids the author sees — which is what every diagnostic naming a node
+        // depends on.
+        return graph;
+    }
+
+    const flat = graph.clone();
+
+    for (let pass = 0; ; pass++) {
+        const compound = flat.getNodes().filter(is_compound);
+
+        if (compound.length === 0) {
+            return flat;
+        }
+
+        if (pass >= max_passes) {
+            throw new Error(
+                `Node groups are nested more than ${max_passes} deep, or a group contains itself. `
+                + `'${compound[0].description.name}' is still unopened after ${max_passes} passes.`
+            );
+        }
+
+        for (const node of compound) {
+            inline_group(flat, node, body_of(node));
+        }
+    }
+}
+
+/**
+ * Splice one group instance's body into the graph around it, and remove the instance.
+ *
+ * @param {NodeGraph} graph the graph being flattened, modified in place
+ * @param {NodeInstance} node the group instance
+ * @param {import("./ParticleNodeGroup.js").ParticleNodeGroup} group the body it stands for
+ */
+function inline_group(graph, node, group) {
+    const body = group.graph;
+
+    // What the group is wired to, read before anything is taken apart.
+
+    /** @type {Map<string, {node: number, port: number}>} group input port name -> the outer source */
+    const sources = new Map();
+
+    for (const connection of node.inConnections) {
+        const name = connection.target.port.name;
+
+        if (sources.has(name)) {
+            // More than one source on an input is a graph the validator already refuses; taking the
+            // first keeps flattening total rather than adding a second opinion about it.
+            continue;
+        }
+
+        sources.set(name, { node: connection.source.instance.id, port: connection.source.port.id });
+    }
+
+    /** @type {Map<string, Array<{node: number, port: number}>>} group output port name -> outer targets */
+    const targets = new Map();
+
+    for (const connection of node.outConnections) {
+        const name = connection.source.port.name;
+
+        const listed = targets.get(name) ?? [];
+
+        listed.push({ node: connection.target.instance.id, port: connection.target.port.id });
+
+        targets.set(name, listed);
+    }
+
+    // A copy of every node in the body, boundary blocks excepted: those are the group's edge, and
+    // the edge is what is being dissolved.
+
+    /** @type {Map<number, NodeInstance>} body node id -> its copy in `graph` */
+    const copies = new Map();
+
+    for (const inner of body.getNodes()) {
+        if (inner === group.inputNode || inner === group.outputNode) {
+            continue;
+        }
+
+        const copy = graph.getNodeSafe(graph.createNode(inner.description));
+
+        // A body's node is the template for every instance of its group, so sharing anything mutable
+        // with it would make an edit to one instance an edit to all of them — the definition
+        // included.
+        copy.setParameters(clone_particle_parameters(inner.parameters));
+
+        copies.set(inner.id, copy);
+    }
+
+    for (const connection of body.getConnections()) {
+        const from = connection.source;
+        const to = connection.target;
+
+        const from_boundary = from.instance === group.inputNode;
+        const to_boundary = to.instance === group.outputNode;
+
+        if (from_boundary && to_boundary) {
+            // straight through: the group contributes nothing but a rename
+            const source = sources.get(from.port.name);
+
+            for (const target of targets.get(to.port.name) ?? []) {
+                if (source !== undefined) {
+                    graph.createConnection(source.node, source.port, target.node, target.port);
+                }
+            }
+
+            continue;
+        }
+
+        if (from_boundary) {
+            const source = sources.get(from.port.name);
+
+            if (source !== undefined) {
+                const target = copies.get(to.instance.id);
+
+                graph.createConnection(source.node, source.port, target.id, to.port.id);
+            }
+
+            continue;
+        }
+
+        if (to_boundary) {
+            const source = copies.get(from.instance.id);
+
+            for (const target of targets.get(to.port.name) ?? []) {
+                graph.createConnection(source.id, from.port.id, target.node, target.port);
+            }
+
+            continue;
+        }
+
+        graph.createConnection(
+            copies.get(from.instance.id).id, from.port.id,
+            copies.get(to.instance.id).id, to.port.id
+        );
+    }
+
+    // takes the group's own wires with it; every one of them has been re-made above
+    graph.deleteNode(node.id);
+}

package/src/shade/renderer/particles/graph/groups/particle_builtin_groups.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_builtin_groups.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/particle_builtin_groups.js"],"names":[],"mappings":"AAuBA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;GAQG;AACH,sCAFU,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,CAuB7D"}
+{"version":3,"file":"particle_builtin_groups.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/particle_builtin_groups.js"],"names":[],"mappings":"AA2BA;;;;;;;;;;;;;;;GAeG;AAEH;;;;;;;;GAQG;AACH,sCAFU,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,CAyB7D"}

package/src/shade/renderer/particles/graph/groups/particle_builtin_groups.js

@@ -13,6 +13,10 @@ import {
     PARTICLE_GROUP_SIMPLEX_3,
     PARTICLE_GROUP_SIMPLEX_4,
 } from "./particle_groups_noise.js";
+import {
+    PARTICLE_GROUP_PSRDNOISE_3,
+    PARTICLE_GROUP_SRDNOISE_3,
+} from "./particle_groups_psrdnoise.js";
 import {
     PARTICLE_GROUP_CEIL,
     PARTICLE_GROUP_DECOMPOSE,
@@ -66,6 +70,8 @@ export const PARTICLE_BUILTIN_GROUPS = [
     // the expensive ones
     PARTICLE_GROUP_SIMPLEX_3,
     PARTICLE_GROUP_SIMPLEX_4,
+    PARTICLE_GROUP_SRDNOISE_3,
+    PARTICLE_GROUP_PSRDNOISE_3,
     PARTICLE_GROUP_CURL_3,
     PARTICLE_GROUP_CURL_4,
 ];

package/src/shade/renderer/particles/graph/groups/particle_groups_geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"particle_groups_geometry.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/particle_groups_geometry.js"],"names":[],"mappings":"AA8DA;;;;;;;;;;;GAWG;AACH,mDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAsBxD;AAEL;;;;;;;;;GASG;AACH,kDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAmBxD;AAEL;;;;;;;;;;;;GAYG;AACH,2CAFU,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,CAiB5D;AAEH;;;;;;;;GAQG;AACH,kDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAsBxD;AAEL;;;;;;;;;;;GAWG;AACH,yCAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAuBxD;AAEL;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA+ExD"}
+{"version":3,"file":"particle_groups_geometry.d.ts","sourceRoot":"","sources":["../../../../../../../src/shade/renderer/particles/graph/groups/particle_groups_geometry.js"],"names":[],"mappings":"AAqCA;;;;;;;;;;;GAWG;AACH,mDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAsBxD;AAEL;;;;;;;;;GASG;AACH,kDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAmBxD;AAEL;;;;;;;;;;;;GAYG;AACH,2CAFU,OAAO,yBAAyB,EAAE,iBAAiB,EAAE,CAiB5D;AAEH;;;;;;;;GAQG;AACH,kDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAsBxD;AAEL;;;;;;;;;;;GAWG;AACH,yCAFU,OAAO,yBAAyB,EAAE,iBAAiB,CAuBxD;AAEL;;;;;;;;;;;;;;;;;;;GAmBG;AACH,gDAFU,OAAO,yBAAyB,EAAE,iBAAiB,CA+ExD"}