@shaderfrog/core 1.3.0 → 1.3.2

package/cjs/graph/graph.js

@@ -1,533 +0,0 @@
-"use strict";
-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));
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.compileSource = exports.collectNodeProperties = exports.compileGraph = exports.compileNode = exports.isDataInput = exports.filterGraphNodes = exports.collectConnectedNodes = exports.filterGraphFromNode = exports.prepopulatePropertyInputs = exports.mergeSearchResults = exports.consSearchResult = exports.findLinkedVertexNodes = exports.findLinkedNode = exports.resetGraphIds = exports.ensureFromNode = exports.mangleMainFn = exports.mangleEntireProgram = exports.mangleVar = exports.mangleName = exports.nodeName = exports.doesLinkThruShader = exports.findNode = exports.isSourceNode = exports.isDataNode = void 0;
-var utils_1 = require("@shaderfrog/glsl-parser/parser/utils");
-var context_1 = require("./context");
-var shader_sections_1 = require("./shader-sections");
-var ast_1 = require("../util/ast");
-var ensure_1 = require("../util/ensure");
-var code_nodes_1 = require("./code-nodes");
-var base_node_1 = require("./base-node");
-var id_1 = require("../util/id");
-var parsers_1 = require("./parsers");
-var evaluate_1 = require("./evaluate");
-var graph_types_1 = require("./graph-types");
-var glsl_parser_1 = require("@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));
-};
-var isDataNode = function (node) {
-    return 'value' in node;
-};
-exports.isDataNode = isDataNode;
-var isSourceNode = function (node) {
-    return !(0, exports.isDataNode)(node);
-};
-exports.isSourceNode = isSourceNode;
-var findNode = function (graph, id) {
-    return (0, ensure_1.ensure)(graph.nodes.find(function (node) { return node.id === id; }));
-};
-exports.findNode = findNode;
-var doesLinkThruShader = function (graph, node) {
-    var edges = graph.edges.filter(function (edge) { return edge.type !== graph_types_1.EdgeLink.NEXT_STAGE && edge.from === node.id; });
-    if (edges.length === 0) {
-        return false;
-    }
-    return edges.reduce(function (foundShader, edge) {
-        var upstreamNode = (0, ensure_1.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 !== code_nodes_1.SourceType.EXPRESSION &&
-                upstreamNode.type !== graph_types_1.NodeType.OUTPUT) ||
-            (0, exports.doesLinkThruShader)(graph, upstreamNode));
-    }, false);
-};
-exports.doesLinkThruShader = doesLinkThruShader;
-var nodeName = function (node) {
-    return 'main_' + node.name.replace(/[^a-zA-Z0-9]/g, ' ').replace(/ +/g, '_');
-};
-exports.nodeName = nodeName;
-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);
-};
-exports.mangleName = mangleName;
-var mangleVar = function (name, engine, node, sibling) { return (engine.preserve.has(name) ? name : (0, exports.mangleName)(name, node, sibling)); };
-exports.mangleVar = mangleVar;
-var mangleEntireProgram = function (engine, ast, node, sibling) {
-    (0, utils_1.renameBindings)(ast.scopes[0], function (name, n) {
-        return n.doNotDescope ? name : (0, exports.mangleVar)(name, engine, node, sibling);
-    });
-    (0, exports.mangleMainFn)(ast, node, sibling);
-};
-exports.mangleEntireProgram = mangleEntireProgram;
-var mangleMainFn = function (ast, node, sibling) {
-    (0, utils_1.renameFunctions)(ast.scopes[0], function (name) {
-        return name === 'main' ? (0, exports.nodeName)(node) : (0, exports.mangleName)(name, node, sibling);
-    });
-};
-exports.mangleMainFn = mangleMainFn;
-var ensureFromNode = function (graph, inputEdge) {
-    return (0, ensure_1.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."));
-};
-exports.ensureFromNode = ensureFromNode;
-var resetGraphIds = function (graph) {
-    var idMap = {};
-    var map = function (id) {
-        idMap[id] = idMap[id] || (0, id_1.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) })); }),
-    };
-};
-exports.resetGraphIds = resetGraphIds;
-var findLinkedNode = function (graph, id) {
-    var edgeLink = graph.edges.find(function (e) { return e.type === graph_types_1.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; });
-};
-exports.findLinkedNode = findLinkedNode;
-/**
- * Find any unconnected vertex nodes linked to collected fragment nodes
- */
-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 === graph_types_1.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 (0, exports.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];
-    });
-};
-exports.findLinkedVertexNodes = findLinkedVertexNodes;
-var consSearchResult = function () { return ({
-    nodes: {},
-    inputs: {},
-    edges: [],
-}); };
-exports.consSearchResult = consSearchResult;
-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),
-}); };
-exports.mergeSearchResults = mergeSearchResults;
-/**
- * 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.
- */
-var prepopulatePropertyInputs = function (node) { return (__assign(__assign({}, node), { inputs: __spreadArray(__spreadArray([], __read(node.inputs), false), __read((node.config.properties || []).map(function (property) {
-        return (0, base_node_1.nodeInput)(property.displayName, "property_".concat(property.property), 'property', property.type, ['data'], !!property.fillerName, // bakeable
-        property.property);
-    })), false) })); };
-exports.prepopulatePropertyInputs = prepopulatePropertyInputs;
-/**
- * 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.
- */
-var filterGraphFromNode = function (graph, node, predicates, depth, lastResult) {
-    var _a;
-    if (depth === void 0) { depth = Infinity; }
-    if (lastResult === void 0) { lastResult = (0, exports.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 ? (0, exports.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 = (0, exports.filterGraphFromNode)(graph, fromNode, predicates, depth - 1, intermediateAcc);
-            return (0, exports.mergeSearchResults)(intermediateAcc, result);
-        }
-        else {
-            return intermediateAcc;
-        }
-    }, accumulatedResult);
-};
-exports.filterGraphFromNode = filterGraphFromNode;
-var collectConnectedNodes = function (graph, node) {
-    return (0, exports.filterGraphFromNode)(graph, node, { node: function () { return true; } }).nodes;
-};
-exports.collectConnectedNodes = collectConnectedNodes;
-var filterGraphNodes = function (graph, nodes, filter, depth) {
-    if (depth === void 0) { depth = Infinity; }
-    return nodes.reduce(function (acc, node) {
-        var result = (0, exports.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),
-        };
-    }, (0, exports.consSearchResult)());
-};
-exports.filterGraphNodes = filterGraphNodes;
-// 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?
-var isDataInput = function (input) {
-    return (input.type === 'uniform' || input.type === 'property') && !input.baked;
-};
-exports.isDataInput = isDataInput;
-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({}, (parsers_1.coreParsers[node.type] || parsers_1.coreParsers[graph_types_1.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 = (0, exports.isDataNode)(node)
-        ? null
-        : (0, ensure_1.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 = (0, shader_sections_1.emptyShaderSections)();
-        inputEdges
-            .filter(function (edge) { return edge.type !== graph_types_1.EdgeLink.NEXT_STAGE; })
-            .map(function (edge) { return ({
-            edge: edge,
-            fromNode: (0, ensure_1.ensure)(graph.nodes.find(function (node) { return edge.from === node.id; }), "GraphNode for edge ".concat(edge.from, " not found")),
-            input: (0, ensure_1.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 !(0, exports.isDataInput)(input);
-        })
-            .forEach(function (_a) {
-            var _b;
-            var fromNode = _a.fromNode, edge = _a.edge, input = _a.input;
-            var _c = __read((0, exports.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 = (0, shader_sections_1.mergeShaderSections)(continuation_1, inputSections);
-            compiledIds = __assign(__assign({}, compiledIds), childIds);
-            var filler;
-            var fillerName;
-            if (nodeContext) {
-                if (input.property) {
-                    fillerName = (0, ensure_1.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];
-                        (0, utils_1.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 = (0, shader_sections_1.mergeShaderSections)(continuation_1, (0, exports.isDataNode)(node) ||
-            node.sourceType === code_nodes_1.SourceType.EXPRESSION ||
-            node.sourceType === code_nodes_1.SourceType.FN_BODY_FRAGMENT
-            ? (0, shader_sections_1.emptyShaderSections)()
-            : (0, shader_sections_1.findShaderSections)(ast));
-        var filler = (0, exports.isDataNode)(node)
-            ? (0, ast_1.makeExpression)((0, evaluate_1.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 = (0, exports.isDataNode)(node) ||
-            node.sourceType === code_nodes_1.SourceType.EXPRESSION ||
-            node.sourceType === code_nodes_1.SourceType.FN_BODY_FRAGMENT
-            ? (0, shader_sections_1.emptyShaderSections)()
-            : (0, shader_sections_1.findShaderSections)(ast);
-        var filler = (0, exports.isDataNode)(node)
-            ? (0, ast_1.makeExpression)((0, evaluate_1.toGlsl)(node))
-            : parser.produceFiller(node, ast);
-        return [sections, filler, __assign(__assign({}, compiledIds), (_b = {}, _b[node.id] = node, _b))];
-    }
-};
-exports.compileNode = compileNode;
-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((0, exports.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 = (0, exports.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 = (0, exports.findLinkedVertexNodes)(graph, vertexIds);
-    var orphanEdges = orphanNodes.map(function (node) { return ({
-        id: (0, id_1.makeId)(),
-        from: node.id,
-        to: outputVert.id,
-        output: 'main',
-        input: "filler_".concat(graph_types_1.MAGIC_OUTPUT_STMTS),
-        stage: 'vertex',
-        category: 'code',
-    }); });
-    var _b = __read((0, exports.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)),
-    };
-};
-exports.compileGraph = compileGraph;
-/**
- * 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.
- */
-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 = (0, exports.filterGraphFromNode)(graph, outputFrag, nodesWithProperties);
-    var vertProperties = (0, exports.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),
-    };
-};
-exports.collectNodeProperties = collectNodeProperties;
-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*/, (0, context_1.computeGraphContext)(ctx, engine, graph)];
-            case 1:
-                result = _a.sent();
-                if ((0, context_1.isError)(result)) {
-                    return [2 /*return*/, result];
-                }
-                compileResult = (0, exports.compileGraph)(ctx, engine, graph);
-                fragmentResult = (0, glsl_parser_1.generate)((0, shader_sections_1.shaderSectionsToProgram)(compileResult.fragment, engine.mergeOptions).program);
-                vertexResult = (0, glsl_parser_1.generate)((0, shader_sections_1.shaderSectionsToProgram)(compileResult.vertex, engine.mergeOptions).program);
-                dataInputs = (0, exports.filterGraphNodes)(graph, [compileResult.outputFrag, compileResult.outputVert], { input: exports.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), (0, exports.collectConnectedNodes)(graph, fromNode)) : iAcc;
-                    }, acc);
-                }, {});
-                return [2 /*return*/, {
-                        compileResult: compileResult,
-                        fragmentResult: fragmentResult,
-                        vertexResult: vertexResult,
-                        dataNodes: dataNodes,
-                        dataInputs: dataInputs,
-                    }];
-        }
-    });
-}); };
-exports.compileSource = compileSource;