@shaderfrog/core 2.0.0-beta.3 → 3.0.0

package/graph/graph.js

@@ -72,13 +72,13 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import { renameBindings, renameFunctions, } from '@shaderfrog/glsl-parser/parser/utils';
 import { computeGraphContext, isError, } from './context';
-import { emptyShaderSections, findShaderSections, mergeShaderSections, shaderSectionsToProgram, } from './shader-sections';
-import { makeExpression } from '../util/ast';
+import { shaderSectionsCons, findShaderSections, mergeShaderSections, shaderSectionsToProgram, } from './shader-sections';
+import { backfillAst, makeExpression } from '../util/ast';
 import { ensure } from '../util/ensure';
 import { SourceType } from './code-nodes';
 import { nodeInput } from './base-node';
 import { makeId } from '../util/id';
-import { coreParsers } from './parsers';
+import { alphabet, coreParsers } from './parsers';
 import { toGlsl } from './evaluate';
 import { EdgeLink, MAGIC_OUTPUT_STMTS, NodeType, } from './graph-types';
 import { generate } from '@shaderfrog/glsl-parser';
@@ -96,6 +96,21 @@ export var isDataNode = function (node) {
 export var isSourceNode = function (node) {
     return !isDataNode(node);
 };
+/**
+ * Determine if a node's source code / AST should have a main function. Essentially
+ * check if the source code is a full program or not.
+ */
+export var shouldNodeHaveMainFn = function (node) {
+    // Some legacy shaders have an output node that does not have a sourceType,
+    // otherwise the sourceType second check would always work
+    return node.type === NodeType.OUTPUT ||
+        // Same for code nodes :(
+        (isSourceNode(node) && !node.sourceType) ||
+        node.sourceType === SourceType.SHADER_PROGRAM ||
+        // Engine nodes can have rando types like "physical", so if they are engine
+        // nodes, assume they have a main fn.
+        node.engine;
+};
 export var findNode = function (graph, id) {
     return ensure(graph.nodes.find(function (node) { return node.id === id; }));
 };
@@ -120,6 +135,7 @@ export var doesLinkThruShader = function (graph, node) {
 export var nodeName = function (node) {
     return 'main_' + node.name.replace(/[^a-zA-Z0-9]/g, ' ').replace(/ +/g, '_');
 };
+export var resultName = function (node) { return nodeName(node) + '_out'; };
 export var mangleName = function (name, node, nextSibling) {
     // Mangle a name to its next stage node, so the vertex suffix becomes the
     // fragment id, but not the other way around.
@@ -157,9 +173,59 @@ export var resetGraphIds = function (graph) {
         edges: graph.edges.map(function (e) { return (__assign(__assign({}, e), { id: map(e.id), from: map(e.from), to: map(e.to) })); }),
     };
 };
-export var findLinkedNode = function (graph, id) {
-    var edgeLink = graph.edges.find(function (e) { return e.type === EdgeLink.NEXT_STAGE && (e.from === id || e.to === id); });
-    var otherId = (edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from) === id ? edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.to : edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from;
+/**
+ * A binary node automatically adds/removes inputs based on how many edges
+ * connect to it. If a binary node has edges to "a" and "b", removing the edge
+ * to "a" means the edge to "b" needs to be moved down to the "a" one. This
+ * function essentially groups edges by target node id, and resets the edge
+ * target to its index. This doesn't feel good to do here but I don't have a
+ * better idea at the moment. One reason the inputs to binary nodes are
+ * automatically updated after compile, but the edges are updated here
+ * at the editor layer, before compile. This also hard codes assumptions about
+ * (binary) node inputs into the graph, namely they can't have blank inputs.
+ */
+export var collapseBinaryGraphEdges = function (graph) {
+    // Find all edges that flow into a binary node, grouped by the target node's
+    // id, since we need to know the total number of edges per node first
+    var binaryEdges = graph.edges.reduce(function (acc, edge) {
+        var _a;
+        var toNode = findNode(graph, edge.to);
+        return toNode.type === NodeType.BINARY
+            ? __assign(__assign({}, acc), (_a = {}, _a[toNode.id] = __spreadArray(__spreadArray([], __read((acc[toNode.id] || [])), false), [edge], false), _a)) : acc;
+    }, {});
+    // Then collapse them
+    var updatedEdges = graph.edges.map(function (edge) {
+        return edge.to in binaryEdges
+            ? __assign(__assign({}, edge), { input: alphabet.charAt(binaryEdges[edge.to].indexOf(edge)) }) : edge;
+    });
+    return __assign(__assign({}, graph), { edges: updatedEdges });
+};
+/**
+ * Restrict edges so that an input handle can't have multiple edges going to it
+ */
+export var addEdgeAndPruneRestrictions = function (edges, newEdge) {
+    return edges
+        .filter(function (edge) {
+        // Prevent one input handle from having multiple inputs
+        return !(edge.to === newEdge.to && edge.input === newEdge.input);
+    })
+        .concat(newEdge);
+};
+/**
+ * Adds an edge to the graph and enforces graph edge business logic rules:
+ * - Makes sure "binary" (add/multiply) nodes edges are collapsed
+ * - Makes sure two edges can't flow into the same input.
+ * See also editor/flow-helpers.ts
+ */
+export var addGraphEdge = function (graph, newEdge) {
+    return collapseBinaryGraphEdges(__assign(__assign({}, graph), { edges: addEdgeAndPruneRestrictions(graph.edges, newEdge) }));
+};
+export var findLinkedNode = function (graph, nodeId) {
+    var edgeLink = graph.edges.find(function (e) {
+        return e.type === EdgeLink.NEXT_STAGE && (e.from === nodeId || e.to === nodeId);
+    });
+    var otherId = (edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from) === nodeId ? edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.to : edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from;
+    // Only source nodes can be linked, so cast it
     return graph.nodes.find(function (node) { return node.id === otherId; });
 };
 /**
@@ -187,12 +253,12 @@ export var findLinkedVertexNodes = function (graph, existingIds) {
 export var consSearchResult = function () { return ({
     nodes: {},
     inputs: {},
-    edges: [],
+    edges: {},
 }); };
 export var mergeSearchResults = function (a, b) { return ({
     nodes: __assign(__assign({}, a.nodes), b.nodes),
     inputs: __assign(__assign({}, a.inputs), b.inputs),
-    edges: __spreadArray(__spreadArray([], __read(a.edges), false), __read(b.edges), false),
+    edges: __assign(__assign({}, a.edges), b.edges),
 }); };
 /**
  * Create the inputs on a node from the properties. This used to be done at
@@ -220,23 +286,24 @@ export var filterGraphFromNode = function (graph, node, predicates, depth, lastR
         ? (_a = {}, _a[node.id] = node, _a) : {}));
     var accumulatedResult = __assign(__assign({}, lastResult), { nodes: __assign(__assign({}, lastResult.nodes), nodeAcc) });
     return inputEdges.reduce(function (acc, inputEdge) {
-        var _a;
+        var _a, _b;
         var input = inputs.find(function (i) { return i.id === inputEdge.input; });
         var fromNode = inputEdge ? ensureFromNode(graph, inputEdge) : undefined;
         var inputAcc = __assign(__assign({}, acc.inputs), (input &&
             predicates.input &&
             predicates.input(input, node, inputEdge, fromNode, lastResult)
             ? (_a = {}, _a[node.id] = __spreadArray(__spreadArray([], __read((acc.inputs[node.id] || [])), false), [input], false), _a) : {}));
-        var edgeAcc = __spreadArray(__spreadArray([], __read(acc.edges), false), __read((predicates.edge &&
+        var edgeAcc = __assign(__assign({}, acc.edges), (predicates.edge &&
             predicates.edge(input, node, inputEdge, fromNode, lastResult)
-            ? [inputEdge]
-            : [])), false);
+            ? (_b = {}, _b[inputEdge.id] = inputEdge, _b) : {}));
         // Add in the latest result of edges and inputs so that when we recurse into
         // the next node, it has the latest accumulator
         var intermediateAcc = __assign(__assign({}, acc), { inputs: inputAcc, edges: edgeAcc });
         if (inputEdge && fromNode && depth > 1) {
             var result = filterGraphFromNode(graph, fromNode, predicates, depth - 1, intermediateAcc);
-            return mergeSearchResults(intermediateAcc, result);
+            // The result is automatically the combination of the currenet acc and the
+            // result of the recursed data
+            return result;
         }
         else {
             return intermediateAcc;
@@ -246,13 +313,20 @@ export var filterGraphFromNode = function (graph, node, predicates, depth, lastR
 export var collectConnectedNodes = function (graph, node) {
     return filterGraphFromNode(graph, node, { node: function () { return true; } }).nodes;
 };
+var merge = function (a, b) {
+    var keys = new Set(__spreadArray(__spreadArray([], __read(Object.keys(a)), false), __read(Object.keys(b)), false));
+    return Array.from(keys).reduce(function (acc, key) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[key] = __spreadArray(__spreadArray([], __read((a[key] || [])), false), __read((b[key] || [])), false), _a)));
+    }, {});
+};
 export var filterGraphNodes = function (graph, nodes, filter, depth) {
     if (depth === void 0) { depth = Infinity; }
     return nodes.reduce(function (acc, node) {
         var result = filterGraphFromNode(graph, node, filter, depth);
         return {
             nodes: __assign(__assign({}, acc.nodes), result.nodes),
-            inputs: __assign(__assign({}, acc.inputs), result.inputs),
+            inputs: merge(acc.inputs, result.inputs),
             edges: __assign(__assign({}, acc.edges), result.edges),
         };
     }, consSearchResult());
@@ -264,10 +338,11 @@ export var isDataInput = function (input) {
     return (input.type === 'uniform' || input.type === 'property') && !input.baked;
 };
 export var compileNode = function (engine, graph, edges, engineContext, node, activeIds) {
-    var _a, _b;
+    var _a;
     if (activeIds === void 0) { activeIds = {}; }
     // THIS DUPLICATES OTHER LINE
     var parser = __assign(__assign({}, (coreParsers[node.type] || coreParsers[NodeType.SOURCE])), (engine.parsers[node.type] || {}));
+    var codeNode = node;
     var inputs = node.inputs;
     if (!parser) {
         console.error(node);
@@ -276,135 +351,101 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
     var nodeContext = isDataNode(node)
         ? null
         : ensure(engineContext.nodes[node.id], "No node context found for \"".concat(node.name, "\" (id ").concat(node.id, ")!"));
-    var _c = (nodeContext || {}), ast = _c.ast, inputFillers = _c.inputFillers;
-    if (!inputs) {
-        throw new Error("I'm drunk and I think this case should be impossible");
+    var _b = nodeContext || {}, ast = _b.ast, inputFillers = _b.inputFillers;
+    if (!ast || !inputFillers) {
+        throw new Error("I'm drunk while writing this code, and I think this case should be impossible, so I'm going to throw an error and ignore it");
     }
     var compiledIds = activeIds;
     var inputEdges = edges.filter(function (edge) { return edge.to === node.id; });
-    if (inputEdges.length) {
-        var continuation_1 = emptyShaderSections();
-        inputEdges
-            .filter(function (edge) { return edge.type !== EdgeLink.NEXT_STAGE; })
-            .map(function (edge) { return ({
-            edge: edge,
-            fromNode: ensure(graph.nodes.find(function (node) { return edge.from === node.id; }), "GraphNode for edge ".concat(edge.from, " not found")),
-            input: ensure(inputs.find(function (_a) {
-                var id = _a.id;
-                return id == edge.input;
-            }), "GraphNode \"".concat(node.name, "\"").concat(node.stage ? " (".concat(node.stage, ")") : '', " has no input ").concat(edge.input, "!\nAvailable:").concat(inputs
-                .map(function (_a) {
-                var id = _a.id;
-                return id;
-            })
-                .join(', '))),
-        }); })
-            .filter(function (_a) {
-            var input = _a.input;
-            return !isDataInput(input);
+    var continuation = shaderSectionsCons();
+    // Compile children recursively
+    inputEdges
+        .filter(function (edge) { return edge.type !== EdgeLink.NEXT_STAGE; })
+        .map(function (edge) { return ({
+        edge: edge,
+        fromNode: ensure(graph.nodes.find(function (node) { return edge.from === node.id; }), "GraphNode for edge ".concat(edge.from, " not found")),
+        input: ensure(inputs.find(function (_a) {
+            var id = _a.id;
+            return id == edge.input;
+        }), "GraphNode \"".concat(node.name, "\"").concat(node.stage ? " (".concat(node.stage, ")") : '', " has no input ").concat(edge.input, "!\nAvailable:").concat(inputs
+            .map(function (_a) {
+            var id = _a.id;
+            return id;
         })
-            .forEach(function (_a) {
-            var _b;
-            var fromNode = _a.fromNode, edge = _a.edge, input = _a.input;
-            var _c = __read(compileNode(engine, graph, edges, engineContext, fromNode, activeIds), 3), inputSections = _c[0], fillerAst = _c[1], childIds = _c[2];
-            if (!fillerAst) {
-                throw new TypeError("Expected a filler ast from node ID ".concat(fromNode.id, " (").concat(fromNode.type, ") but none was returned"));
-            }
-            continuation_1 = mergeShaderSections(continuation_1, inputSections);
-            compiledIds = __assign(__assign({}, compiledIds), childIds);
-            var filler;
-            var fillerName;
-            if (nodeContext) {
-                if (input.property) {
-                    fillerName = ensure((_b = (node.config.properties || []).find(function (p) { return p.property === input.property; })) === null || _b === void 0 ? void 0 : _b.fillerName, "Node \"".concat(node.name, "\" has no property named \"").concat(input.property, "\" to find the filler for"));
-                    filler = inputFillers[fillerName];
-                }
-                else {
-                    filler = inputFillers[input.id];
-                }
-                if (!filler) {
-                    console.error('No filler for property', {
-                        input: input,
-                        node: node,
-                        inputFillers: inputFillers,
-                        fillerName: fillerName,
-                    });
-                    throw new Error("Node \"".concat(node.name, "\"").concat(node.stage
-                        ? " (".concat(node.stage, ")")
-                        : '', " has no filler for input \"").concat(input.displayName, "\" named ").concat(fillerName));
-                }
-                /**
-                 *      +------+    +------+
-                 * a -- o add  o -- o tex  |
-                 * b -- o      |    +------+
-                 *      +------+
-                 *
-                 * This could produce:
-                 *     main_a(v1) + main_b(v2)
-                 * I guess it has to? or it could produce
-                 *     function add(v1) { return main_a(v1) + main_b(v2); }
-                 * It can't replace the arg _expression_ in the from shaders, because
-                 * the expression isn't available there.
-                 */
-                // TODO: This is a hard coded hack for vUv backfilling. It works in
-                // the simple case. Doesn't work for hell (based on world position).
-                if (filler.backfillArgs &&
-                    !Array.isArray(fillerAst) &&
-                    fillerAst.type === 'function_call') {
-                    // Object.values(filterGraphFromNode(graph, node, {
-                    //   node: (n) => n.type === 'source'
-                    // }).nodes).forEach(sourceNode => {
-                    if (fromNode.type === 'source') {
-                        // @ts-ignore
-                        fillerAst.args = filler.backfillArgs;
-                        // const fc = engineContext.nodes[sourceNode.id];
-                        var fc = engineContext.nodes[fromNode.id];
-                        var main = Object.values(fc.ast.scopes[0].functions.main)[0].declaration;
-                        main.prototype.parameters = [
-                            'vec2 vv',
-                        ];
-                        // @ts-ignore
-                        var scope = fc.ast.scopes[0];
-                        // renameBindings(scope, (name, node) => {
-                        //   return node.type !== 'declaration' && name === 'vUv'
-                        //     ? 'vv'
-                        //     : name;
-                        // });
-                    }
-                    // })
-                }
-                // Fill in the input! The return value is the new AST of the filled in
-                // fromNode.
-                nodeContext.ast = filler.filler(fillerAst);
+            .join(', '))),
+    }); })
+        .filter(function (_a) {
+        var input = _a.input;
+        return !isDataInput(input);
+    })
+        .forEach(function (_a) {
+        var _b, _c;
+        var fromNode = _a.fromNode, input = _a.input;
+        var _d = __read(compileNode(engine, graph, edges, engineContext, fromNode, activeIds), 3), inputSections = _d[0], fillerFn = _d[1], childIds = _d[2];
+        if (!fillerFn) {
+            throw new TypeError("Expected a filler ast from node ID ".concat(fromNode.id, " (").concat(fromNode.type, ") but none was returned"));
+        }
+        continuation = mergeShaderSections(continuation, inputSections);
+        compiledIds = __assign(__assign({}, compiledIds), childIds);
+        // Continue on if there's no context I don't know what case causes this
+        if (!nodeContext) {
+            return;
+        }
+        // Produce the input filler
+        var filler;
+        var fillerName;
+        if (input.property) {
+            fillerName = ensure((_b = (codeNode.config.properties || []).find(function (p) { return p.property === input.property; })) === null || _b === void 0 ? void 0 : _b.fillerName, "Node \"".concat(node.name, "\" has no property named \"").concat(input.property, "\" to find the filler for"));
+            filler = inputFillers[fillerName];
+        }
+        else {
+            filler = inputFillers[input.id];
+        }
+        if (!filler) {
+            console.error('No filler for property', {
+                input: input,
+                node: node,
+                inputFillers: inputFillers,
+                fillerName: fillerName,
+            });
+            return;
+            // throw new Error(
+            //   `Node "${node.name}"${
+            //     (node as SourceNode).stage ? ` (${(node as SourceNode).stage})` : ''
+            //   } has no filler for input "${input.displayName}" named ${fillerName}`,
+            // );
+        }
+        // Test if it needs to be backfilled - this only goes one level deep
+        // because we're only backfilling fromNode
+        var backfillers = (_c = codeNode.backfillers) === null || _c === void 0 ? void 0 : _c[input.id];
+        if (backfillers && shouldNodeHaveMainFn(fromNode)) {
+            var childAst_1 = engineContext.nodes[fromNode.id].ast;
+            // For now we can only backfill programs
+            if (childAst_1.type === 'program') {
+                backfillers.forEach(function (backfiller) {
+                    // This is where the variable name gets injected into the main
+                    // function parameter of the backfilled child
+                    backfillAst(childAst_1, backfiller.argType, backfiller.targetVariable, engineContext.nodes[fromNode.id].mainFn);
+                });
             }
-            // log(generate(ast.program));
-        });
-        // Order matters here! *Prepend* the input nodes to this one, because
-        // you have to declare functions in order of use in GLSL
-        var sections = mergeShaderSections(continuation_1, isDataNode(node) ||
-            node.sourceType === SourceType.EXPRESSION ||
-            node.sourceType === SourceType.FN_BODY_FRAGMENT
-            ? emptyShaderSections()
-            : findShaderSections(ast));
-        var filler = isDataNode(node)
-            ? makeExpression(toGlsl(node))
-            : parser.produceFiller(node, ast);
-        return [sections, filler, __assign(__assign({}, compiledIds), (_a = {}, _a[node.id] = node, _a))];
-    }
-    else {
-        // TODO: This duplicates the above branch, and also does this mean we
-        // recalculate the shader sections and filler for every edge? Can I move
-        // these lines above the loop?
-        var sections = isDataNode(node) ||
-            node.sourceType === SourceType.EXPRESSION ||
-            node.sourceType === SourceType.FN_BODY_FRAGMENT
-            ? emptyShaderSections()
-            : findShaderSections(ast);
-        var filler = isDataNode(node)
-            ? makeExpression(toGlsl(node))
-            : parser.produceFiller(node, ast);
-        return [sections, filler, __assign(__assign({}, compiledIds), (_b = {}, _b[node.id] = node, _b))];
-    }
+            nodeContext.ast = filler.filler(fillerFn);
+        }
+        else {
+            // Don't backfill by discarding the backfiller args
+            nodeContext.ast = filler.filler(function () { return fillerFn(); });
+        }
+    });
+    // Order matters here! *Prepend* the input nodes to this one, because
+    // you have to declare functions in order of use in GLSL
+    var sections = mergeShaderSections(continuation, isDataNode(node) ||
+        codeNode.sourceType === SourceType.EXPRESSION ||
+        codeNode.sourceType === SourceType.FN_BODY_FRAGMENT
+        ? shaderSectionsCons()
+        : findShaderSections(node.id, ast));
+    var filler = isDataNode(node)
+        ? function () { return makeExpression(toGlsl(node)); }
+        : parser.produceFiller(node, ast);
+    return [sections, filler, __assign(__assign({}, compiledIds), (_a = {}, _a[node.id] = node, _a))];
 };
 export var compileGraph = function (engineContext, engine, graph) {
     // computeGraphContext(engineContext, engine, graph);
@@ -472,7 +513,7 @@ export var collectNodeProperties = function (graph) {
     };
 };
 export var compileSource = function (graph, engine, ctx) { return __awaiter(void 0, void 0, void 0, function () {
-    var result, compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
+    var result, updatedNodeContext, updatedContext, compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0: return [4 /*yield*/, computeGraphContext(ctx, engine, graph)];
@@ -481,9 +522,10 @@ export var compileSource = function (graph, engine, ctx) { return __awaiter(void
                 if (isError(result)) {
                     return [2 /*return*/, result];
                 }
-                compileResult = compileGraph(ctx, engine, graph);
-                fragmentResult = generate(shaderSectionsToProgram(compileResult.fragment, engine.mergeOptions)
-                    .program);
+                updatedNodeContext = __assign(__assign({}, ctx.nodes), result);
+                updatedContext = __assign(__assign({}, ctx), { nodes: updatedNodeContext });
+                compileResult = compileGraph(updatedContext, engine, graph);
+                fragmentResult = generate(shaderSectionsToProgram(compileResult.fragment, engine.mergeOptions).program);
                 vertexResult = generate(shaderSectionsToProgram(compileResult.vertex, engine.mergeOptions).program);
                 dataInputs = filterGraphNodes(graph, [compileResult.outputFrag, compileResult.outputVert], { input: isDataInput }).inputs;
                 dataNodes = Object.entries(dataInputs).reduce(function (acc, _a) {
@@ -496,11 +538,13 @@ export var compileSource = function (graph, engine, ctx) { return __awaiter(void
                     }, acc);
                 }, {});
                 return [2 /*return*/, {
+                        updatedNodeContext: updatedNodeContext,
                         compileResult: compileResult,
                         fragmentResult: fragmentResult,
                         vertexResult: vertexResult,
                         dataNodes: dataNodes,
                         dataInputs: dataInputs,
+                        compileMs: '',
                     }];
         }
     });