@shaderfrog/core 1.0.10 → 1.1.0

package/dist/graph/{engine-node.js → graph-node.js}

@@ -1,25 +1,19 @@
-import { EngineNodeType } from '../engine';
-import { prepopulatePropertyInputs } from './graph';
 import { NodeType } from './graph-types';
-import { assignemntToStrategy, namedAttributeStrategy, texture2DStrategy, uniformStrategy, variableStrategy, } from '../strategy';
-import { SourceType, property, } from './code-nodes';
-/**
- * TODO: These definitions should live outside of core since I'm trying to
- * refactor out this core folder to only know about nodes with config config,
- * where nodes like output/phong/physical are all configured at the
- * implementation level. "phong" shouldn't be in the core
- */
-export var sourceNode = function (id, name, position, config, source, stage, originalEngine, nextStageNodeId) { return ({
+import { assignemntToStrategy, variableStrategy } from '../strategy';
+import { SourceType } from './code-nodes';
+export var sourceNode = function (id, name, position, config, source, stage, originalEngine) { return ({
     id: id,
     name: name,
-    groupId: undefined,
     type: NodeType.SOURCE,
+    sourceType: SourceType.SHADER_PROGRAM,
+    engine: false,
     config: config,
     position: position,
     inputs: [],
     outputs: [
         {
             name: 'vector4',
+            dataType: 'vector4',
             category: 'data',
             id: '1',
         },
@@ -27,14 +21,14 @@ export var sourceNode = function (id, name, position, config, source, stage, ori
     source: source,
     stage: stage,
     originalEngine: originalEngine,
-    nextStageNodeId: nextStageNodeId,
 }); };
 export var outputNode = function (id, name, position, stage) { return ({
     id: id,
     name: name,
     position: position,
-    groupId: undefined,
     type: NodeType.OUTPUT,
+    sourceType: SourceType.SHADER_PROGRAM,
+    engine: false,
     config: {
         version: 3,
         mangle: false,
@@ -65,8 +59,8 @@ export var expressionNode = function (id, name, position, source) { return ({
     name: name,
     position: position,
     type: NodeType.SOURCE,
+    engine: false,
     sourceType: SourceType.EXPRESSION,
-    groupId: undefined,
     stage: undefined,
     config: {
         uniforms: [],
@@ -85,60 +79,12 @@ export var expressionNode = function (id, name, position, source) { return ({
     ],
     source: source,
 }); };
-export var phongNode = function (id, name, groupId, position, stage, nextStageNodeId) {
-    return prepopulatePropertyInputs({
-        id: id,
-        name: name,
-        groupId: groupId,
-        position: position,
-        type: EngineNodeType.phong,
-        config: {
-            version: 3,
-            uniforms: [],
-            preprocess: true,
-            mangle: false,
-            properties: [
-                property('Color', 'color', 'rgb', 'uniform_diffuse'),
-                property('Emissive', 'emissive', 'rgb', 'uniform_emissive'),
-                property('Emissive Map', 'emissiveMap', 'texture', 'filler_emissiveMap'),
-                property('Emissive Intensity', 'emissiveIntensity', 'number', 'uniform_emissive'),
-                property('Texture', 'map', 'texture', 'filler_map'),
-                property('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
-                property('Normal Scale', 'normalScale', 'vector2'),
-                property('Shininess', 'shininess', 'number'),
-                property('Reflectivity', 'reflectivity', 'number'),
-                property('Refraction Ratio', 'refractionRatio', 'number'),
-                property('Specular', 'specular', 'rgb', 'uniform_specular'),
-                property('Specular Map', 'specularMap', 'texture', 'filler_specularMap'),
-                property('Displacement Map', 'displacementMap', 'texture'),
-                property('Env Map', 'envMap', 'samplerCube'),
-            ],
-            strategies: [
-                uniformStrategy(),
-                stage === 'fragment'
-                    ? texture2DStrategy()
-                    : namedAttributeStrategy('position'),
-            ],
-        },
-        inputs: [],
-        outputs: [
-            {
-                name: 'vector4',
-                category: 'data',
-                id: '1',
-            },
-        ],
-        source: '',
-        stage: stage,
-        nextStageNodeId: nextStageNodeId,
-    });
-};
 export var addNode = function (id, position) { return ({
     id: id,
     name: 'add',
     position: position,
     type: NodeType.BINARY,
-    groupId: undefined,
+    engine: false,
     stage: undefined,
     config: {
         mangle: false,
@@ -164,7 +110,7 @@ export var multiplyNode = function (id, position) { return ({
     id: id,
     name: 'multiply',
     type: NodeType.BINARY,
-    groupId: undefined,
+    engine: false,
     stage: undefined,
     position: position,
     config: {

package/dist/graph/graph-types.d.ts

@@ -12,6 +12,19 @@ import { SourceNode } from './code-nodes';
  * by then.
  */
 export type ShaderStage = 'fragment' | 'vertex';
+/**
+ * The type applied to the edge representing a link between node stages
+ */
+export declare enum EdgeLink {
+    NEXT_STAGE = "next_stage"
+}
+/**
+ * The handle types for links. These become <Handle /> ids
+ */
+export declare enum LinkHandle {
+    NEXT_STAGE = "next_stage",
+    PREVIOUS_STAGE = "previous_stage"
+}
 export declare enum NodeType {
     OUTPUT = "output",
     BINARY = "binary",

package/dist/graph/graph-types.js

@@ -1,3 +1,18 @@
+/**
+ * The type applied to the edge representing a link between node stages
+ */
+export var EdgeLink;
+(function (EdgeLink) {
+    EdgeLink["NEXT_STAGE"] = "next_stage";
+})(EdgeLink || (EdgeLink = {}));
+/**
+ * The handle types for links. These become <Handle /> ids
+ */
+export var LinkHandle;
+(function (LinkHandle) {
+    LinkHandle["NEXT_STAGE"] = "next_stage";
+    LinkHandle["PREVIOUS_STAGE"] = "previous_stage";
+})(LinkHandle || (LinkHandle = {}));
 export var NodeType;
 (function (NodeType) {
     NodeType["OUTPUT"] = "output";

package/dist/graph/graph.d.ts

@@ -1,5 +1,6 @@
 import { Program } from '@shaderfrog/glsl-parser/ast';
 import { Engine, EngineContext } from '../engine';
+import { NodeErrors } from './context';
 import { ShaderSections } from './shader-sections';
 import { DataNode } from './data-nodes';
 import { Edge } from './edge';
@@ -12,18 +13,29 @@ export declare const isSourceNode: (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 mangleName: (name: string, node: GraphNode) => string;
-export declare const mangleVar: (name: string, engine: Engine, node: GraphNode) => string;
-export declare const mangleEntireProgram: (ast: Program, node: SourceNode, engine: Engine) => void;
-export declare const mangleMainFn: (ast: Program, node: SourceNode) => void;
-type Predicates = {
-    node?: (node: GraphNode, inputEdges: Edge[]) => boolean;
-    input?: (input: NodeInput, node: GraphNode, inputEdge: Edge | undefined, fromNode: GraphNode | undefined) => boolean;
+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: Program, node: GraphNode, sibling?: GraphNode) => void;
+export declare const mangleMainFn: (ast: Program, node: GraphNode, sibling?: GraphNode) => void;
+export declare const ensureFromNode: (graph: Graph, inputEdge: Edge) => GraphNode;
+export declare const resetGraphIds: (graph: Graph) => Graph;
+export declare const findLinkedNode: (graph: Graph, id: string) => GraphNode;
+/**
+ * Find any unconnected vertex nodes linked to collected fragment nodes
+ */
+export declare const findLinkedVertexNodes: (graph: Graph, existingIds?: NodeIds) => GraphNode[];
+export type Predicates = {
+    node?: (node: GraphNode, inputEdges: Edge[], lastResult: SearchResult) => boolean;
+    edge?: (input: NodeInput | undefined, node: GraphNode, inputEdge: Edge | undefined, fromNode: GraphNode | undefined, lastResult: SearchResult) => boolean;
+    input?: (input: NodeInput, node: GraphNode, inputEdge: Edge | undefined, fromNode: GraphNode | undefined, lastResult: SearchResult) => boolean;
 };
 export type SearchResult = {
     nodes: Record<string, GraphNode>;
     inputs: Record<string, NodeInput[]>;
+    edges: Edge[];
 };
+export declare const consSearchResult: () => SearchResult;
+export declare const mergeSearchResults: (a: SearchResult, b: SearchResult) => SearchResult;
 /**
  * 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
@@ -32,14 +44,12 @@ export type SearchResult = {
 export declare const prepopulatePropertyInputs: (node: CodeNode) => CodeNode;
 /**
  * Recursively filter the graph, starting from a specific node, looking for
- * nodes and edges that match predicates. This function returns the inputs for
- * matched edges, not the edges themselves, as a convenience for the only
- * consumer of this function, which is finding input names to use as uniforms.
+ * nodes and edges that match predicates.
  *
  * Inputs can only be filtered if the graph context has been computed, since
  * inputs aren't created until then.
  */
-export declare const filterGraphFromNode: (graph: Graph, node: GraphNode, predicates: Predicates, depth?: number) => SearchResult;
+export declare const filterGraphFromNode: (graph: Graph, node: GraphNode, predicates: Predicates, depth?: number, lastResult?: SearchResult) => SearchResult;
 export declare const collectConnectedNodes: (graph: Graph, node: GraphNode) => NodeIds;
 export declare const filterGraphNodes: (graph: Graph, nodes: GraphNode[], filter: Predicates, depth?: number) => SearchResult;
 type NodeIds = Record<string, GraphNode>;
@@ -75,5 +85,5 @@ export type CompileResult = {
     dataNodes: Record<string, GraphNode>;
     dataInputs: IndexedDataInputs;
 };
-export declare const compileSource: (graph: Graph, engine: Engine, ctx: EngineContext) => Promise<CompileResult>;
+export declare const compileSource: (graph: Graph, engine: Engine, ctx: EngineContext) => Promise<CompileResult | NodeErrors>;
 export {};

package/dist/graph/graph.js

@@ -71,7 +71,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { renameBindings, renameFunctions, } from '@shaderfrog/glsl-parser/parser/utils';
-import { computeGraphContext } from './context';
+import { computeGraphContext, isError, } from './context';
 import { emptyShaderSections, findShaderSections, mergeShaderSections, shaderSectionsToProgram, } from './shader-sections';
 import { makeExpression } from '../util/ast';
 import { ensure } from '../util/ensure';
@@ -80,7 +80,7 @@ import { nodeInput } from './base-node';
 import { makeId } from '../util/id';
 import { coreParsers } from './parsers';
 import { toGlsl } from './evaluate';
-import { MAGIC_OUTPUT_STMTS, NodeType } from './graph-types';
+import { EdgeLink, MAGIC_OUTPUT_STMTS, NodeType, } from './graph-types';
 import { generate } from '@shaderfrog/glsl-parser';
 var log = function () {
     var _a;
@@ -100,7 +100,7 @@ export var findNode = function (graph, id) {
     return ensure(graph.nodes.find(function (node) { return node.id === id; }));
 };
 export var doesLinkThruShader = function (graph, node) {
-    var edges = graph.edges.filter(function (edge) { return edge.from === node.id; });
+    var edges = graph.edges.filter(function (edge) { return edge.type !== EdgeLink.NEXT_STAGE && edge.from === node.id; });
     if (edges.length === 0) {
         return false;
     }
@@ -120,72 +120,128 @@ export var doesLinkThruShader = function (graph, node) {
 export var nodeName = function (node) {
     return 'main_' + node.name.replace(/[^a-zA-Z0-9]/g, ' ').replace(/ +/g, '_');
 };
-export var mangleName = function (name, node) {
-    // Mangle names by using the next stage id, if present
-    var id = ('nextStageNodeId' in node && node.nextStageNodeId) || node.id;
+export var mangleName = function (name, node, nextSibling) {
+    // Mangle a name to its next stage node, so the vertex suffix becomes the
+    // fragment id, but not the other way around.
+    var id = (nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.stage) === 'fragment'
+        ? nextSibling === null || nextSibling === void 0 ? void 0 : nextSibling.id
+        : node.id;
     return "".concat(name, "_").concat(id);
 };
-export var mangleVar = function (name, engine, node) {
-    return engine.preserve.has(name) ? name : mangleName(name, node);
-};
-export var mangleEntireProgram = function (ast, node, engine) {
+export var mangleVar = function (name, engine, node, sibling) { return (engine.preserve.has(name) ? name : mangleName(name, node, sibling)); };
+export var mangleEntireProgram = function (engine, ast, node, sibling) {
     renameBindings(ast.scopes[0], function (name, n) {
-        return n.doNotDescope ? name : mangleVar(name, engine, node);
+        return n.doNotDescope ? name : mangleVar(name, engine, node, sibling);
     });
-    mangleMainFn(ast, node);
+    mangleMainFn(ast, node, sibling);
 };
-export var mangleMainFn = function (ast, node) {
+export var mangleMainFn = function (ast, node, sibling) {
     renameFunctions(ast.scopes[0], function (name) {
-        return name === 'main' ? nodeName(node) : mangleName(name, node);
+        return name === 'main' ? nodeName(node) : mangleName(name, node, sibling);
     });
 };
+export var ensureFromNode = function (graph, inputEdge) {
+    return ensure(graph.nodes.find(function (_a) {
+        var id = _a.id;
+        return id === inputEdge.from;
+    }), "Orphaned edge! There is an edge fro \"".concat(inputEdge.from, "\" to \"").concat(inputEdge.to, "\", but from node ").concat(inputEdge.from, " does not exist in the graph."));
+};
+export var resetGraphIds = function (graph) {
+    var idMap = {};
+    var map = function (id) {
+        idMap[id] = idMap[id] || makeId();
+        return idMap[id];
+    };
+    return {
+        nodes: graph.nodes.map(function (n) { return (__assign(__assign(__assign({}, n), { id: map(n.id) }), (n.parentId ? { parentId: map(n.parentId) } : {}))); }),
+        edges: graph.edges.map(function (e) { return (__assign(__assign({}, e), { id: map(e.id), from: map(e.from), to: map(e.to) })); }),
+    };
+};
+export var findLinkedNode = function (graph, id) {
+    var edgeLink = graph.edges.find(function (e) { return e.type === EdgeLink.NEXT_STAGE && (e.from === id || e.to === id); });
+    var otherId = (edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from) === id ? edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.to : edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from;
+    return graph.nodes.find(function (node) { return node.id === otherId; });
+};
+/**
+ * Find any unconnected vertex nodes linked to collected fragment nodes
+ */
+export var findLinkedVertexNodes = function (graph, existingIds) {
+    if (existingIds === void 0) { existingIds = {}; }
+    // Group edges by where they point
+    var edgeLinks = graph.edges
+        .filter(function (e) { return e.type === EdgeLink.NEXT_STAGE; })
+        .reduce(function (edges, edge) {
+        var _a;
+        return (__assign(__assign({}, edges), (_a = {}, _a[edge.to] = edge, _a[edge.from] = edge, _a)));
+    }, {});
+    return graph.nodes.filter(function (node) {
+        // If this is a vertex node
+        return isSourceNode(node) &&
+            node.stage === 'vertex' &&
+            // That's linked
+            node.id in edgeLinks &&
+            // And not already captured (this should probably just be a set)
+            !existingIds[node.id];
+    });
+};
+export var consSearchResult = function () { return ({
+    nodes: {},
+    inputs: {},
+    edges: [],
+}); };
+export var mergeSearchResults = function (a, b) { return ({
+    nodes: __assign(__assign({}, a.nodes), b.nodes),
+    inputs: __assign(__assign({}, a.inputs), b.inputs),
+    edges: __spreadArray(__spreadArray([], __read(a.edges), false), __read(b.edges), false),
+}); };
 /**
  * Create the inputs on a node from the properties. This used to be done at
  * context time. Doing it at node creation time lets us auto-bake edges into
  * the node at initial graph creation time.
  */
 export var prepopulatePropertyInputs = function (node) { return (__assign(__assign({}, node), { inputs: __spreadArray(__spreadArray([], __read(node.inputs), false), __read((node.config.properties || []).map(function (property) {
-        return nodeInput(property.displayName, "property_".concat(property.property), 'property', property.type, new Set(['data']), !!property.fillerName, // bakeable
+        return nodeInput(property.displayName, "property_".concat(property.property), 'property', property.type, ['data'], !!property.fillerName, // bakeable
         property.property);
     })), false) })); };
 /**
  * Recursively filter the graph, starting from a specific node, looking for
- * nodes and edges that match predicates. This function returns the inputs for
- * matched edges, not the edges themselves, as a convenience for the only
- * consumer of this function, which is finding input names to use as uniforms.
+ * nodes and edges that match predicates.
  *
  * Inputs can only be filtered if the graph context has been computed, since
  * inputs aren't created until then.
  */
-export var filterGraphFromNode = function (graph, node, predicates, depth) {
+export var filterGraphFromNode = function (graph, node, predicates, depth, lastResult) {
     var _a;
     if (depth === void 0) { depth = Infinity; }
+    if (lastResult === void 0) { lastResult = consSearchResult(); }
     var inputs = node.inputs;
     var inputEdges = graph.edges.filter(function (edge) { return edge.to === node.id; });
-    var nodeAcc = __assign({}, (predicates.node && predicates.node(node, inputEdges)
+    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
-            ? ensure(graph.nodes.find(function (_a) {
-                var id = _a.id;
-                return id === inputEdge.from;
-            }))
-            : undefined;
+        var fromNode = inputEdge ? ensureFromNode(graph, inputEdge) : undefined;
         var inputAcc = __assign(__assign({}, acc.inputs), (input &&
             predicates.input &&
-            predicates.input(input, node, inputEdge, fromNode)
+            predicates.input(input, node, inputEdge, fromNode, lastResult)
             ? (_a = {}, _a[node.id] = __spreadArray(__spreadArray([], __read((acc.inputs[node.id] || [])), false), [input], false), _a) : {}));
+        var edgeAcc = __spreadArray(__spreadArray([], __read(acc.edges), false), __read((predicates.edge &&
+            predicates.edge(input, node, inputEdge, fromNode, lastResult)
+            ? [inputEdge]
+            : [])), false);
+        // Add in the latest result of edges and inputs so that when we recurse into
+        // the next node, it has the latest accumulator
+        var intermediateAcc = __assign(__assign({}, acc), { inputs: inputAcc, edges: edgeAcc });
         if (inputEdge && fromNode && depth > 1) {
-            var result = filterGraphFromNode(graph, fromNode, predicates, depth - 1);
-            return {
-                nodes: __assign(__assign({}, acc.nodes), result.nodes),
-                inputs: __assign(__assign(__assign({}, acc.inputs), inputAcc), result.inputs),
-            };
+            var result = filterGraphFromNode(graph, fromNode, predicates, depth - 1, intermediateAcc);
+            return mergeSearchResults(intermediateAcc, result);
+        }
+        else {
+            return intermediateAcc;
         }
-        return __assign(__assign({}, acc), { inputs: __assign(__assign({}, acc.inputs), inputAcc) });
-    }, { inputs: {}, nodes: nodeAcc });
+    }, accumulatedResult);
 };
 export var collectConnectedNodes = function (graph, node) {
     return filterGraphFromNode(graph, node, { node: function () { return true; } }).nodes;
@@ -197,11 +253,9 @@ export var filterGraphNodes = function (graph, nodes, filter, depth) {
         return {
             nodes: __assign(__assign({}, acc.nodes), result.nodes),
             inputs: __assign(__assign({}, acc.inputs), result.inputs),
+            edges: __assign(__assign({}, acc.edges), result.edges),
         };
-    }, {
-        nodes: {},
-        inputs: {},
-    });
+    }, consSearchResult());
 };
 // before data inputs were known by the input.category being node or data. I
 // tried updating inputs to have acepts: [code|data] and "baked" now is there a
@@ -231,16 +285,19 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
     if (inputEdges.length) {
         var continuation_1 = emptyShaderSections();
         inputEdges
+            .filter(function (edge) { return edge.type !== EdgeLink.NEXT_STAGE; })
             .map(function (edge) { return ({
             edge: edge,
             fromNode: ensure(graph.nodes.find(function (node) { return edge.from === node.id; }), "GraphNode for edge ".concat(edge.from, " not found")),
             input: ensure(inputs.find(function (_a) {
                 var id = _a.id;
                 return id == edge.input;
-            }), "GraphNode \"".concat(node.name, "\" has no input ").concat(edge.input, "!\nAvailable:").concat(inputs.map(function (_a) {
+            }), "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(', '))),
+            })
+                .join(', '))),
         }); })
             .filter(function (_a) {
             var input = _a.input;
@@ -272,7 +329,9 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
                         inputFillers: inputFillers,
                         fillerName: fillerName,
                     });
-                    throw new Error("Node \"".concat(node.name, "\" has no filler for input \"").concat(input.displayName, "\" named ").concat(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));
                 }
                 /**
                  *      +------+    +------+
@@ -363,13 +422,7 @@ export var compileGraph = function (engineContext, engine, graph) {
     // 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 = graph.nodes.filter(function (node) {
-        return isSourceNode(node) &&
-            node.stage === 'vertex' &&
-            node.nextStageNodeId &&
-            fragmentIds[node.nextStageNodeId] &&
-            !vertexIds[node.id];
-    });
+    var orphanNodes = findLinkedVertexNodes(graph, vertexIds);
     var orphanEdges = orphanNodes.map(function (node) { return ({
         id: makeId(),
         from: node.id,
@@ -415,15 +468,19 @@ export var collectNodeProperties = function (graph) {
     return {
         nodes: __assign(__assign({}, fragProperties.nodes), vertProperties.nodes),
         inputs: __assign(__assign({}, fragProperties.inputs), vertProperties.inputs),
+        edges: __assign(__assign({}, fragProperties.edges), vertProperties.edges),
     };
 };
 export var compileSource = function (graph, engine, ctx) { return __awaiter(void 0, void 0, void 0, function () {
-    var compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
+    var result, compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0: return [4 /*yield*/, computeGraphContext(ctx, engine, graph)];
             case 1:
-                _a.sent();
+                result = _a.sent();
+                if (isError(result)) {
+                    return [2 /*return*/, result];
+                }
                 compileResult = compileGraph(ctx, engine, graph);
                 fragmentResult = generate(shaderSectionsToProgram(compileResult.fragment, engine.mergeOptions).program);
                 vertexResult = generate(shaderSectionsToProgram(compileResult.vertex, engine.mergeOptions).program);

package/dist/graph/graph.test.js

@@ -1,7 +1,7 @@
 import util from 'util';
 import { parser } from '@shaderfrog/glsl-parser';
 import { generate } from '@shaderfrog/glsl-parser';
-import { addNode } from './engine-node';
+import { addNode } from './graph-node';
 import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, } from './shader-sections';
 import { numberNode } from './data-nodes';
 import { makeEdge } from './edge';
@@ -36,16 +36,17 @@ var constructor = function () { return ({
     },
     id: '1',
     name: '1',
+    engine: true,
     type: '',
     inputs: [],
     outputs: [],
     position: { x: 0, y: 0 },
     source: '',
     stage: undefined,
-    groupId: null,
 }); };
 var engine = {
     name: 'three',
+    displayName: 'Three.js',
     evaluateNode: function (node) {
         if (node.type === 'number') {
             return parseFloat(node.value);

package/dist/graph/index.d.ts

@@ -1,6 +1,6 @@
 export * from './base-node';
 export * from './data-nodes';
-export * from './engine-node';
+export * from './graph-node';
 export * from './code-nodes';
 export * from './edge';
 export * from './parsers';

package/dist/graph/index.js

@@ -1,6 +1,6 @@
 export * from './base-node';
 export * from './data-nodes';
-export * from './engine-node';
+export * from './graph-node';
 export * from './code-nodes';
 export * from './edge';
 export * from './parsers';

package/dist/graph/parsers.d.ts

@@ -17,14 +17,14 @@ type FillerArguments = AstNode[];
 export type ComputedInput = [NodeInput, InputFiller, FillerArguments?];
 export type ProduceAst = (engineContext: EngineContext, engine: Engine, graph: Graph, node: SourceNode, inputEdges: Edge[]) => AstNode | Program;
 export type OnBeforeCompile = (graph: Graph, engineContext: EngineContext, node: SourceNode, sibling?: SourceNode) => Promise<void>;
-export type ManipulateAst = (engineContext: EngineContext, engine: Engine, graph: Graph, node: SourceNode, ast: AstNode | Program, inputEdges: Edge[]) => AstNode | Program;
+export type ManipulateAst = (engineContext: EngineContext, engine: Engine, graph: Graph, ast: AstNode | Program, inputEdges: Edge[], node: SourceNode, sibling: SourceNode) => AstNode | Program;
 export type NodeParser = {
     onBeforeCompile?: OnBeforeCompile;
     manipulateAst?: ManipulateAst;
     findInputs?: FindInputs;
     produceFiller?: ProduceNodeFiller;
 };
-export type FindInputs = (engineContext: EngineContext, node: SourceNode, ast: Program | AstNode, inputEdges: Edge[]) => ComputedInput[];
+export type FindInputs = (engineContext: EngineContext, ast: Program | AstNode, inputEdges: Edge[], node: SourceNode, sibling: SourceNode) => ComputedInput[];
 export type ProduceNodeFiller = (node: SourceNode, ast: Program | AstNode) => Filler;
 type CoreNodeParser = {
     produceAst: ProduceAst;

package/dist/graph/parsers.js

@@ -98,10 +98,10 @@ export var coreParsers = (_a = {},
             }
             return ast;
         },
-        findInputs: function (engineContext, node, ast) {
+        findInputs: function (engineContext, ast, edges, node, sibling) {
             var seen = new Set();
             return node.config.strategies
-                .flatMap(function (strategy) { return applyStrategy(strategy, node, ast); })
+                .flatMap(function (strategy) { return applyStrategy(strategy, ast, node, sibling); })
                 .filter(function (_a) {
                 var _b = __read(_a, 2), input = _b[0], _ = _b[1];
                 if (!seen.has(input.id)) {
@@ -125,12 +125,12 @@ export var coreParsers = (_a = {},
         produceAst: function (engineContext, engine, graph, node, inputEdges) {
             return parser.parse(node.source);
         },
-        findInputs: function (engineContext, node, ast) {
+        findInputs: function (engineContext, ast, edges, node, sibling) {
             return __spreadArray(__spreadArray([], __read(node.config.strategies.flatMap(function (strategy) {
-                return applyStrategy(strategy, node, ast);
+                return applyStrategy(strategy, ast, node, sibling);
             })), false), [
                 [
-                    nodeInput(MAGIC_OUTPUT_STMTS, "filler_".concat(MAGIC_OUTPUT_STMTS), 'filler', 'rgba', new Set(['code']), false),
+                    nodeInput(MAGIC_OUTPUT_STMTS, "filler_".concat(MAGIC_OUTPUT_STMTS), 'filler', 'rgba', ['code'], false),
                     function (fillerAst) {
                         var fn = ast.program.find(function (stmt) { return stmt.type === 'function'; });
                         fn === null || fn === void 0 ? void 0 : fn.body.statements.unshift(makeFnStatement(generateFiller(fillerAst)));
@@ -154,13 +154,13 @@ export var coreParsers = (_a = {},
                     : "a ".concat(node.operator, " b")) +
                 ')');
         },
-        findInputs: function (engineContext, node, ast, inputEdges) {
+        findInputs: function (engineContext, ast, inputEdges, node, sibling) {
             return new Array(Math.max(inputEdges.length + 1, 2))
                 .fill(0)
                 .map(function (_, index) {
                 var letter = alphabet.charAt(index);
                 return [
-                    nodeInput(letter, letter, 'filler', undefined, new Set(['data', 'code']), false),
+                    nodeInput(letter, letter, 'filler', undefined, ['data', 'code'], false),
                     function (fillerAst) {
                         var foundPath;
                         var visitors = {

package/dist/plugins/babylon/bablyengine.d.ts

@@ -5,7 +5,7 @@ import { CodeNode } from '../../graph/code-nodes';
 import { NodePosition } from '../../graph/base-node';
 import { UniformDataType } from '../../graph/data-nodes';
 export declare const physicalDefaultProperties: Partial<Record<keyof PBRMaterial, any>>;
-export declare const physicalNode: (id: string, name: string, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
+export declare const physicalNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
 export type RuntimeContext = {
     scene: Scene;
     camera: Camera;
@@ -23,6 +23,6 @@ export type RuntimeContext = {
         };
     };
 };
-export declare const toonNode: (id: string, name: string, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
+export declare const toonNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
 export declare let mIdx: number;
 export declare const babylengine: Engine;