@shaderfrog/core 1.0.10 → 1.1.0

package/README.md

@@ -1,6 +1,7 @@
 # Shaderfrog Core
 
 🚨 This library is experimental! 🚨
+
 🚨 The API can change at any time! 🚨
 
 The core graph API that powers Shaderfrog. This API, built on top of the
@@ -8,6 +9,12 @@ The core graph API that powers Shaderfrog. This API, built on top of the
 Shaderfrog graphs into an intermediate result, which you then pass off to an
 _engine_ (aka a plugin), to create a running GLSL shader.
 
+### Examples
+
+See examples of using Core in your own projects [on Github](https://github.com/ShaderFrog/examples).
+
+- **Three.js:** [Live](https://codesandbox.io/s/great-hertz-sjh425?file=/src/index.js) - [Source](https://github.com/ShaderFrog/examples/tree/main/three)
+
 ### Graph
 
 ```typescript

package/dist/engine.d.ts

@@ -13,18 +13,21 @@ export declare enum EngineNodeType {
     shader = "shader",
     binary = "binary"
 }
-export type PhysicalNodeConstructor = (id: string, name: string, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
-export type ToonNodeConstructor = (id: string, name: string, groupId: string | null | undefined, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined, nextStageNodeId?: string) => CodeNode;
+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: string;
+    name: 'three' | 'babylon' | 'playcanvas';
+    displayName: string;
     preserve: Set<string>;
     mergeOptions: MergeOptions;
     parsers: Record<string, NodeParser>;
     importers: EngineImporters;
     evaluateNode: (node: DataNode) => any;
     constructors: {
-        [EngineNodeType.physical]: PhysicalNodeConstructor;
-        [EngineNodeType.toon]: ToonNodeConstructor;
+        [EngineNodeType.phong]?: PhongNodeConstructor;
+        [EngineNodeType.physical]?: PhysicalNodeConstructor;
+        [EngineNodeType.toon]?: ToonNodeConstructor;
     };
 }
 export type EngineContext = {

package/dist/engine.js

@@ -87,7 +87,7 @@ export var convertToEngine = function (oldEngine, newEngine, graph) {
             if (node.type in newEngine.constructors) {
                 var source = node;
                 nodeUpdates[source.id] = // @ts-ignore
-                    newEngine.constructors[source.type](source.id, source.name, source.groupId, source.position, source.config.uniforms, source.stage, source.nextStageNodeId);
+                    newEngine.constructors[source.type](source.id, source.name, source.position, source.config.uniforms, source.stage);
                 // Bail if no conversion
             }
             else {

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

@@ -9,23 +9,25 @@ export interface NodeInput {
     id: string;
     type: InputType;
     dataType?: GraphDataType;
-    accepts: Set<InputCategory>;
+    accepts: InputCategory[];
     baked?: boolean;
     bakeable: boolean;
     property?: string;
 }
-export declare const nodeInput: (displayName: string, id: string, type: InputType, dataType: GraphDataType | undefined, accepts: Set<InputCategory>, bakeable: boolean, property?: string) => NodeInput;
+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 CoreNode {
+export interface BaseNode {
     id: string;
+    parentId?: string;
     name: string;
     type: string;
     inputs: NodeInput[];

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

@@ -1,7 +1,7 @@
 import { ShaderStage } from './graph-types';
 import { Strategy } from '../strategy';
 import { GraphDataType, UniformDataType } from './data-nodes';
-import { CoreNode, NodeInput } from './base-node';
+import { BaseNode, NodeInput } from './base-node';
 export declare const mapInputName: (node: CodeNode, { id, displayName }: NodeInput) => string;
 export type InputMapping = {
     [original: string]: string;
@@ -25,19 +25,17 @@ 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",
-    SHADER_FRAGMENT = "Shader Fragment"
+    FN_BODY_FRAGMENT = "Function Body Fragment"
 }
-export interface CodeNode extends CoreNode {
+export interface CodeNode extends BaseNode {
     config: NodeConfig;
+    engine: boolean;
     source: string;
     sourceType?: SourceType;
-    stage: ShaderStage | undefined;
+    stage?: ShaderStage;
     biStage?: boolean;
-    groupId: string | null | undefined;
-    nextStageNodeId?: string;
-    prevStageNodeId?: string;
     originalEngine?: string;
 }
 export interface BinaryNode extends CodeNode {

package/dist/graph/code-nodes.js

@@ -12,7 +12,7 @@ export var property = function (displayName, property, type, fillerName, default
 }); };
 export var SourceType;
 (function (SourceType) {
+    SourceType["SHADER_PROGRAM"] = "Shader Program";
     SourceType["EXPRESSION"] = "Expression";
     SourceType["FN_BODY_FRAGMENT"] = "Function Body Fragment";
-    SourceType["SHADER_FRAGMENT"] = "Shader Fragment";
 })(SourceType || (SourceType = {}));

package/dist/graph/context.d.ts

@@ -1,3 +1,4 @@
+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';
@@ -17,19 +18,20 @@ export type NodeContext = {
     inputFillers: InputFillers;
     errors?: NodeErrors;
 };
-type NodeErrors = {
+export type NodeErrors = {
     type: 'errors';
-    errors: any[];
+    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 | Record<string, NodeContext>>;
+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<void>;
-export {};
+export declare const computeGraphContext: (engineContext: EngineContext, engine: Engine, graph: Graph) => Promise<NodeErrors>;

package/dist/graph/context.js

@@ -73,19 +73,22 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import groupBy from 'lodash.groupby';
 import { mapInputName, SourceType } from './code-nodes';
 import { NodeType } from './graph-types';
-import { collectConnectedNodes, filterGraphFromNode, isSourceNode, mangleEntireProgram, } from './graph';
+import { collectConnectedNodes, filterGraphFromNode, findLinkedNode, findLinkedVertexNodes, isSourceNode, mangleEntireProgram, } from './graph';
 import { coreParsers } from './parsers';
-var makeError = function () {
+var makeError = function (nodeId) {
     var errors = [];
-    for (var _i = 0; _i < arguments.length; _i++) {
-        errors[_i] = arguments[_i];
+    for (var _i = 1; _i < arguments.length; _i++) {
+        errors[_i - 1] = arguments[_i];
     }
     return ({
         type: 'errors',
+        nodeId: nodeId,
         errors: errors,
     });
 };
-var isError = function (test) { return (test === null || test === void 0 ? void 0 : test.type) === '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
@@ -94,17 +97,14 @@ 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, onBeforeCompile, manipulateAst, groupId_1, sibling, inputEdges, ast, dataInputs, computedInputs, nodeContext;
+    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];
-                groupId_1 = node.groupId;
-                sibling = graph.nodes.find(function (n) {
-                    return n !== node && 'groupId' in n && n.groupId === groupId_1;
-                });
                 return [4 /*yield*/, onBeforeCompile(graph, engineContext, node, sibling)];
             case 1:
                 _a.sent();
@@ -114,19 +114,19 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                 try {
                     ast = parser.produceAst(engineContext, engine, graph, node, inputEdges);
                     if (manipulateAst) {
-                        ast = manipulateAst(engineContext, engine, graph, node, ast, inputEdges);
+                        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(error)];
+                    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, node, ast, inputEdges);
+                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) }));
@@ -150,7 +150,7 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                 if (node.config.mangle !== false &&
                     node.sourceType !== SourceType.EXPRESSION &&
                     node.sourceType !== SourceType.FN_BODY_FRAGMENT) {
-                    mangleEntireProgram(ast, node, engine);
+                    mangleEntireProgram(engine, ast, node, findLinkedNode(graph, node.id));
                 }
                 return [2 /*return*/, nodeContext];
         }
@@ -161,7 +161,7 @@ export var computeContextForNodes = function (engineContext, engine, graph, node
         return [2 /*return*/, nodes
                 .filter(isSourceNode)
                 .reduce(function (ctx, node) { return __awaiter(void 0, void 0, void 0, function () {
-                var context, nodeContext;
+                var context, nodeContextOrError;
                 return __generator(this, function (_a) {
                     switch (_a.label) {
                         case 0: return [4 /*yield*/, ctx];
@@ -172,11 +172,11 @@ export var computeContextForNodes = function (engineContext, engine, graph, node
                             }
                             return [4 /*yield*/, computeNodeContext(engineContext, engine, graph, node)];
                         case 2:
-                            nodeContext = _a.sent();
-                            if (isError(nodeContext)) {
-                                return [2 /*return*/, makeError(nodeContext)];
+                            nodeContextOrError = _a.sent();
+                            if (isError(nodeContextOrError)) {
+                                return [2 /*return*/, nodeContextOrError];
                             }
-                            context[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContext);
+                            context[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContextOrError);
                             return [2 /*return*/, context];
                     }
                 });
@@ -187,13 +187,26 @@ 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 computeContextForNodes(engineContext, engine, graph, graph.nodes); };
+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, additionalIds;
+    var outputFrag, outputVert, vertexIds, fragmentIds, unlinkedNodes, vertNodesOrError, fragNodesOrError;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
@@ -207,23 +220,23 @@ export var computeGraphContext = function (engineContext, engine, graph) { retur
                 }
                 vertexIds = collectConnectedNodes(graph, outputVert);
                 fragmentIds = collectConnectedNodes(graph, outputFrag);
-                additionalIds = graph.nodes.filter(function (node) {
-                    return isSourceNode(node) &&
-                        node.stage === 'vertex' &&
-                        node.nextStageNodeId &&
-                        fragmentIds[node.nextStageNodeId] &&
-                        !vertexIds[node.id];
-                });
+                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(additionalIds), false))];
+                    ], __read(Object.values(vertexIds).filter(function (node) { return node.id !== outputVert.id; })), false), __read(unlinkedNodes), false))];
             case 1:
-                _a.sent();
+                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:
-                _a.sent();
+                fragNodesOrError = _a.sent();
+                if (isError(fragNodesOrError)) {
+                    return [2 /*return*/, fragNodesOrError];
+                }
                 return [2 /*return*/];
         }
     });

package/dist/graph/data-nodes.d.ts

@@ -1,10 +1,10 @@
-import { CoreNode, NodeInput, NodeOutput, NodePosition } from './base-node';
+import { BaseNode, NodeInput, NodeOutput, NodePosition } from './base-node';
 type ArrayType = 'array';
 type Vector = 'vector2' | 'vector3' | 'vector4';
 type Color = 'rgb' | 'rgba';
 type Mat = 'mat2' | 'mat3' | 'mat4' | 'mat2x2' | 'mat2x3' | 'mat2x4' | 'mat3x2' | 'mat3x3' | 'mat3x4' | 'mat4x2' | 'mat4x3' | 'mat4x4';
 export type GraphDataType = Vector | Color | Mat | 'texture' | 'samplerCube' | 'number' | ArrayType;
-export interface NumberNode extends CoreNode {
+export interface NumberNode extends BaseNode {
     type: 'number';
     value: string;
     range?: [number, number];
@@ -16,24 +16,24 @@ export declare const numberNode: (id: string, name: string, position: NodePositi
     inputs?: NodeInput[];
     outputs?: NodeOutput[];
 }) => NumberNode;
-export type NumberDataUniform = Omit<NumberNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export type NumberDataUniform = Pick<NumberNode, 'type' | 'value' | 'name' | 'range' | 'stepper'>;
 export declare const numberUniformData: (name: string, value: string, range?: [number, number], stepper?: number) => NumberDataUniform;
-export interface TextureNode extends CoreNode {
+export interface TextureNode extends BaseNode {
     type: 'texture';
-    value: string;
+    value: string | number;
 }
-export declare const textureNode: (id: string, name: string, position: NodePosition, value: string) => TextureNode;
-export type TextureDataUniform = Omit<TextureNode, 'id' | 'inputs' | 'outputs' | 'position'>;
-export declare const textureUniformData: (name: string, value: string) => TextureDataUniform;
-export interface SamplerCubeNode extends CoreNode {
+export declare const textureNode: (id: string, name: string, position: NodePosition, value: string | number) => TextureNode;
+export type TextureDataUniform = Pick<TextureNode, 'type' | 'value' | 'name'>;
+export declare const textureUniformData: (name: string, value: string | number) => TextureDataUniform;
+export interface SamplerCubeNode extends BaseNode {
     type: 'samplerCube';
     value: string;
 }
 export declare const samplerCubeNode: (id: string, name: string, position: NodePosition, value: string) => SamplerCubeNode;
-export type SamplerCubeDataUniform = Omit<SamplerCubeNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export type SamplerCubeDataUniform = Pick<SamplerCubeNode, 'type' | 'value' | 'name'>;
 export declare const samplerCubeUniformData: (name: string, value: string) => SamplerCubeDataUniform;
 export type ArrayValue = string[];
-export interface ArrayNode extends CoreNode {
+export interface ArrayNode extends BaseNode {
     type: 'array';
     dimensions: number;
     value: ArrayValue;
@@ -42,41 +42,41 @@ export declare function arrayNode(id: string, name: string, position: NodePositi
 export type Vector2 = [string, string];
 export type Vector3 = [string, string, string];
 export type Vector4 = [string, string, string, string];
-export interface Vector2Node extends CoreNode {
+export interface Vector2Node extends BaseNode {
     type: 'vector2';
     dimensions: 2;
     value: Vector2;
 }
-export interface Vector3Node extends CoreNode {
+export interface Vector3Node extends BaseNode {
     type: 'vector3';
     dimensions: 3;
     value: Vector3;
 }
-export interface Vector4Node extends CoreNode {
+export interface Vector4Node extends BaseNode {
     type: 'vector4';
     dimensions: 4;
     value: Vector4;
 }
 export declare function vectorNode(id: string, name: string, position: NodePosition, value: Vector2 | Vector3 | Vector4): Vector2Node | Vector3Node | Vector4Node;
-export type ArrayDataUniform = Omit<ArrayNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export type ArrayDataUniform = Pick<ArrayNode, 'type' | 'value' | 'name' | 'dimensions'>;
 export declare const arrayUniformData: (name: string, value: ArrayValue) => ArrayDataUniform;
-export type Vector2DataUniform = Omit<Vector2Node, 'id' | 'inputs' | 'outputs' | 'position'>;
-export type Vector3DataUniform = Omit<Vector3Node, 'id' | 'inputs' | 'outputs' | 'position'>;
-export type Vector4DataUniform = Omit<Vector4Node, 'id' | 'inputs' | 'outputs' | 'position'>;
+export type Vector2DataUniform = Pick<Vector2Node, 'type' | 'value' | 'name' | 'dimensions'>;
+export type Vector3DataUniform = Pick<Vector3Node, 'type' | 'value' | 'name' | 'dimensions'>;
+export type Vector4DataUniform = Pick<Vector4Node, 'type' | 'value' | 'name' | 'dimensions'>;
 export declare const vectorUniformData: (name: string, value: Vector2 | Vector3 | Vector4) => Vector2DataUniform | Vector3DataUniform | Vector4DataUniform;
-export interface RgbNode extends CoreNode {
+export interface RgbNode extends BaseNode {
     type: 'rgb';
     dimensions: 3;
     value: Vector3;
 }
-export interface RgbaNode extends CoreNode {
+export interface RgbaNode extends BaseNode {
     type: 'rgba';
     dimensions: 4;
     value: Vector4;
 }
 export declare function colorNode(id: string, name: string, position: NodePosition, value: Vector3 | Vector4): RgbNode | RgbaNode;
-export type RgbDataUniform = Omit<RgbNode, 'id' | 'inputs' | 'outputs' | 'position'>;
-export type RgbaDataUniform = Omit<RgbaNode, 'id' | 'inputs' | 'outputs' | 'position'>;
+export type RgbDataUniform = Omit<RgbNode, 'id' | 'inputs' | 'outputs' | 'position' | 'parentId'>;
+export type RgbaDataUniform = Omit<RgbaNode, 'id' | 'inputs' | 'outputs' | 'position' | 'parentId'>;
 export declare const colorUniformData: (name: string, value: Vector3 | Vector4) => RgbDataUniform | RgbaDataUniform;
 export type UniformDataType = TextureDataUniform | SamplerCubeDataUniform | NumberDataUniform | Vector2DataUniform | Vector3DataUniform | Vector4DataUniform | RgbDataUniform | RgbaDataUniform;
 export type DataNode = TextureNode | SamplerCubeNode | NumberNode | Vector2Node | Vector3Node | Vector4Node | ArrayNode | RgbNode | RgbaNode;

package/dist/graph/data-nodes.js

@@ -20,6 +20,7 @@ export var numberNode = function (id, name, position, value, optionals) { return
         {
             name: 'float',
             id: '1',
+            dataType: 'number',
             category: 'data',
         },
     ],
@@ -44,6 +45,7 @@ export var textureNode = function (id, name, position, value) { return ({
         {
             name: 'texture',
             id: '1',
+            dataType: 'vector4',
             category: 'data',
         },
     ],
@@ -60,6 +62,7 @@ export var samplerCubeNode = function (id, name, position, value) { return ({
         {
             name: 'samplerCube',
             id: '1',
+            dataType: 'vector4',
             category: 'data',
         },
     ],
@@ -75,6 +78,7 @@ export function arrayNode(id, name, position, value) {
             {
                 name: 'array',
                 id: '1',
+                dataType: 'array',
                 category: 'data',
             },
         ],
@@ -84,11 +88,13 @@ export function arrayNode(id, name, position, value) {
     };
 }
 export function vectorNode(id, name, position, value) {
+    var dataType = value.length === 2 ? 'vector2' : value.length === 3 ? 'vector3' : 'vector4';
     return __assign({ id: id, name: name, position: position, inputs: [], outputs: [
             {
                 name: "vector".concat(value.length),
                 id: '1',
                 category: 'data',
+                dataType: dataType,
             },
         ] }, (value.length === 2
         ? { value: value, dimensions: 2, type: 'vector2' }
@@ -108,10 +114,12 @@ export var vectorUniformData = function (name, value) { return (__assign({ name:
         ? { value: value, dimensions: 3, type: 'vector3' }
         : { value: value, dimensions: 4, type: 'vector4' }))); };
 export function colorNode(id, name, position, value) {
+    var dataType = value.length === 3 ? 'rgb' : 'rgba';
     return __assign({ id: id, name: name, position: position, inputs: [], outputs: [
             {
-                name: value.length === 3 ? 'rgb' : 'rgba',
+                name: dataType,
                 id: '1',
+                dataType: dataType,
                 category: 'data',
             },
         ] }, (value.length === 3

package/dist/graph/edge.d.ts

@@ -1,6 +1,6 @@
-import { ShaderStage } from './graph-types';
+import { EdgeLink, ShaderStage } from './graph-types';
 import { GraphDataType } from './data-nodes';
-export type EdgeType = ShaderStage | GraphDataType;
+export type EdgeType = ShaderStage | GraphDataType | EdgeLink;
 export type Edge = {
     id: string;
     from: string;
@@ -10,3 +10,4 @@ export type Edge = {
     type?: EdgeType;
 };
 export declare const makeEdge: (id: string, from: string, to: string, output: string, input: string, type?: EdgeType) => Edge;
+export declare const linkFromVertToFrag: (id: string, vertId: string, fragId: string) => Edge;

package/dist/graph/edge.js

@@ -1 +1,7 @@
+import { EdgeLink, LinkHandle } from './graph-types';
 export var makeEdge = function (id, from, to, output, input, type) { return ({ id: id, from: from, to: to, output: output, input: input, type: type }); };
+export var linkFromVertToFrag = function (id, vertId, fragId) {
+    return makeEdge(id, vertId, fragId, LinkHandle.NEXT_STAGE, // output from next_stage
+    LinkHandle.PREVIOUS_STAGE, // input to previous_stage
+    EdgeLink.NEXT_STAGE);
+};

package/dist/graph/{engine-node.d.ts → graph-node.d.ts}

@@ -1,15 +1,8 @@
 import { ShaderStage } from './graph-types';
 import { BinaryNode, CodeNode, NodeConfig } from './code-nodes';
 import { NodePosition } from './base-node';
-/**
- * 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 declare const sourceNode: (id: string, name: string, position: NodePosition, config: NodeConfig, source: string, stage: ShaderStage, originalEngine?: string, nextStageNodeId?: string) => CodeNode;
+export declare const sourceNode: (id: string, name: string, position: NodePosition, config: NodeConfig, source: string, stage: ShaderStage, originalEngine?: string) => CodeNode;
 export declare const outputNode: (id: string, name: string, position: NodePosition, stage: ShaderStage) => CodeNode;
 export declare const expressionNode: (id: string, name: string, position: NodePosition, source: string) => CodeNode;
-export declare const phongNode: (id: string, name: string, groupId: string, position: NodePosition, stage: ShaderStage, nextStageNodeId?: string) => CodeNode;
 export declare const addNode: (id: string, position: NodePosition) => BinaryNode;
 export declare const multiplyNode: (id: string, position: NodePosition) => BinaryNode;