@shaderfrog/core 2.0.0-beta.3 → 3.0.0

package/README.md

@@ -119,9 +119,9 @@ export interface Engine {
 
 Shaderfrog works by searching each node's AST for certain patterns, like
 `uniform` variables, and creating an interface where you can replace each
-`uniform` variable with the output of another node. 
+`uniform` variable with the output of another node.
 
-Each fillable part of the AST is called a __hole__. Holes are found by executing
+Each fillable part of the AST is called a **hole**. Holes are found by executing
 user defined _strategies_ against an AST. With a program such as:
 
 ```glsl

package/engine.d.ts

@@ -1,10 +1,10 @@
 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 { NodeInput, 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 { NodeContext, NodeContexts } from './graph/context';
 import { NodeParser } from './graph/parsers';
 export declare enum EngineNodeType {
     toon = "toon",
@@ -30,9 +30,44 @@ export interface Engine {
         [EngineNodeType.toon]?: ToonNodeConstructor;
     };
 }
-export type EngineContext = {
+export type EngineContext<T = any> = {
     engine: string;
     nodes: Record<string, NodeContext>;
+    runtime: T;
+    debuggingNonsense: {
+        vertexSource?: string;
+        vertexPreprocessed?: string;
+        fragmentPreprocessed?: string;
+        fragmentSource?: string;
+    };
+};
+export declare const extendNodeContext: (context: EngineContext, nodeId: string, nodeContext: Partial<NodeContext>) => {
+    nodes: {
+        [x: string]: NodeContext | {
+            id?: string;
+            name?: string;
+            computedSource?: string;
+            ast: import("@shaderfrog/glsl-parser/ast").AstNode | Program;
+            inputs?: NodeInput[];
+            inputFillers: import("./strategy").InputFillers;
+            errors?: import("./graph/context").NodeErrors;
+            mainFn?: import("@shaderfrog/glsl-parser/ast").FunctionNode;
+        };
+    };
+    engine: string;
+    runtime: any;
+    debuggingNonsense: {
+        vertexSource?: string;
+        vertexPreprocessed?: string;
+        fragmentPreprocessed?: string;
+        fragmentSource?: string;
+    };
+};
+export declare const extendNodesContext: (context: EngineContext, nodesContext: NodeContexts) => {
+    nodes: {
+        [x: string]: NodeContext;
+    };
+    engine: string;
     runtime: any;
     debuggingNonsense: {
         vertexSource?: string;
@@ -47,6 +82,7 @@ export type EngineImporter = {
     edgeMap: {
         [oldInput: string]: string;
     };
+    code?: Record<string, string>;
 };
 export type EngineImporters = {
     [engine: string]: EngineImporter;

package/engine.js

@@ -56,6 +56,11 @@ export var EngineNodeType;
     EngineNodeType["shader"] = "shader";
     EngineNodeType["binary"] = "binary";
 })(EngineNodeType || (EngineNodeType = {}));
+export var extendNodeContext = function (context, nodeId, nodeContext) {
+    var _a;
+    return (__assign(__assign({}, context), { nodes: __assign(__assign({}, context.nodes), (_a = {}, _a[nodeId] = __assign(__assign({}, (context.nodes[nodeId] || {})), nodeContext), _a)) }));
+};
+export var extendNodesContext = function (context, nodesContext) { return (__assign(__assign({}, context), { nodes: __assign(__assign({}, context.nodes), nodesContext) })); };
 // type EdgeUpdates = { [edgeId: string]: { oldInput: string; newInput: string } };
 export var convertNode = function (node, converter) {
     log("Converting ".concat(node.name, " (").concat(node.id, ")"));

package/graph/code-nodes.d.ts

@@ -26,17 +26,23 @@ export interface NodeProperty {
 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"
+    FN_BODY_FRAGMENT = "Function Body Fragment",
+    EXPRESSION = "Expression"
 }
+export type Backfillers = Record<string, {
+    argType: string;
+    targetVariable: string;
+}[]>;
 export interface CodeNode extends BaseNode {
     config: NodeConfig;
+    type: string;
     engine: boolean;
     source: string;
     sourceType?: SourceType;
     stage?: ShaderStage;
     biStage?: boolean;
     originalEngine?: string;
+    backfillers?: Backfillers;
 }
 export interface BinaryNode extends CodeNode {
     operator: string;

package/graph/code-nodes.js

@@ -13,6 +13,10 @@ export var property = function (displayName, property, type, fillerName, default
 export var SourceType;
 (function (SourceType) {
     SourceType["SHADER_PROGRAM"] = "Shader Program";
-    SourceType["EXPRESSION"] = "Expression";
+    // Function body fragments are parsed, and parsed differently than shader
+    // programs. This confuses me all the time. TODO: Remove fn_body_framgent
+    // and just try/catch parsing a program, then try fn body fragment?
     SourceType["FN_BODY_FRAGMENT"] = "Function Body Fragment";
+    // Expressions are inlined as is
+    SourceType["EXPRESSION"] = "Expression";
 })(SourceType || (SourceType = {}));

package/graph/context.d.ts

@@ -1,9 +1,9 @@
 import { type GlslSyntaxError } from '@shaderfrog/glsl-parser';
-import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
+import { AstNode, FunctionNode, 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';
+import { InputFillers } from '../strategy';
 /**
  * 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
@@ -12,26 +12,28 @@ import { InputFillers } from './parsers';
 export type NodeContext = {
     id?: string;
     name?: string;
-    source?: string;
+    computedSource?: string;
     ast: AstNode | Program;
     inputs?: NodeInput[];
     inputFillers: InputFillers;
     errors?: NodeErrors;
+    mainFn?: FunctionNode;
 };
+export type NodeContexts = Record<string, NodeContext>;
 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>>;
+export declare const computeContextForNodes: (engineContext: EngineContext, engine: Engine, graph: Graph, nodes: GraphNode[]) => Promise<NodeErrors | NodeContexts>;
 /**
  * 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 | undefined>;
+export declare const computeAllContexts: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors | NodeContexts>;
 /**
  * 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 | undefined>;
+export declare const computeGraphContext: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors | NodeContexts>;

package/graph/context.js

@@ -71,10 +71,12 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import groupBy from 'lodash.groupby';
+import { extendNodeContext, extendNodesContext, } from '../engine';
 import { mapInputName, SourceType } from './code-nodes';
 import { NodeType } from './graph-types';
-import { collectConnectedNodes, filterGraphFromNode, findLinkedNode, findLinkedVertexNodes, isSourceNode, mangleEntireProgram, } from './graph';
+import { collectConnectedNodes, filterGraphFromNode, findLinkedNode, findLinkedVertexNodes, isSourceNode, mangleEntireProgram, shouldNodeHaveMainFn, } from './graph';
 import { coreParsers } from './parsers';
+import { findMain } from '../util/ast';
 var makeError = function (nodeId) {
     var errors = [];
     for (var _i = 1; _i < arguments.length; _i++) {
@@ -97,24 +99,32 @@ 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;
+    var parser, sibling, onBeforeCompile, manipulateAst, updatedNodeContext, updatedContext, inputEdges, mainFn, 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;
+                updatedContext = engineContext;
                 if (!onBeforeCompile) return [3 /*break*/, 2];
                 return [4 /*yield*/, onBeforeCompile(graph, engineContext, node, sibling)];
             case 1:
-                _a.sent();
+                updatedNodeContext = _a.sent();
+                if (updatedNodeContext) {
+                    updatedContext = extendNodeContext(engineContext, node.id, updatedNodeContext);
+                }
                 _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);
+                    ast = parser.produceAst(updatedContext, engine, graph, node, inputEdges);
+                    // Find the main function before mangling
+                    if (shouldNodeHaveMainFn(node)) {
+                        mainFn = findMain(ast);
+                    }
                     if (manipulateAst) {
-                        ast = manipulateAst(engineContext, engine, graph, ast, inputEdges, node, sibling);
+                        ast = manipulateAst(updatedContext, engine, graph, ast, inputEdges, node, sibling);
                     }
                 }
                 catch (error) {
@@ -126,23 +136,11 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                         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);
+                computedInputs = parser.findInputs(updatedContext, 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
@@ -152,6 +150,20 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                     node.sourceType !== SourceType.FN_BODY_FRAGMENT) {
                     mangleEntireProgram(engine, ast, node, findLinkedNode(graph, node.id));
                 }
+                nodeContext = __assign(__assign({}, (updatedNodeContext || {})), { ast: ast, id: node.id, mainFn: mainFn, inputFillers: computedInputs.reduce(function (acc, _a) {
+                        var _b;
+                        var _c = __read(_a, 4), input = _c[0], filler = _c[1], fillerArgs = _c[2], fillerStmt = _c[3];
+                        // This is intentionally broken out into an explicit return to force
+                        // this type declaration. Inlining the object in [input.id]: {...}
+                        // doesn't force it to be an InputFillerGroup, and it can contain extra
+                        // arguments by accident
+                        var fillerGroup = {
+                            filler: filler,
+                            fillerArgs: fillerArgs,
+                            fillerStmt: fillerStmt,
+                        };
+                        return __assign(__assign({}, acc), (_b = {}, _b[input.id] = fillerGroup, _b));
+                    }, {}) });
                 return [2 /*return*/, nodeContext];
         }
     });
@@ -162,22 +174,22 @@ export var computeContextForNodes = function (engineContext, engine, graph, node
                 .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) {
+                var _a;
+                return __generator(this, function (_b) {
+                    switch (_b.label) {
                         case 0: return [4 /*yield*/, ctx];
                         case 1:
-                            context = _a.sent();
+                            context = _b.sent();
                             if (isError(context)) {
                                 return [2 /*return*/, context];
                             }
                             return [4 /*yield*/, computeNodeContext(engineContext, engine, graph, node)];
                         case 2:
-                            nodeContextOrError = _a.sent();
+                            nodeContextOrError = _b.sent();
                             if (isError(nodeContextOrError)) {
                                 return [2 /*return*/, nodeContextOrError];
                             }
-                            context[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContextOrError);
-                            return [2 /*return*/, context];
+                            return [2 /*return*/, __assign(__assign({}, context), (_a = {}, _a[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContextOrError), _a))];
                     }
                 });
             }); }, Promise.resolve(engineContext.nodes))];
@@ -187,26 +199,18 @@ export var computeContextForNodes = function (engineContext, engine, graph, node
  * 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*/];
-        }
-    });
-}); };
+export var computeAllContexts = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () { return __generator(this, function (_a) {
+    switch (_a.label) {
+        case 0: return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, graph.nodes)];
+        case 1: return [2 /*return*/, _a.sent()];
+    }
+}); }); };
 /**
  * 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;
+    var outputFrag, outputVert, vertexes, fragments, vertexIds, unlinkedNodes, vertNodesOrError, updatedContext, finalNodeContextOrError;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
@@ -218,26 +222,25 @@ export var computeGraphContext = function (engineContext, engine, graph) { retur
                 if (!outputVert) {
                     throw new Error('No vertex output in graph');
                 }
-                vertexIds = collectConnectedNodes(graph, outputVert);
-                fragmentIds = collectConnectedNodes(graph, outputFrag);
-                unlinkedNodes = findLinkedVertexNodes(graph, vertexIds);
+                vertexes = collectConnectedNodes(graph, outputVert);
+                fragments = collectConnectedNodes(graph, outputFrag);
+                vertexIds = new Set(Object.keys(vertexes));
+                unlinkedNodes = findLinkedVertexNodes(graph, vertexes);
                 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))];
+                    ], __read(Object.values(vertexes).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([
+                updatedContext = extendNodesContext(engineContext, vertNodesOrError);
+                return [4 /*yield*/, computeContextForNodes(updatedContext, engine, graph, __spreadArray([
                         outputFrag
-                    ], __read(Object.values(fragmentIds).filter(function (node) { return node.id !== outputFrag.id; })), false))];
+                    ], __read(Object.values(fragments).filter(function (node) { return node.id !== outputFrag.id && !vertexIds.has(node.id); })), false))];
             case 2:
-                fragNodesOrError = _a.sent();
-                if (isError(fragNodesOrError)) {
-                    return [2 /*return*/, fragNodesOrError];
-                }
-                return [2 /*return*/];
+                finalNodeContextOrError = _a.sent();
+                return [2 /*return*/, finalNodeContextOrError];
         }
     });
 }); };

package/graph/data-nodes.d.ts

@@ -20,17 +20,26 @@ export declare const numberNode: (id: string, name: string, position: NodePositi
 }) => NumberNode;
 export type NumberDataUniform = Pick<NumberNode, 'type' | 'value' | 'name' | 'range' | 'stepper'>;
 export declare const numberUniformData: (name: string, value: string, range?: [string | number, string | number], stepper?: string | number) => NumberDataUniform;
-export type AssetVersionNodeData = {
-    assetId: number;
-    versionId: number;
+export type TextureNodeValueData = {
+    assetId?: number;
+    versionId?: number;
+    properties?: {
+        repeatTexure: boolean;
+        repeat?: {
+            x: number;
+            y: number;
+        };
+        anisotropy?: number;
+        encoding?: 'srgb';
+    };
 };
 export interface TextureNode extends BaseNode {
     type: 'texture';
-    value?: AssetVersionNodeData;
+    value?: TextureNodeValueData;
 }
-export declare const textureNode: (id: string, name: string, position: NodePosition, value: AssetVersionNodeData) => TextureNode;
+export declare const textureNode: (id: string, name: string, position: NodePosition, value?: TextureNodeValueData) => TextureNode;
 export type TextureDataUniform = Pick<TextureNode, 'type' | 'value' | 'name'>;
-export declare const textureUniformData: (name: string, value: AssetVersionNodeData) => TextureDataUniform;
+export declare const textureUniformData: (name: string, value: TextureNodeValueData) => TextureDataUniform;
 export interface SamplerCubeNode extends BaseNode {
     type: 'samplerCube';
     value: string;

package/graph/data-nodes.js

@@ -40,7 +40,7 @@ export var textureNode = function (id, name, position, value) { return ({
     id: id,
     name: name,
     position: position,
-    value: value,
+    value: __assign(__assign({}, (value || { assetId: undefined, versionId: undefined })), { properties: (value === null || value === void 0 ? void 0 : value.properties) || { repeatTexure: true } }),
     inputs: [],
     outputs: [
         {

package/graph/evaluate.js

@@ -1,6 +1,9 @@
 import { coreParsers } from './parsers';
 export var toGlsl = function (node) {
     var type = node.type, value = node.value;
+    if (type === 'number') {
+        return value;
+    }
     if (type === 'vector2') {
         return "vec2(".concat(value[0], ", ").concat(value[1], ")");
     }
@@ -10,6 +13,10 @@ export var toGlsl = function (node) {
     if (type === 'vector4' || type === 'rgba') {
         return "vec4(".concat(value[0], ", ").concat(value[1], ", ").concat(value[2], ", ").concat(value[3], ")");
     }
+    // Right now hard coding that an array is floats. Need type from node later.
+    if (type === 'array') {
+        return "float[".concat(value.length, "](").concat(value.join(', '), ")");
+    }
     throw new Error("Unknown GLSL inline type: \"".concat(node.type, "\""));
 };
 export var evaluateNode = function (engine, graph, node) {

package/graph/graph-types.d.ts

@@ -4,12 +4,11 @@ import { SourceNode } from './code-nodes';
 /**
  * Core graph types.
  *
- * Originally abstracted out of graph.ts to avoid a circular
- * dependency between graph.ts and parsers.ts. Both files need these types at
- * module initialization time, and without this third file, the types will be
- * undefined in either graph/parsers.ts at init time. If the types were only
- * used at runtime it would be fine, because the circular depenency is resolved
- * by then.
+ * Originally abstracted out of graph.ts to avoid a circular dependency between
+ * graph.ts and parsers.ts. Both files need these types at module initialization
+ * time, and without this third file, the types will be undefined in either
+ * graph/parsers.ts at init time. If the types were only used at runtime it
+ * would be fine, because the circular depenency is resolved by then.
  */
 export type ShaderStage = 'fragment' | 'vertex';
 /**
@@ -35,4 +34,25 @@ export interface Graph {
     nodes: GraphNode[];
     edges: Edge[];
 }
+export type EdgesByNode = {
+    [nodeId: string]: {
+        from: Edge[];
+        to: {
+            edges: Edge[];
+            edgesByInput: {
+                [inputId: string]: Edge;
+            };
+        };
+    };
+};
+export type Grindex = {
+    nodes: {
+        [nodeId: string]: GraphNode;
+    };
+    edges: {
+        [edgeId: string]: Edge;
+    };
+    edgesByNode: EdgesByNode;
+};
+export declare const computeGrindex: (graph: Graph) => Grindex;
 export declare const MAGIC_OUTPUT_STMTS = "mainStmts";

package/graph/graph-types.js

@@ -1,3 +1,40 @@
+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 indexById from '../util/indexByid';
 /**
  * The type applied to the edge representing a link between node stages
  */
@@ -19,4 +56,36 @@ export var NodeType;
     NodeType["BINARY"] = "binary";
     NodeType["SOURCE"] = "source";
 })(NodeType || (NodeType = {}));
+var lastGraph;
+var lastGrindex;
+export var computeGrindex = function (graph) {
+    // Poor programmer's memoization
+    if (graph === lastGraph && lastGrindex) {
+        return lastGrindex;
+    }
+    lastGraph = graph;
+    lastGrindex = {
+        nodes: indexById(graph.nodes),
+        edges: indexById(graph.edges),
+        edgesByNode: graph.edges.reduce(function (acc, edge) {
+            var _a, _b, _c;
+            var _d, _e, _f, _g, _h, _j, _k, _l, _m, _o;
+            var to = edge.to, from = edge.from;
+            return __assign(__assign({}, acc), (_a = {}, _a[to] = {
+                to: {
+                    edges: __spreadArray(__spreadArray([], __read((((_e = (_d = acc[to]) === null || _d === void 0 ? void 0 : _d.to) === null || _e === void 0 ? void 0 : _e.edges) || [])), false), [edge], false),
+                    edgesByInput: __assign(__assign({}, (_g = (_f = acc[to]) === null || _f === void 0 ? void 0 : _f.to) === null || _g === void 0 ? void 0 : _g.edgesByInput), (_b = {}, _b[edge.input] = edge, _b)),
+                },
+                from: ((_h = acc[to]) === null || _h === void 0 ? void 0 : _h.from) || [],
+            }, _a[from] = {
+                to: {
+                    edges: ((_k = (_j = acc[from]) === null || _j === void 0 ? void 0 : _j.to) === null || _k === void 0 ? void 0 : _k.edges) || [],
+                    edgesByInput: __assign(__assign({}, (_m = (_l = acc[from]) === null || _l === void 0 ? void 0 : _l.to) === null || _m === void 0 ? void 0 : _m.edgesByInput), (_c = {}, _c[edge.input] = edge, _c)),
+                },
+                from: __spreadArray(__spreadArray([], __read((((_o = acc[from]) === null || _o === void 0 ? void 0 : _o.from) || [])), false), [edge], false),
+            }, _a));
+        }, {}),
+    };
+    return lastGrindex;
+};
 export var MAGIC_OUTPUT_STMTS = 'mainStmts';

package/graph/graph.d.ts

@@ -1,6 +1,6 @@
 import { Program } from '@shaderfrog/glsl-parser/ast';
 import { Engine, EngineContext } from '../engine';
-import { NodeErrors } from './context';
+import { NodeContexts, NodeErrors } from './context';
 import { ShaderSections } from './shader-sections';
 import { FrogProgram } from '../util/ast';
 import { DataNode } from './data-nodes';
@@ -11,16 +11,45 @@ import { ProduceNodeFiller } from './parsers';
 import { Graph, GraphNode } from './graph-types';
 export declare const isDataNode: (node: GraphNode) => node is DataNode;
 export declare const isSourceNode: (node: GraphNode) => node is SourceNode;
+/**
+ * Determine if a node's source code / AST should have a main function. Essentially
+ * check if the source code is a full program or not.
+ */
+export declare const shouldNodeHaveMainFn: (node: GraphNode) => node is SourceNode;
 export declare const findNode: (graph: Graph, id: string) => GraphNode;
 export declare const doesLinkThruShader: (graph: Graph, node: GraphNode) => boolean;
 export declare const nodeName: (node: GraphNode) => string;
+export declare const resultName: (node: GraphNode) => string;
 export declare const mangleName: (name: string, node: GraphNode, nextSibling?: GraphNode) => string;
 export declare const mangleVar: (name: string, engine: Engine, node: GraphNode, sibling?: GraphNode) => string;
 export declare const mangleEntireProgram: (engine: Engine, ast: FrogProgram, node: GraphNode, sibling?: GraphNode) => void;
 export declare const mangleMainFn: (ast: Program, node: GraphNode, sibling?: GraphNode) => void;
-export declare const ensureFromNode: (graph: Graph, inputEdge: Edge) => import("./data-nodes").NumberNode | import("./data-nodes").TextureNode | import("./data-nodes").SamplerCubeNode | import("./data-nodes").ArrayNode | import("./data-nodes").Vector2Node | import("./data-nodes").Vector3Node | import("./data-nodes").Vector4Node | import("./data-nodes").RgbNode | import("./data-nodes").RgbaNode | CodeNode | import("./code-nodes").BinaryNode;
+export declare const ensureFromNode: (graph: Graph, inputEdge: Edge) => import("./data-nodes").NumberNode | import("./data-nodes").TextureNode | import("./data-nodes").SamplerCubeNode | import("./data-nodes").ArrayNode | import("./data-nodes").Vector2Node | import("./data-nodes").Vector3Node | import("./data-nodes").Vector4Node | import("./data-nodes").RgbNode | import("./data-nodes").RgbaNode | import("./code-nodes").BinaryNode | CodeNode;
 export declare const resetGraphIds: (graph: Graph) => Graph;
-export declare const findLinkedNode: (graph: Graph, id: string) => GraphNode | undefined;
+/**
+ * A binary node automatically adds/removes inputs based on how many edges
+ * connect to it. If a binary node has edges to "a" and "b", removing the edge
+ * to "a" means the edge to "b" needs to be moved down to the "a" one. This
+ * function essentially groups edges by target node id, and resets the edge
+ * target to its index. This doesn't feel good to do here but I don't have a
+ * better idea at the moment. One reason the inputs to binary nodes are
+ * automatically updated after compile, but the edges are updated here
+ * at the editor layer, before compile. This also hard codes assumptions about
+ * (binary) node inputs into the graph, namely they can't have blank inputs.
+ */
+export declare const collapseBinaryGraphEdges: (graph: Graph) => Graph;
+/**
+ * Restrict edges so that an input handle can't have multiple edges going to it
+ */
+export declare const addEdgeAndPruneRestrictions: (edges: Edge[], newEdge: Edge) => Edge[];
+/**
+ * Adds an edge to the graph and enforces graph edge business logic rules:
+ * - Makes sure "binary" (add/multiply) nodes edges are collapsed
+ * - Makes sure two edges can't flow into the same input.
+ * See also editor/flow-helpers.ts
+ */
+export declare const addGraphEdge: (graph: Graph, newEdge: Edge) => Graph;
+export declare const findLinkedNode: (graph: Graph, nodeId: string) => SourceNode | undefined;
 /**
  * Find any unconnected vertex nodes linked to collected fragment nodes
  */
@@ -33,7 +62,7 @@ export type Predicates = {
 export type SearchResult = {
     nodes: Record<string, GraphNode>;
     inputs: Record<string, NodeInput[]>;
-    edges: Edge[];
+    edges: Record<string, Edge>;
 };
 export declare const consSearchResult: () => SearchResult;
 export declare const mergeSearchResults: (a: SearchResult, b: SearchResult) => SearchResult;
@@ -80,11 +109,13 @@ export declare const compileGraph: (engineContext: EngineContext, engine: Engine
 export declare const collectNodeProperties: (graph: Graph) => SearchResult;
 export type IndexedDataInputs = Record<string, NodeInput[]>;
 export type CompileResult = {
+    updatedNodeContext: NodeContexts;
     fragmentResult: string;
     vertexResult: string;
     compileResult: CompileGraphResult;
     dataNodes: Record<string, GraphNode>;
     dataInputs: IndexedDataInputs;
+    compileMs: string;
 };
 export declare const compileSource: (graph: Graph, engine: Engine, ctx: EngineContext) => Promise<CompileResult | NodeErrors>;
 export {};