@shaderfrog/core 1.2.0 → 1.3.0

package/esm/graph/graph.js

@@ -0,0 +1,506 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __generator = (this && this.__generator) || function (thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (g && (g = 0, op[0] && (_ = 0)), _) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+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 { ensure } from '../util/ensure';
+import { SourceType } from './code-nodes';
+import { nodeInput } from './base-node';
+import { makeId } from '../util/id';
+import { coreParsers } from './parsers';
+import { toGlsl } from './evaluate';
+import { EdgeLink, MAGIC_OUTPUT_STMTS, NodeType, } from './graph-types';
+import { generate } from '@shaderfrog/glsl-parser';
+var log = function () {
+    var _a;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[31m(core.graph)\x1b[0m'], __read(args), false));
+};
+export var isDataNode = function (node) {
+    return 'value' in node;
+};
+export var isSourceNode = function (node) {
+    return !isDataNode(node);
+};
+export var findNode = function (graph, id) {
+    return ensure(graph.nodes.find(function (node) { return node.id === id; }));
+};
+export var doesLinkThruShader = function (graph, node) {
+    var edges = graph.edges.filter(function (edge) { return edge.type !== EdgeLink.NEXT_STAGE && edge.from === node.id; });
+    if (edges.length === 0) {
+        return false;
+    }
+    return edges.reduce(function (foundShader, edge) {
+        var upstreamNode = ensure(graph.nodes.find(function (node) { return node.id === edge.to; }));
+        return (foundShader ||
+            // TODO: LARD this probably will introduce some insidius hard to track
+            // down bug, as I try to pull toon and phong up out of core, I need to
+            // know if a graph links through a "shader" which now means somehting
+            // different... does a config object need isShader? Can we compute it from
+            // inputs/ outputs/source?
+            (upstreamNode.sourceType !== SourceType.EXPRESSION &&
+                upstreamNode.type !== NodeType.OUTPUT) ||
+            doesLinkThruShader(graph, upstreamNode));
+    }, false);
+};
+export var nodeName = function (node) {
+    return 'main_' + node.name.replace(/[^a-zA-Z0-9]/g, ' ').replace(/ +/g, '_');
+};
+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.
+    var id = (nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.stage) === 'fragment'
+        ? nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.id
+        : node.id;
+    return "".concat(name, "_").concat(id);
+};
+export var mangleVar = function (name, engine, node, sibling) { return (engine.preserve.has(name) ? name : mangleName(name, node, sibling)); };
+export var mangleEntireProgram = function (engine, ast, node, sibling) {
+    renameBindings(ast.scopes[0], function (name, n) {
+        return n.doNotDescope ? name : mangleVar(name, engine, node, sibling);
+    });
+    mangleMainFn(ast, node, sibling);
+};
+export var mangleMainFn = function (ast, node, sibling) {
+    renameFunctions(ast.scopes[0], function (name) {
+        return name === 'main' ? nodeName(node) : mangleName(name, node, sibling);
+    });
+};
+export var ensureFromNode = function (graph, inputEdge) {
+    return ensure(graph.nodes.find(function (_a) {
+        var id = _a.id;
+        return id === inputEdge.from;
+    }), "Orphaned edge! There is an edge fro \"".concat(inputEdge.from, "\" to \"").concat(inputEdge.to, "\", but from node ").concat(inputEdge.from, " does not exist in the graph."));
+};
+export var resetGraphIds = function (graph) {
+    var idMap = {};
+    var map = function (id) {
+        idMap[id] = idMap[id] || makeId();
+        return idMap[id];
+    };
+    return {
+        nodes: graph.nodes.map(function (n) { return (__assign(__assign(__assign({}, n), { id: map(n.id) }), (n.parentId ? { parentId: map(n.parentId) } : {}))); }),
+        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;
+    return graph.nodes.find(function (node) { return node.id === otherId; });
+};
+/**
+ * Find any unconnected vertex nodes linked to collected fragment nodes
+ */
+export var findLinkedVertexNodes = function (graph, existingIds) {
+    if (existingIds === void 0) { existingIds = {}; }
+    // Group edges by where they point
+    var edgeLinks = graph.edges
+        .filter(function (e) { return e.type === EdgeLink.NEXT_STAGE; })
+        .reduce(function (edges, edge) {
+        var _a;
+        return (__assign(__assign({}, edges), (_a = {}, _a[edge.to] = edge, _a[edge.from] = edge, _a)));
+    }, {});
+    return graph.nodes.filter(function (node) {
+        // If this is a vertex node
+        return isSourceNode(node) &&
+            node.stage === 'vertex' &&
+            // That's linked
+            node.id in edgeLinks &&
+            // And not already captured (this should probably just be a set)
+            !existingIds[node.id];
+    });
+};
+export var consSearchResult = function () { return ({
+    nodes: {},
+    inputs: {},
+    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),
+}); };
+/**
+ * Create the inputs on a node from the properties. This used to be done at
+ * context time. Doing it at node creation time lets us auto-bake edges into
+ * the node at initial graph creation time.
+ */
+export var prepopulatePropertyInputs = function (node) { return (__assign(__assign({}, node), { inputs: __spreadArray(__spreadArray([], __read(node.inputs), false), __read((node.config.properties || []).map(function (property) {
+        return nodeInput(property.displayName, "property_".concat(property.property), 'property', property.type, ['data'], !!property.fillerName, // bakeable
+        property.property);
+    })), false) })); };
+/**
+ * Recursively filter the graph, starting from a specific node, looking for
+ * nodes and edges that match predicates.
+ *
+ * Inputs can only be filtered if the graph context has been computed, since
+ * inputs aren't created until then.
+ */
+export var filterGraphFromNode = function (graph, node, predicates, depth, lastResult) {
+    var _a;
+    if (depth === void 0) { depth = Infinity; }
+    if (lastResult === void 0) { lastResult = consSearchResult(); }
+    var inputs = node.inputs;
+    var inputEdges = graph.edges.filter(function (edge) { return edge.to === node.id; });
+    var nodeAcc = __assign({}, (predicates.node && predicates.node(node, inputEdges, lastResult)
+        ? (_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 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 &&
+            predicates.edge(input, node, inputEdge, fromNode, lastResult)
+            ? [inputEdge]
+            : [])), false);
+        // 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);
+        }
+        else {
+            return intermediateAcc;
+        }
+    }, accumulatedResult);
+};
+export var collectConnectedNodes = function (graph, node) {
+    return filterGraphFromNode(graph, node, { node: function () { return true; } }).nodes;
+};
+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),
+            edges: __assign(__assign({}, acc.edges), result.edges),
+        };
+    }, consSearchResult());
+};
+// before data inputs were known by the input.category being node or data. I
+// tried updating inputs to have acepts: [code|data] and "baked" now is there a
+// way to know if we're plugging in code or data?
+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;
+    if (activeIds === void 0) { activeIds = {}; }
+    // THIS DUPLICATES OTHER LINE
+    var parser = __assign(__assign({}, (coreParsers[node.type] || coreParsers[NodeType.SOURCE])), (engine.parsers[node.type] || {}));
+    var inputs = node.inputs;
+    if (!parser) {
+        console.error(node);
+        throw new Error("No parser found for ".concat(node.name, " (").concat(node.type, ", id ").concat(node.id, ")"));
+    }
+    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 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);
+        })
+            .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, function (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);
+            }
+            // 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))];
+    }
+};
+export var compileGraph = function (engineContext, engine, graph) {
+    // computeGraphContext(engineContext, engine, graph);
+    var outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
+    if (!outputFrag) {
+        throw new Error('No fragment output in graph');
+    }
+    var _a = __read(compileNode(engine, graph, graph.edges, engineContext, outputFrag), 3), fragment = _a[0], fragmentIds = _a[2];
+    var outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
+    if (!outputVert) {
+        throw new Error('No vertex output in graph');
+    }
+    var vertexIds = collectConnectedNodes(graph, outputVert);
+    // Some fragment shaders reference vertex shaders which may not have been
+    // given edges in the graph. Build invisible edges from these vertex nodes to
+    // the hidden "mainStmts" input on the output node, which inlines the function
+    // calls to those vertex main() statements and includes them in the output
+    var orphanNodes = findLinkedVertexNodes(graph, vertexIds);
+    var orphanEdges = orphanNodes.map(function (node) { return ({
+        id: makeId(),
+        from: node.id,
+        to: outputVert.id,
+        output: 'main',
+        input: "filler_".concat(MAGIC_OUTPUT_STMTS),
+        stage: 'vertex',
+        category: 'code',
+    }); });
+    var _b = __read(compileNode(engine, graph, __spreadArray(__spreadArray([], __read(graph.edges), false), __read(orphanEdges), false), engineContext, outputVert), 2), vertex = _b[0];
+    // Every compileNode returns the AST so far, as well as the filler for the
+    // next node with inputs. On the final step, we discard the filler
+    return {
+        fragment: fragment,
+        vertex: vertex,
+        outputFrag: outputFrag,
+        outputVert: outputVert,
+        orphanNodes: orphanNodes,
+        activeNodeIds: new Set(__spreadArray(__spreadArray(__spreadArray([], __read(Object.keys(vertexIds)), false), __read(Object.keys(fragmentIds)), false), __read(orphanNodes.map(function (node) { return node.id; })), false)),
+    };
+};
+/**
+ * Find engine nodes to set properties on, like find a Physical node so
+ * consumers can set physicalNode.myProperty = 123.
+ *
+ * Finds all active nodes in the graph that have inputs that are properties,
+ * which currently means it will find all active engine nodes.
+ */
+export var collectNodeProperties = function (graph) {
+    var nodesWithProperties = {
+        node: function (node) {
+            var _a;
+            return 'config' in node &&
+                'properties' in node.config &&
+                !!((_a = node.config.properties) === null || _a === void 0 ? void 0 : _a.length);
+        },
+        input: function (input) { return !!input.property; },
+    };
+    var outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
+    var outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
+    var fragProperties = filterGraphFromNode(graph, outputFrag, nodesWithProperties);
+    var vertProperties = filterGraphFromNode(graph, outputVert, nodesWithProperties);
+    return {
+        nodes: __assign(__assign({}, fragProperties.nodes), vertProperties.nodes),
+        inputs: __assign(__assign({}, fragProperties.inputs), vertProperties.inputs),
+        edges: __assign(__assign({}, fragProperties.edges), vertProperties.edges),
+    };
+};
+export var compileSource = function (graph, engine, ctx) { return __awaiter(void 0, void 0, void 0, function () {
+    var result, compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, computeGraphContext(ctx, engine, graph)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    return [2 /*return*/, result];
+                }
+                compileResult = compileGraph(ctx, 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) {
+                    var _b = __read(_a, 2), nodeId = _b[0], inputs = _b[1];
+                    return inputs.reduce(function (iAcc, input) {
+                        var fromEdge = graph.edges.find(function (edge) { return edge.to === nodeId && edge.input === input.id; });
+                        var fromNode = fromEdge && graph.nodes.find(function (node) { return node.id === fromEdge.from; });
+                        return fromNode
+                            ? __assign(__assign({}, iAcc), collectConnectedNodes(graph, fromNode)) : iAcc;
+                    }, acc);
+                }, {});
+                return [2 /*return*/, {
+                        compileResult: compileResult,
+                        fragmentResult: fragmentResult,
+                        vertexResult: vertexResult,
+                        dataNodes: dataNodes,
+                        dataInputs: dataInputs,
+                    }];
+        }
+    });
+}); };

package/esm/graph/graph.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/graph/graph.test.js

@@ -0,0 +1,168 @@
+import util from 'util';
+import { parser } from '@shaderfrog/glsl-parser';
+import { generate } from '@shaderfrog/glsl-parser';
+import { addNode } from './graph-node';
+import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, } from './shader-sections';
+import { numberNode } from './data-nodes';
+import { makeEdge } from './edge';
+import { evaluateNode } from './evaluate';
+var inspect = function (thing) {
+    return console.log(util.inspect(thing, false, null, true));
+};
+var mergeBlocks = function (ast1, ast2) {
+    var s1 = findShaderSections(ast1);
+    var s2 = findShaderSections(ast2);
+    var merged = mergeShaderSections(s1, s2);
+    return generate(shaderSectionsToProgram(merged, {
+        includePrecisions: true,
+        includeVersion: true,
+    }));
+};
+var dedupe = function (code) {
+    return generate(shaderSectionsToProgram(findShaderSections(parser.parse(code)), {
+        includePrecisions: true,
+        includeVersion: true,
+    }));
+};
+var counter = 0;
+var p = { x: 0, y: 0 };
+var id = function () { return '' + counter++; };
+var constructor = function () { return ({
+    config: {
+        version: 3,
+        preprocess: false,
+        strategies: [],
+        uniforms: [],
+    },
+    id: '1',
+    name: '1',
+    engine: true,
+    type: '',
+    inputs: [],
+    outputs: [],
+    position: { x: 0, y: 0 },
+    source: '',
+    stage: undefined,
+}); };
+var engine = {
+    name: 'three',
+    displayName: 'Three.js',
+    evaluateNode: function (node) {
+        if (node.type === 'number') {
+            return parseFloat(node.value);
+        }
+        return node.value;
+    },
+    constructors: {
+        physical: constructor,
+        toon: constructor,
+    },
+    mergeOptions: {
+        includePrecisions: true,
+        includeVersion: true,
+    },
+    importers: {},
+    preserve: new Set(),
+    parsers: {},
+};
+// it('graph compiler arbitrary helper test', () => {
+//   const graph: Graph = {
+//     nodes: [
+//       outputNode('0', 'Output v', p, 'vertex'),
+//       outputNode('1', 'Output f', p, 'fragment'),
+//       makeSourceNode(
+//         '2',
+//         `uniform sampler2D image1;
+// uniform sampler2D image2;
+// void main() {
+//   vec3 col = texture2D(image1, posTurn - 0.4 * time).rgb + 1.0;
+//   vec3 col = texture2D(image2, negTurn - 0.4 * time).rgb + 2.0;
+// }
+// `,
+//         'fragment'
+//       ),
+//       makeSourceNode(
+//         '3',
+//         `void main() {
+//     return vec4(0.0);
+// }
+// `,
+//         'fragment'
+//       ),
+//       makeSourceNode(
+//         '4',
+//         `void main() {
+//     return vec4(1.0);
+// }
+// `,
+//         'fragment'
+//       ),
+//     ],
+//     edges: [
+//       makeEdge(id(), '2', '1', 'out', 'filler_frogFragOut', 'fragment'),
+//       makeEdge(id(), '3', '2', 'out', 'filler_image1', 'fragment'),
+//       makeEdge(id(), '4', '2', 'out', 'filler_image2', 'fragment'),
+//     ],
+//   };
+//   const engineContext: EngineContext = {
+//     engine: 'three',
+//     nodes: {},
+//     runtime: {},
+//     debuggingNonsense: {},
+//   };
+//   const result = compileGraph(engineContext, engine, graph);
+//   const built = generate(
+//     shaderSectionsToProgram(result.fragment, {
+//       includePrecisions: true,
+//       includeVersion: true,
+//     }).program
+//   );
+//   expect(built).toBe('hi');
+// });
+describe('evaluateNode()', function () {
+    it('evaluates binary nodes', function () {
+        var finalAdd = addNode(id(), p);
+        var add2 = addNode(id(), p);
+        var num1 = numberNode(id(), 'number', p, '3');
+        var num2 = numberNode(id(), 'number', p, '5');
+        var num3 = numberNode(id(), 'number', p, '7');
+        var graph = {
+            nodes: [num1, num2, num3, finalAdd, add2],
+            edges: [
+                makeEdge(id(), num1.id, finalAdd.id, 'out', 'a'),
+                makeEdge(id(), add2.id, finalAdd.id, 'out', 'b'),
+                makeEdge(id(), num2.id, add2.id, 'out', 'a'),
+                makeEdge(id(), num3.id, add2.id, 'out', 'b'),
+            ],
+        };
+        expect(evaluateNode(engine, graph, finalAdd)).toBe(15);
+    });
+});
+it('should merge uniforms with interface blocks', function () {
+    var astX = parser.parse("uniform vec2 x;");
+    var astY = parser.parse("uniform vec2 y, z;\nuniform vec3 a;");
+    expect(mergeBlocks(astX, astY)).toEqual("uniform vec2 x, y, z;\nuniform vec3 a;\n");
+    var astL01 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    var astL02 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    expect(mergeBlocks(astL01, astL02)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    var astL001 = parser.parse("uniform Light0 { vec4 y; } x;", {
+        quiet: true,
+    });
+    var astL002 = parser.parse("uniform Light0 x;", { quiet: true });
+    expect(mergeBlocks(astL001, astL002)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    var astLo01 = parser.parse("uniform Light0 x;", { quiet: true });
+    var astLo02 = parser.parse("uniform Light0 { vec4 y; } x;", {
+        quiet: true,
+    });
+    expect(mergeBlocks(astLo01, astLo02)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    // This may be a bug, look at how the uniforms are merged. I at least want to
+    // note its current behavior in this test
+    var vec2Arr1 = parser.parse("uniform vec2 y[5];");
+    var vec2Arr2 = parser.parse("uniform vec2 y[10];");
+    expect(mergeBlocks(vec2Arr1, vec2Arr2)).toEqual("uniform vec2 y[10];\n");
+    var block1 = parser.parse("uniform Scene { mat4 view; };");
+    var block2 = parser.parse("uniform Scene { mat4 view; };");
+    expect(mergeBlocks(block1, block2)).toEqual("uniform Scene { mat4 view; };\n");
+    // Verify these lines are preserved (they go through dedupeUniforms)
+    expect(dedupe("layout(std140,column_major) uniform;")).toEqual("layout(std140,column_major) uniform;");
+});