@shaderfrog/core 1.2.0 → 1.3.1

package/cjs/package.json

@@ -0,0 +1 @@
+{"type": "commonjs"}

package/esm/engine.d.ts

@@ -0,0 +1,69 @@
+import { Program } from '@shaderfrog/glsl-parser/ast';
+import { MergeOptions } from './graph/shader-sections';
+import { Graph, ShaderStage } from './graph/graph-types';
+import { NodePosition } from './graph/base-node';
+import { DataNode, UniformDataType } from './graph/data-nodes';
+import { CodeNode, NodeProperty, SourceNode } from './graph/code-nodes';
+import { NodeContext } from './graph/context';
+import { NodeParser } from './graph/parsers';
+export declare enum EngineNodeType {
+    toon = "toon",
+    phong = "phong",
+    physical = "physical",
+    shader = "shader",
+    binary = "binary"
+}
+export type PhongNodeConstructor = (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
+export type PhysicalNodeConstructor = (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
+export type ToonNodeConstructor = (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
+export interface Engine {
+    name: 'three' | 'babylon' | 'playcanvas';
+    displayName: string;
+    preserve: Set<string>;
+    mergeOptions: MergeOptions;
+    parsers: Record<string, NodeParser>;
+    importers: EngineImporters;
+    evaluateNode: (node: DataNode) => any;
+    constructors: {
+        [EngineNodeType.phong]?: PhongNodeConstructor;
+        [EngineNodeType.physical]?: PhysicalNodeConstructor;
+        [EngineNodeType.toon]?: ToonNodeConstructor;
+    };
+}
+export type EngineContext = {
+    engine: string;
+    nodes: Record<string, NodeContext>;
+    runtime: any;
+    debuggingNonsense: {
+        vertexSource?: string;
+        vertexPreprocessed?: string;
+        fragmentPreprocessed?: string;
+        fragmentSource?: string;
+    };
+};
+export type EngineImporter = {
+    convertAst(ast: Program, type?: ShaderStage): void;
+    nodeInputMap: Partial<Record<EngineNodeType, Record<string, string | null>>>;
+    edgeMap: {
+        [oldInput: string]: string;
+    };
+};
+export type EngineImporters = {
+    [engine: string]: EngineImporter;
+};
+export declare const convertNode: (node: SourceNode, converter: EngineImporter) => SourceNode;
+export declare const convertToEngine: (oldEngine: Engine, newEngine: Engine, graph: Graph) => Graph;
+export type DefaultPropertySetter = (p: NodeProperty) => any;
+/**
+ * Create the initial engine node properties for a plugin to create its initial
+ * material with. This finds all engine nodes in the graph, finds all their
+ * properties, evalutes them, and returns an object with initial properties to
+ * set on the new plugin material, like a three.RawShaderMaterial().
+ *
+ * Currently only PlayCanvas uses this. It's at odds with the compileResult.dataInputs
+ * code path. That path uses isDataNode() to check for inputs, which excludes
+ * baked inputs. PlayCanvas requires (at least diffusesMap?) baked input properties
+ * to be set to a pc.Texture() at runtime, otherwise there's an error about
+ * vertex_texCoord0.
+ */
+export declare const collectInitialEvaluatedGraphProperties: (engine: Engine, graph: Graph, defaultPropertySetting: DefaultPropertySetter) => Record<string, any>;

package/esm/engine.js

@@ -0,0 +1,209 @@
+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 __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 preprocess from '@shaderfrog/glsl-parser/preprocessor';
+import { generate, parser } from '@shaderfrog/glsl-parser';
+import { NodeType } from './graph/graph-types';
+import groupBy from 'lodash.groupby';
+import { collectNodeProperties } from './graph/graph';
+import { evaluateNode } from './graph/evaluate';
+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[32m(core)\x1b[0m'], __read(args), false));
+};
+export var EngineNodeType;
+(function (EngineNodeType) {
+    EngineNodeType["toon"] = "toon";
+    EngineNodeType["phong"] = "phong";
+    EngineNodeType["physical"] = "physical";
+    EngineNodeType["shader"] = "shader";
+    EngineNodeType["binary"] = "binary";
+})(EngineNodeType || (EngineNodeType = {}));
+// type EdgeUpdates = { [edgeId: string]: { oldInput: string; newInput: string } };
+export var convertNode = function (node, converter) {
+    log("Converting ".concat(node.name, " (").concat(node.id, ")"));
+    var preprocessed = preprocess(node.source, {
+        preserveComments: true,
+        preserve: {
+            version: function () { return true; },
+            define: function () { return true; },
+        },
+    });
+    var ast = parser.parse(preprocessed);
+    converter.convertAst(ast, node.stage);
+    var source = generate(ast);
+    return __assign(__assign({}, node), { source: source });
+};
+export var convertToEngine = function (oldEngine, newEngine, graph) {
+    var converter = newEngine.importers[oldEngine.name];
+    if (!converter) {
+        throw new Error("The engine ".concat(newEngine.name, " has no importer for ").concat(oldEngine.name));
+    }
+    log("Attempting to convert from ".concat(newEngine.name, " to ").concat(oldEngine.name));
+    // const edgeUpdates: EdgeUpdates = {};
+    var edgesByNodeId = groupBy(graph.edges, 'to');
+    var edgeUpdates = {};
+    var nodeUpdates = {};
+    graph.nodes.forEach(function (node) {
+        // Convert engine nodes
+        if (node.type in EngineNodeType) {
+            if (node.type in newEngine.constructors) {
+                var source = node;
+                nodeUpdates[source.id] = // @ts-ignore
+                    newEngine.constructors[source.type](source.id, source.name, source.position, source.config.uniforms, source.stage);
+                // Bail if no conversion
+            }
+            else {
+                throw new Error("Can't convert ".concat(oldEngine.name, " to ").concat(newEngine.name, " because ").concat(newEngine.name, " does not have a \"").concat(node.type, "\" constructor"));
+            }
+        }
+        else if (NodeType.SOURCE === node.type) {
+            nodeUpdates[node.id] = convertNode(node, converter);
+        }
+        // Then update input edges. We only care about engine nodes
+        if (node.type in converter.nodeInputMap) {
+            var map_1 = converter.nodeInputMap[node.type];
+            (edgesByNodeId[node.id] || []).forEach(function (edge) {
+                if (edge.input in map_1) {
+                    var mapped = map_1[edge.input];
+                    log('Converting edge', edge.input, 'to', map_1[edge.input]);
+                    edgeUpdates[edge.id] = __assign(__assign({}, edge), { input: mapped });
+                }
+                else {
+                    log('Discarding', edge.input, 'as there is no edge mapping in the', newEngine.name, 'importer');
+                    edgeUpdates[edge.id] = null;
+                }
+            });
+        }
+    });
+    graph.edges = graph.edges.reduce(function (edges, edge) {
+        if (edge.id in edgeUpdates) {
+            var res = edgeUpdates[edge.id];
+            if (res === null) {
+                return edges;
+            }
+            else {
+                return __spreadArray(__spreadArray([], __read(edges), false), [res], false);
+            }
+        }
+        return __spreadArray(__spreadArray([], __read(edges), false), [edge], false);
+    }, []);
+    graph.nodes = graph.nodes.reduce(function (nodes, node) {
+        if (node.id in nodeUpdates) {
+            var res = nodeUpdates[node.id];
+            if (res === null) {
+                return nodes;
+            }
+            else {
+                return __spreadArray(__spreadArray([], __read(nodes), false), [res], false);
+            }
+        }
+        return __spreadArray(__spreadArray([], __read(nodes), false), [node], false);
+    }, []);
+    log('Created converted graph', graph);
+    return graph;
+};
+/**
+ * Create the initial engine node properties for a plugin to create its initial
+ * material with. This finds all engine nodes in the graph, finds all their
+ * properties, evalutes them, and returns an object with initial properties to
+ * set on the new plugin material, like a three.RawShaderMaterial().
+ *
+ * Currently only PlayCanvas uses this. It's at odds with the compileResult.dataInputs
+ * code path. That path uses isDataNode() to check for inputs, which excludes
+ * baked inputs. PlayCanvas requires (at least diffusesMap?) baked input properties
+ * to be set to a pc.Texture() at runtime, otherwise there's an error about
+ * vertex_texCoord0.
+ */
+export var collectInitialEvaluatedGraphProperties = function (engine, graph, defaultPropertySetting) {
+    var graphProperties = {};
+    // Get all the nodes with properties, meaning engine nodes, and the inputs
+    // for each property (property is like "diffuseMap").
+    var _a = collectNodeProperties(graph), nodes = _a.nodes, inputs = _a.inputs;
+    Object.entries(inputs).forEach(function (_a) {
+        var _b = __read(_a, 2), nodeId = _b[0], nodeInputs = _b[1];
+        // For every node with properties... There might be mulitple if there are
+        // uniforms plugged into both frag and vertex engine nodes, which
+        var node = nodes[nodeId];
+        nodeInputs.forEach(function (i) {
+            // Cast this to an input with a property specified on it, which the
+            // predicate search enforces
+            var input = i;
+            var edge = graph.edges.find(function (_a) {
+                var to = _a.to, i = _a.input;
+                return to === node.id && i === input.id;
+            });
+            // In the case where a node has been deleted from the graph,
+            // dataInputs won't have been udpated until a recompile completes
+            var fromNode = edge && graph.nodes.find(function (_a) {
+                var id = _a.id;
+                return id === edge.from;
+            });
+            if (fromNode) {
+                // If this is a baked input, we need to set the engine property to force
+                // whatever we're baking to generate.
+                if (input.baked) {
+                    // Find the corresponding property on the node and get the default
+                    // setting
+                    var property = (node.config.properties || []).find(function (p) { return p.property === input.property; });
+                    if (property) {
+                        graphProperties[input.property] = defaultPropertySetting(property);
+                    }
+                    else {
+                        console.error('Property not found on input node', node, input);
+                        throw new Error('Property not found on input node');
+                    }
+                    // Other inputs should(?) be data if not baked
+                }
+                else {
+                    try {
+                        graphProperties[input.property] = evaluateNode(engine, graph, fromNode);
+                    }
+                    catch (err) {
+                        console.error('Tried to evaluate a non-data node!', {
+                            err: err,
+                        });
+                    }
+                }
+            }
+        });
+    });
+    return graphProperties;
+};

package/esm/graph/base-node.d.ts

@@ -0,0 +1,36 @@
+/**
+ * Base node stuff, used across all nodes
+ */
+import { GraphDataType } from './data-nodes';
+export type InputCategory = 'data' | 'code';
+export type InputType = 'uniform' | 'property' | 'filler';
+export interface NodeInput {
+    displayName: string;
+    id: string;
+    type: InputType;
+    dataType?: GraphDataType;
+    accepts: InputCategory[];
+    baked?: boolean;
+    bakeable: boolean;
+    property?: string;
+}
+export declare const nodeInput: (displayName: string, id: string, type: InputType, dataType: GraphDataType | undefined, accepts: InputCategory[], bakeable: boolean, property?: string) => NodeInput;
+export interface NodeOutput {
+    name: string;
+    id: string;
+    dataType?: GraphDataType;
+    category: InputCategory;
+}
+export type NodePosition = {
+    x: number;
+    y: number;
+};
+export interface BaseNode {
+    id: string;
+    parentId?: string;
+    name: string;
+    type: string;
+    inputs: NodeInput[];
+    outputs: NodeOutput[];
+    position: NodePosition;
+}

package/esm/graph/base-node.js

@@ -0,0 +1,9 @@
+export var nodeInput = function (displayName, id, type, dataType, accepts, bakeable, property) { return ({
+    displayName: displayName,
+    id: id,
+    type: type,
+    dataType: dataType,
+    accepts: accepts,
+    bakeable: bakeable,
+    property: property,
+}); };

package/esm/graph/code-nodes.d.ts

@@ -0,0 +1,44 @@
+import { ShaderStage } from './graph-types';
+import { Strategy } from '../strategy';
+import { GraphDataType, UniformDataType } from './data-nodes';
+import { BaseNode, NodeInput } from './base-node';
+export declare const mapInputName: (node: CodeNode, { id, displayName }: NodeInput) => string;
+export type InputMapping = {
+    [original: string]: string;
+};
+export type NodeConfig = {
+    version: 2 | 3;
+    mangle?: boolean;
+    preprocess: boolean;
+    inputMapping?: InputMapping;
+    strategies: Strategy[];
+    uniforms: UniformDataType[];
+    properties?: NodeProperty[];
+    hardCodedProperties?: Record<string, any>;
+};
+export interface NodeProperty {
+    displayName: string;
+    type: GraphDataType;
+    property: string;
+    fillerName?: string;
+    defaultValue?: any;
+}
+export declare const property: (displayName: string, property: string, type: GraphDataType, fillerName?: string, defaultValue?: any) => NodeProperty;
+export declare enum SourceType {
+    SHADER_PROGRAM = "Shader Program",
+    EXPRESSION = "Expression",
+    FN_BODY_FRAGMENT = "Function Body Fragment"
+}
+export interface CodeNode extends BaseNode {
+    config: NodeConfig;
+    engine: boolean;
+    source: string;
+    sourceType?: SourceType;
+    stage?: ShaderStage;
+    biStage?: boolean;
+    originalEngine?: string;
+}
+export interface BinaryNode extends CodeNode {
+    operator: string;
+}
+export type SourceNode = BinaryNode | CodeNode;

package/esm/graph/code-nodes.js

@@ -0,0 +1,18 @@
+export var mapInputName = function (node, _a) {
+    var _b, _c;
+    var id = _a.id, displayName = _a.displayName;
+    return ((_c = (_b = node.config) === null || _b === void 0 ? void 0 : _b.inputMapping) === null || _c === void 0 ? void 0 : _c[id]) || displayName;
+};
+export var property = function (displayName, property, type, fillerName, defaultValue) { return ({
+    displayName: displayName,
+    type: type,
+    property: property,
+    fillerName: fillerName,
+    defaultValue: defaultValue,
+}); };
+export var SourceType;
+(function (SourceType) {
+    SourceType["SHADER_PROGRAM"] = "Shader Program";
+    SourceType["EXPRESSION"] = "Expression";
+    SourceType["FN_BODY_FRAGMENT"] = "Function Body Fragment";
+})(SourceType || (SourceType = {}));

package/esm/graph/context.d.ts

@@ -0,0 +1,37 @@
+import type { GlslSyntaxError } from '@shaderfrog/glsl-parser';
+import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
+import { Engine, EngineContext } from '../engine';
+import { NodeInput } from './base-node';
+import { Graph, GraphNode } from './graph-types';
+import { InputFillers } from './parsers';
+/**
+ * A node's context is the runtime / in-memory computed data associated with a
+ * graph node. It includes the parsed AST representation of the node, as well as
+ * the inputs found in that AST. It's not currently saved to the database.
+ */
+export type NodeContext = {
+    id?: string;
+    name?: string;
+    source?: string;
+    ast: AstNode | Program;
+    inputs?: NodeInput[];
+    inputFillers: InputFillers;
+    errors?: NodeErrors;
+};
+export type NodeErrors = {
+    type: 'errors';
+    nodeId: string;
+    errors: (GlslSyntaxError | string)[];
+};
+export declare const isError: (test: any) => test is NodeErrors;
+export declare const computeContextForNodes: (engineContext: EngineContext, engine: Engine, graph: Graph, nodes: GraphNode[]) => Promise<NodeErrors | Record<string, NodeContext>>;
+/**
+ * Compute the context for every node in the graph, done on initial graph load
+ * to compute the inputs/outputs for every node
+ */
+export declare const computeAllContexts: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors>;
+/**
+ * Compute the contexts for nodes starting from the outputs, working backwards.
+ * Used to only (re)-compute context for any actively used nodes
+ */
+export declare const computeGraphContext: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors>;

package/esm/graph/context.js

@@ -0,0 +1,243 @@
+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 groupBy from 'lodash.groupby';
+import { mapInputName, SourceType } from './code-nodes';
+import { NodeType } from './graph-types';
+import { collectConnectedNodes, filterGraphFromNode, findLinkedNode, findLinkedVertexNodes, isSourceNode, mangleEntireProgram, } from './graph';
+import { coreParsers } from './parsers';
+var makeError = function (nodeId) {
+    var errors = [];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        errors[_i - 1] = arguments[_i];
+    }
+    return ({
+        type: 'errors',
+        nodeId: nodeId,
+        errors: errors,
+    });
+};
+export var isError = function (test) {
+    return (test === null || test === void 0 ? void 0 : test.type) === 'errors';
+};
+// Merge existing node inputs, and inputs based on properties, with new ones
+// found from the source code, using the *id* as the uniqueness key. Any filler input gets
+// merged into property inputs with the same id. This preserves the
+// "baked" property on node inputs which is toggle-able in the graph
+var collapseNodeInputs = function (node, updatedInputs) {
+    return Object.values(groupBy(__spreadArray(__spreadArray([], __read(updatedInputs), false), __read(node.inputs), false), function (i) { return i.id; })).map(function (dupes) { return dupes.reduce(function (node, dupe) { return (__assign(__assign({}, node), dupe)); }); });
+};
+var computeNodeContext = function (engineContext, engine, graph, node) { return __awaiter(void 0, void 0, void 0, function () {
+    var parser, sibling, onBeforeCompile, manipulateAst, inputEdges, ast, dataInputs, computedInputs, nodeContext;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                parser = __assign(__assign({}, (coreParsers[node.type] || coreParsers[NodeType.SOURCE])), (engine.parsers[node.type] || {}));
+                sibling = findLinkedNode(graph, node.id);
+                onBeforeCompile = parser.onBeforeCompile, manipulateAst = parser.manipulateAst;
+                if (!onBeforeCompile) return [3 /*break*/, 2];
+                return [4 /*yield*/, onBeforeCompile(graph, engineContext, node, sibling)];
+            case 1:
+                _a.sent();
+                _a.label = 2;
+            case 2:
+                inputEdges = graph.edges.filter(function (edge) { return edge.to === node.id; });
+                try {
+                    ast = parser.produceAst(engineContext, engine, graph, node, inputEdges);
+                    if (manipulateAst) {
+                        ast = manipulateAst(engineContext, engine, graph, ast, inputEdges, node, sibling);
+                    }
+                }
+                catch (error) {
+                    console.error('Error parsing source code!', { error: error, node: node });
+                    return [2 /*return*/, makeError(node.id, error)];
+                }
+                dataInputs = groupBy(filterGraphFromNode(graph, node, {
+                    input: function (input, b, c, fromNode) {
+                        return input.bakeable && (fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'source';
+                    },
+                }, 1).inputs[node.id] || [], 'id');
+                computedInputs = parser.findInputs(engineContext, ast, inputEdges, node, sibling);
+                node.inputs = collapseNodeInputs(node, computedInputs.map(function (_a) {
+                    var _b = __read(_a, 1), i = _b[0];
+                    return (__assign(__assign({}, i), { displayName: mapInputName(node, i) }));
+                })).map(function (input) { return (__assign(__assign({}, input), (input.id in dataInputs ? { baked: true } : {}))); });
+                nodeContext = {
+                    ast: ast,
+                    id: node.id,
+                    inputFillers: computedInputs.reduce(function (acc, _a) {
+                        var _b;
+                        var _c = __read(_a, 3), input = _c[0], filler = _c[1], args = _c[2];
+                        return (__assign(__assign({}, acc), (_b = {}, _b[input.id] = {
+                            filler: filler,
+                            args: args,
+                        }, _b)));
+                    }, {}),
+                };
+                // Skip mangling if the node tells us to, which probably means it's an engine
+                // node where we don't care about renaming all the variables, or if it's
+                // an expression, where we want to be in the context of other variables
+                // TODO: Use global undefined engine variables here?
+                if (node.config.mangle !== false &&
+                    node.sourceType !== SourceType.EXPRESSION &&
+                    node.sourceType !== SourceType.FN_BODY_FRAGMENT) {
+                    mangleEntireProgram(engine, ast, node, findLinkedNode(graph, node.id));
+                }
+                return [2 /*return*/, nodeContext];
+        }
+    });
+}); };
+export var computeContextForNodes = function (engineContext, engine, graph, nodes) { return __awaiter(void 0, void 0, void 0, function () {
+    return __generator(this, function (_a) {
+        return [2 /*return*/, nodes
+                .filter(isSourceNode)
+                .reduce(function (ctx, node) { return __awaiter(void 0, void 0, void 0, function () {
+                var context, nodeContextOrError;
+                return __generator(this, function (_a) {
+                    switch (_a.label) {
+                        case 0: return [4 /*yield*/, ctx];
+                        case 1:
+                            context = _a.sent();
+                            if (isError(context)) {
+                                return [2 /*return*/, context];
+                            }
+                            return [4 /*yield*/, computeNodeContext(engineContext, engine, graph, node)];
+                        case 2:
+                            nodeContextOrError = _a.sent();
+                            if (isError(nodeContextOrError)) {
+                                return [2 /*return*/, nodeContextOrError];
+                            }
+                            context[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContextOrError);
+                            return [2 /*return*/, context];
+                    }
+                });
+            }); }, Promise.resolve(engineContext.nodes))];
+    });
+}); };
+/**
+ * Compute the context for every node in the graph, done on initial graph load
+ * to compute the inputs/outputs for every node
+ */
+export var computeAllContexts = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () {
+    var result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0: return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, graph.nodes)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    return [2 /*return*/, result];
+                }
+                return [2 /*return*/];
+        }
+    });
+}); };
+/**
+ * Compute the contexts for nodes starting from the outputs, working backwards.
+ * Used to only (re)-compute context for any actively used nodes
+ */
+export var computeGraphContext = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () {
+    var outputFrag, outputVert, vertexIds, fragmentIds, unlinkedNodes, vertNodesOrError, fragNodesOrError;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
+                if (!outputFrag) {
+                    throw new Error('No fragment output in graph');
+                }
+                outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
+                if (!outputVert) {
+                    throw new Error('No vertex output in graph');
+                }
+                vertexIds = collectConnectedNodes(graph, outputVert);
+                fragmentIds = collectConnectedNodes(graph, outputFrag);
+                unlinkedNodes = findLinkedVertexNodes(graph, vertexIds);
+                return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, __spreadArray(__spreadArray([
+                        outputVert
+                    ], __read(Object.values(vertexIds).filter(function (node) { return node.id !== outputVert.id; })), false), __read(unlinkedNodes), false))];
+            case 1:
+                vertNodesOrError = _a.sent();
+                if (isError(vertNodesOrError)) {
+                    return [2 /*return*/, vertNodesOrError];
+                }
+                return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, __spreadArray([
+                        outputFrag
+                    ], __read(Object.values(fragmentIds).filter(function (node) { return node.id !== outputFrag.id; })), false))];
+            case 2:
+                fragNodesOrError = _a.sent();
+                if (isError(fragNodesOrError)) {
+                    return [2 /*return*/, fragNodesOrError];
+                }
+                return [2 /*return*/];
+        }
+    });
+}); };