@shaderfrog/core 1.1.1 → 1.2.0

package/engine.js

@@ -1,3 +1,4 @@
+"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -34,12 +35,17 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import preprocess from '@shaderfrog/glsl-parser/preprocessor';
-import { generate, parser } from '@shaderfrog/glsl-parser';
-import { NodeType } from './graph/graph-types';
-import groupBy from 'lodash.groupby';
-import { collectNodeProperties } from './graph/graph';
-import { evaluateNode } from './graph/evaluate';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.collectInitialEvaluatedGraphProperties = exports.convertToEngine = exports.convertNode = exports.EngineNodeType = void 0;
+var preprocessor_1 = __importDefault(require("@shaderfrog/glsl-parser/preprocessor"));
+var glsl_parser_1 = require("@shaderfrog/glsl-parser");
+var graph_types_1 = require("./graph/graph-types");
+var lodash_groupby_1 = __importDefault(require("lodash.groupby"));
+var graph_1 = require("./graph/graph");
+var evaluate_1 = require("./graph/evaluate");
 var log = function () {
     var _a;
     var args = [];
@@ -48,37 +54,38 @@ var log = function () {
     }
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[32m(core)\x1b[0m'], __read(args), false));
 };
-export var EngineNodeType;
+var EngineNodeType;
 (function (EngineNodeType) {
     EngineNodeType["toon"] = "toon";
     EngineNodeType["phong"] = "phong";
     EngineNodeType["physical"] = "physical";
     EngineNodeType["shader"] = "shader";
     EngineNodeType["binary"] = "binary";
-})(EngineNodeType || (EngineNodeType = {}));
+})(EngineNodeType = exports.EngineNodeType || (exports.EngineNodeType = {}));
 // type EdgeUpdates = { [edgeId: string]: { oldInput: string; newInput: string } };
-export var convertNode = function (node, converter) {
+var convertNode = function (node, converter) {
     log("Converting ".concat(node.name, " (").concat(node.id, ")"));
-    var preprocessed = preprocess(node.source, {
+    var preprocessed = (0, preprocessor_1.default)(node.source, {
         preserveComments: true,
         preserve: {
             version: function () { return true; },
             define: function () { return true; },
         },
     });
-    var ast = parser.parse(preprocessed);
+    var ast = glsl_parser_1.parser.parse(preprocessed);
     converter.convertAst(ast, node.stage);
-    var source = generate(ast);
+    var source = (0, glsl_parser_1.generate)(ast);
     return __assign(__assign({}, node), { source: source });
 };
-export var convertToEngine = function (oldEngine, newEngine, graph) {
+exports.convertNode = convertNode;
+var convertToEngine = function (oldEngine, newEngine, graph) {
     var converter = newEngine.importers[oldEngine.name];
     if (!converter) {
         throw new Error("The engine ".concat(newEngine.name, " has no importer for ").concat(oldEngine.name));
     }
     log("Attempting to convert from ".concat(newEngine.name, " to ").concat(oldEngine.name));
     // const edgeUpdates: EdgeUpdates = {};
-    var edgesByNodeId = groupBy(graph.edges, 'to');
+    var edgesByNodeId = (0, lodash_groupby_1.default)(graph.edges, 'to');
     var edgeUpdates = {};
     var nodeUpdates = {};
     graph.nodes.forEach(function (node) {
@@ -94,8 +101,8 @@ export var convertToEngine = function (oldEngine, newEngine, graph) {
                 throw new Error("Can't convert ".concat(oldEngine.name, " to ").concat(newEngine.name, " because ").concat(newEngine.name, " does not have a \"").concat(node.type, "\" constructor"));
             }
         }
-        else if (NodeType.SOURCE === node.type) {
-            nodeUpdates[node.id] = convertNode(node, converter);
+        else if (graph_types_1.NodeType.SOURCE === node.type) {
+            nodeUpdates[node.id] = (0, exports.convertNode)(node, converter);
         }
         // Then update input edges. We only care about engine nodes
         if (node.type in converter.nodeInputMap) {
@@ -140,6 +147,7 @@ export var convertToEngine = function (oldEngine, newEngine, graph) {
     log('Created converted graph', graph);
     return graph;
 };
+exports.convertToEngine = convertToEngine;
 /**
  * Create the initial engine node properties for a plugin to create its initial
  * material with. This finds all engine nodes in the graph, finds all their
@@ -152,11 +160,11 @@ export var convertToEngine = function (oldEngine, newEngine, graph) {
  * to be set to a pc.Texture() at runtime, otherwise there's an error about
  * vertex_texCoord0.
  */
-export var collectInitialEvaluatedGraphProperties = function (engine, graph, defaultPropertySetting) {
+var collectInitialEvaluatedGraphProperties = function (engine, graph, defaultPropertySetting) {
     var graphProperties = {};
     // Get all the nodes with properties, meaning engine nodes, and the inputs
     // for each property (property is like "diffuseMap").
-    var _a = collectNodeProperties(graph), nodes = _a.nodes, inputs = _a.inputs;
+    var _a = (0, graph_1.collectNodeProperties)(graph), nodes = _a.nodes, inputs = _a.inputs;
     Object.entries(inputs).forEach(function (_a) {
         var _b = __read(_a, 2), nodeId = _b[0], nodeInputs = _b[1];
         // For every node with properties... There might be mulitple if there are
@@ -194,7 +202,7 @@ export var collectInitialEvaluatedGraphProperties = function (engine, graph, def
                 }
                 else {
                     try {
-                        graphProperties[input.property] = evaluateNode(engine, graph, fromNode);
+                        graphProperties[input.property] = (0, evaluate_1.evaluateNode)(engine, graph, fromNode);
                     }
                     catch (err) {
                         console.error('Tried to evaluate a non-data node!', {
@@ -207,3 +215,4 @@ export var collectInitialEvaluatedGraphProperties = function (engine, graph, def
     });
     return graphProperties;
 };
+exports.collectInitialEvaluatedGraphProperties = collectInitialEvaluatedGraphProperties;

package/graph/base-node.js

@@ -1,4 +1,7 @@
-export var nodeInput = function (displayName, id, type, dataType, accepts, bakeable, property) { return ({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.nodeInput = void 0;
+var nodeInput = function (displayName, id, type, dataType, accepts, bakeable, property) { return ({
     displayName: displayName,
     id: id,
     type: type,
@@ -7,3 +10,4 @@ export var nodeInput = function (displayName, id, type, dataType, accepts, bakea
     bakeable: bakeable,
     property: property,
 }); };
+exports.nodeInput = nodeInput;

package/graph/code-nodes.js

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

package/graph/context.js

@@ -1,3 +1,4 @@
+"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -70,11 +71,16 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
-import groupBy from 'lodash.groupby';
-import { mapInputName, SourceType } from './code-nodes';
-import { NodeType } from './graph-types';
-import { collectConnectedNodes, filterGraphFromNode, findLinkedNode, findLinkedVertexNodes, isSourceNode, mangleEntireProgram, } from './graph';
-import { coreParsers } from './parsers';
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.computeGraphContext = exports.computeAllContexts = exports.computeContextForNodes = exports.isError = void 0;
+var lodash_groupby_1 = __importDefault(require("lodash.groupby"));
+var code_nodes_1 = require("./code-nodes");
+var graph_types_1 = require("./graph-types");
+var graph_1 = require("./graph");
+var parsers_1 = require("./parsers");
 var makeError = function (nodeId) {
     var errors = [];
     for (var _i = 1; _i < arguments.length; _i++) {
@@ -86,23 +92,24 @@ var makeError = function (nodeId) {
         errors: errors,
     });
 };
-export var isError = function (test) {
+var isError = function (test) {
     return (test === null || test === void 0 ? void 0 : test.type) === 'errors';
 };
+exports.isError = isError;
 // Merge existing node inputs, and inputs based on properties, with new ones
 // found from the source code, using the *id* as the uniqueness key. Any filler input gets
 // merged into property inputs with the same id. This preserves the
 // "baked" property on node inputs which is toggle-able in the graph
 var collapseNodeInputs = function (node, updatedInputs) {
-    return Object.values(groupBy(__spreadArray(__spreadArray([], __read(updatedInputs), false), __read(node.inputs), false), function (i) { return i.id; })).map(function (dupes) { return dupes.reduce(function (node, dupe) { return (__assign(__assign({}, node), dupe)); }); });
+    return Object.values((0, lodash_groupby_1.default)(__spreadArray(__spreadArray([], __read(updatedInputs), false), __read(node.inputs), false), function (i) { return i.id; })).map(function (dupes) { return dupes.reduce(function (node, dupe) { return (__assign(__assign({}, node), dupe)); }); });
 };
 var computeNodeContext = function (engineContext, engine, graph, node) { return __awaiter(void 0, void 0, void 0, function () {
     var parser, sibling, onBeforeCompile, manipulateAst, inputEdges, ast, dataInputs, computedInputs, nodeContext;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                parser = __assign(__assign({}, (coreParsers[node.type] || coreParsers[NodeType.SOURCE])), (engine.parsers[node.type] || {}));
-                sibling = findLinkedNode(graph, node.id);
+                parser = __assign(__assign({}, (parsers_1.coreParsers[node.type] || parsers_1.coreParsers[graph_types_1.NodeType.SOURCE])), (engine.parsers[node.type] || {}));
+                sibling = (0, graph_1.findLinkedNode)(graph, node.id);
                 onBeforeCompile = parser.onBeforeCompile, manipulateAst = parser.manipulateAst;
                 if (!onBeforeCompile) return [3 /*break*/, 2];
                 return [4 /*yield*/, onBeforeCompile(graph, engineContext, node, sibling)];
@@ -121,7 +128,7 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                     console.error('Error parsing source code!', { error: error, node: node });
                     return [2 /*return*/, makeError(node.id, error)];
                 }
-                dataInputs = groupBy(filterGraphFromNode(graph, node, {
+                dataInputs = (0, lodash_groupby_1.default)((0, graph_1.filterGraphFromNode)(graph, node, {
                     input: function (input, b, c, fromNode) {
                         return input.bakeable && (fromNode === null || fromNode === void 0 ? void 0 : fromNode.type) === 'source';
                     },
@@ -129,7 +136,7 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                 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) }));
+                    return (__assign(__assign({}, i), { displayName: (0, code_nodes_1.mapInputName)(node, i) }));
                 })).map(function (input) { return (__assign(__assign({}, input), (input.id in dataInputs ? { baked: true } : {}))); });
                 nodeContext = {
                     ast: ast,
@@ -148,18 +155,18 @@ var computeNodeContext = function (engineContext, engine, graph, node) { return
                 // an expression, where we want to be in the context of other variables
                 // TODO: Use global undefined engine variables here?
                 if (node.config.mangle !== false &&
-                    node.sourceType !== SourceType.EXPRESSION &&
-                    node.sourceType !== SourceType.FN_BODY_FRAGMENT) {
-                    mangleEntireProgram(engine, ast, node, findLinkedNode(graph, node.id));
+                    node.sourceType !== code_nodes_1.SourceType.EXPRESSION &&
+                    node.sourceType !== code_nodes_1.SourceType.FN_BODY_FRAGMENT) {
+                    (0, graph_1.mangleEntireProgram)(engine, ast, node, (0, graph_1.findLinkedNode)(graph, node.id));
                 }
                 return [2 /*return*/, nodeContext];
         }
     });
 }); };
-export var computeContextForNodes = function (engineContext, engine, graph, nodes) { return __awaiter(void 0, void 0, void 0, function () {
+var computeContextForNodes = function (engineContext, engine, graph, nodes) { return __awaiter(void 0, void 0, void 0, function () {
     return __generator(this, function (_a) {
         return [2 /*return*/, nodes
-                .filter(isSourceNode)
+                .filter(graph_1.isSourceNode)
                 .reduce(function (ctx, node) { return __awaiter(void 0, void 0, void 0, function () {
                 var context, nodeContextOrError;
                 return __generator(this, function (_a) {
@@ -167,13 +174,13 @@ export var computeContextForNodes = function (engineContext, engine, graph, node
                         case 0: return [4 /*yield*/, ctx];
                         case 1:
                             context = _a.sent();
-                            if (isError(context)) {
+                            if ((0, exports.isError)(context)) {
                                 return [2 /*return*/, context];
                             }
                             return [4 /*yield*/, computeNodeContext(engineContext, engine, graph, node)];
                         case 2:
                             nodeContextOrError = _a.sent();
-                            if (isError(nodeContextOrError)) {
+                            if ((0, exports.isError)(nodeContextOrError)) {
                                 return [2 /*return*/, nodeContextOrError];
                             }
                             context[node.id] = __assign(__assign({}, (context[node.id] || {})), nodeContextOrError);
@@ -183,29 +190,31 @@ export var computeContextForNodes = function (engineContext, engine, graph, node
             }); }, Promise.resolve(engineContext.nodes))];
     });
 }); };
+exports.computeContextForNodes = computeContextForNodes;
 /**
  * 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 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 0: return [4 /*yield*/, (0, exports.computeContextForNodes)(engineContext, engine, graph, graph.nodes)];
             case 1:
                 result = _a.sent();
-                if (isError(result)) {
+                if ((0, exports.isError)(result)) {
                     return [2 /*return*/, result];
                 }
                 return [2 /*return*/];
         }
     });
 }); };
+exports.computeAllContexts = computeAllContexts;
 /**
  * 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 computeGraphContext = function (engineContext, engine, graph) { return __awaiter(void 0, void 0, void 0, function () {
     var outputFrag, outputVert, vertexIds, fragmentIds, unlinkedNodes, vertNodesOrError, fragNodesOrError;
     return __generator(this, function (_a) {
         switch (_a.label) {
@@ -218,26 +227,27 @@ 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);
-                return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, __spreadArray(__spreadArray([
+                vertexIds = (0, graph_1.collectConnectedNodes)(graph, outputVert);
+                fragmentIds = (0, graph_1.collectConnectedNodes)(graph, outputFrag);
+                unlinkedNodes = (0, graph_1.findLinkedVertexNodes)(graph, vertexIds);
+                return [4 /*yield*/, (0, exports.computeContextForNodes)(engineContext, engine, graph, __spreadArray(__spreadArray([
                         outputVert
                     ], __read(Object.values(vertexIds).filter(function (node) { return node.id !== outputVert.id; })), false), __read(unlinkedNodes), false))];
             case 1:
                 vertNodesOrError = _a.sent();
-                if (isError(vertNodesOrError)) {
+                if ((0, exports.isError)(vertNodesOrError)) {
                     return [2 /*return*/, vertNodesOrError];
                 }
-                return [4 /*yield*/, computeContextForNodes(engineContext, engine, graph, __spreadArray([
+                return [4 /*yield*/, (0, exports.computeContextForNodes)(engineContext, engine, graph, __spreadArray([
                         outputFrag
                     ], __read(Object.values(fragmentIds).filter(function (node) { return node.id !== outputFrag.id; })), false))];
             case 2:
                 fragNodesOrError = _a.sent();
-                if (isError(fragNodesOrError)) {
+                if ((0, exports.isError)(fragNodesOrError)) {
                     return [2 /*return*/, fragNodesOrError];
                 }
                 return [2 /*return*/];
         }
     });
 }); };
+exports.computeGraphContext = computeGraphContext;

package/graph/data-nodes.js

@@ -1,3 +1,4 @@
+"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -9,7 +10,9 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
-export var numberNode = function (id, name, position, value, optionals) { return ({
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.colorUniformData = exports.colorNode = exports.vectorUniformData = exports.arrayUniformData = exports.vectorNode = exports.arrayNode = exports.samplerCubeUniformData = exports.samplerCubeNode = exports.textureUniformData = exports.textureNode = exports.numberUniformData = exports.numberNode = void 0;
+var numberNode = function (id, name, position, value, optionals) { return ({
     type: 'number',
     id: id,
     name: name,
@@ -27,14 +30,16 @@ export var numberNode = function (id, name, position, value, optionals) { return
     range: optionals === null || optionals === void 0 ? void 0 : optionals.range,
     stepper: optionals === null || optionals === void 0 ? void 0 : optionals.stepper,
 }); };
-export var numberUniformData = function (name, value, range, stepper) { return ({
+exports.numberNode = numberNode;
+var numberUniformData = function (name, value, range, stepper) { return ({
     type: 'number',
     name: name,
     value: value,
     range: range,
     stepper: stepper,
 }); };
-export var textureNode = function (id, name, position, value) { return ({
+exports.numberUniformData = numberUniformData;
+var textureNode = function (id, name, position, value) { return ({
     type: 'texture',
     id: id,
     name: name,
@@ -50,8 +55,10 @@ export var textureNode = function (id, name, position, value) { return ({
         },
     ],
 }); };
-export var textureUniformData = function (name, value) { return ({ type: 'texture', name: name, value: value }); };
-export var samplerCubeNode = function (id, name, position, value) { return ({
+exports.textureNode = textureNode;
+var textureUniformData = function (name, value) { return ({ type: 'texture', name: name, value: value }); };
+exports.textureUniformData = textureUniformData;
+var samplerCubeNode = function (id, name, position, value) { return ({
     type: 'samplerCube',
     id: id,
     name: name,
@@ -67,8 +74,10 @@ export var samplerCubeNode = function (id, name, position, value) { return ({
         },
     ],
 }); };
-export var samplerCubeUniformData = function (name, value) { return ({ type: 'samplerCube', name: name, value: value }); };
-export function arrayNode(id, name, position, value) {
+exports.samplerCubeNode = samplerCubeNode;
+var samplerCubeUniformData = function (name, value) { return ({ type: 'samplerCube', name: name, value: value }); };
+exports.samplerCubeUniformData = samplerCubeUniformData;
+function arrayNode(id, name, position, value) {
     return {
         id: id,
         name: name,
@@ -87,7 +96,8 @@ export function arrayNode(id, name, position, value) {
         type: 'array',
     };
 }
-export function vectorNode(id, name, position, value) {
+exports.arrayNode = arrayNode;
+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: [
             {
@@ -102,18 +112,21 @@ export function vectorNode(id, name, position, value) {
             ? { value: value, dimensions: 3, type: 'vector3' }
             : { value: value, dimensions: 4, type: 'vector4' }));
 }
-export var arrayUniformData = function (name, value) { return ({
+exports.vectorNode = vectorNode;
+var arrayUniformData = function (name, value) { return ({
     name: name,
     value: value,
     dimensions: value.length,
     type: 'array',
 }); };
-export var vectorUniformData = function (name, value) { return (__assign({ name: name }, (value.length === 2
+exports.arrayUniformData = arrayUniformData;
+var vectorUniformData = function (name, value) { return (__assign({ name: name }, (value.length === 2
     ? { value: value, dimensions: 2, type: 'vector2' }
     : value.length === 3
         ? { value: value, dimensions: 3, type: 'vector3' }
         : { value: value, dimensions: 4, type: 'vector4' }))); };
-export function colorNode(id, name, position, value) {
+exports.vectorUniformData = vectorUniformData;
+function colorNode(id, name, position, value) {
     var dataType = value.length === 3 ? 'rgb' : 'rgba';
     return __assign({ id: id, name: name, position: position, inputs: [], outputs: [
             {
@@ -126,6 +139,8 @@ export function colorNode(id, name, position, value) {
         ? { value: value, dimensions: 3, type: 'rgb' }
         : { value: value, dimensions: 4, type: 'rgba' }));
 }
-export var colorUniformData = function (name, value) { return (__assign({ name: name }, (value.length === 3
+exports.colorNode = colorNode;
+var colorUniformData = function (name, value) { return (__assign({ name: name }, (value.length === 3
     ? { value: value, dimensions: 3, type: 'rgb' }
     : { value: value, dimensions: 4, type: 'rgba' }))); };
+exports.colorUniformData = colorUniformData;

package/graph/edge.js

@@ -1,7 +1,12 @@
-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);
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.linkFromVertToFrag = exports.makeEdge = void 0;
+var graph_types_1 = require("./graph-types");
+var makeEdge = function (id, from, to, output, input, type) { return ({ id: id, from: from, to: to, output: output, input: input, type: type }); };
+exports.makeEdge = makeEdge;
+var linkFromVertToFrag = function (id, vertId, fragId) {
+    return (0, exports.makeEdge)(id, vertId, fragId, graph_types_1.LinkHandle.NEXT_STAGE, // output from next_stage
+    graph_types_1.LinkHandle.PREVIOUS_STAGE, // input to previous_stage
+    graph_types_1.EdgeLink.NEXT_STAGE);
 };
+exports.linkFromVertToFrag = linkFromVertToFrag;

package/graph/evaluate.js

@@ -1,5 +1,8 @@
-import { coreParsers } from './parsers';
-export var toGlsl = function (node) {
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.evaluateNode = exports.toGlsl = void 0;
+var parsers_1 = require("./parsers");
+var toGlsl = function (node) {
     var type = node.type, value = node.value;
     if (type === 'vector2') {
         return "vec2(".concat(value[0], ", ").concat(value[1], ")");
@@ -12,16 +15,18 @@ export var toGlsl = function (node) {
     }
     throw new Error("Unknown GLSL inline type: \"".concat(node.type, "\""));
 };
-export var evaluateNode = function (engine, graph, node) {
+exports.toGlsl = toGlsl;
+var evaluateNode = function (engine, graph, node) {
     // TODO: Data nodes themselves should have evaluators
     if ('value' in node) {
         return engine.evaluateNode(node);
     }
-    var evaluate = coreParsers[node.type].evaluate;
+    var evaluate = parsers_1.coreParsers[node.type].evaluate;
     if (!evaluate) {
         throw new Error("No evaluator for node ".concat(node.name, " (type: ").concat(node.type, ", id: ").concat(node.id, ")"));
     }
     var inputEdges = graph.edges.filter(function (edge) { return edge.to === node.id; });
     var inputNodes = inputEdges.map(function (edge) { return graph.nodes.find(function (node) { return node.id === edge.from; }); });
-    return evaluate(node, inputEdges, inputNodes, evaluateNode.bind(null, engine, graph));
+    return evaluate(node, inputEdges, inputNodes, exports.evaluateNode.bind(null, engine, graph));
 };
+exports.evaluateNode = evaluateNode;

package/graph/graph-node.js

@@ -1,11 +1,14 @@
-import { NodeType } from './graph-types';
-import { assignemntToStrategy, variableStrategy } from '../strategy';
-import { SourceType } from './code-nodes';
-export var sourceNode = function (id, name, position, config, source, stage, originalEngine) { return ({
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.multiplyNode = exports.addNode = exports.expressionNode = exports.outputNode = exports.sourceNode = void 0;
+var graph_types_1 = require("./graph-types");
+var strategy_1 = require("../strategy");
+var code_nodes_1 = require("./code-nodes");
+var sourceNode = function (id, name, position, config, source, stage, originalEngine) { return ({
     id: id,
     name: name,
-    type: NodeType.SOURCE,
-    sourceType: SourceType.SHADER_PROGRAM,
+    type: graph_types_1.NodeType.SOURCE,
+    sourceType: code_nodes_1.SourceType.SHADER_PROGRAM,
     engine: false,
     config: config,
     position: position,
@@ -22,12 +25,13 @@ export var sourceNode = function (id, name, position, config, source, stage, ori
     stage: stage,
     originalEngine: originalEngine,
 }); };
-export var outputNode = function (id, name, position, stage) { return ({
+exports.sourceNode = sourceNode;
+var outputNode = function (id, name, position, stage) { return ({
     id: id,
     name: name,
     position: position,
-    type: NodeType.OUTPUT,
-    sourceType: SourceType.SHADER_PROGRAM,
+    type: graph_types_1.NodeType.OUTPUT,
+    sourceType: code_nodes_1.SourceType.SHADER_PROGRAM,
     engine: false,
     config: {
         version: 3,
@@ -42,7 +46,7 @@ export var outputNode = function (id, name, position, stage) { return ({
                 filler_gl_Position: 'Position',
             },
         strategies: [
-            assignemntToStrategy(stage === 'fragment' ? 'frogFragOut' : 'gl_Position'),
+            (0, strategy_1.assignemntToStrategy)(stage === 'fragment' ? 'frogFragOut' : 'gl_Position'),
         ],
     },
     inputs: [],
@@ -54,20 +58,21 @@ export var outputNode = function (id, name, position, stage) { return ({
             "\n#version 300 es\nprecision highp float;\n\nvoid main() {\n  gl_Position = vec4(1.0);\n}\n",
     stage: stage,
 }); };
-export var expressionNode = function (id, name, position, source) { return ({
+exports.outputNode = outputNode;
+var expressionNode = function (id, name, position, source) { return ({
     id: id,
     name: name,
     position: position,
-    type: NodeType.SOURCE,
+    type: graph_types_1.NodeType.SOURCE,
     engine: false,
-    sourceType: SourceType.EXPRESSION,
+    sourceType: code_nodes_1.SourceType.EXPRESSION,
     stage: undefined,
     config: {
         uniforms: [],
         version: 3,
         preprocess: false,
         inputMapping: {},
-        strategies: [variableStrategy()],
+        strategies: [(0, strategy_1.variableStrategy)()],
     },
     inputs: [],
     outputs: [
@@ -79,11 +84,12 @@ export var expressionNode = function (id, name, position, source) { return ({
     ],
     source: source,
 }); };
-export var addNode = function (id, position) { return ({
+exports.expressionNode = expressionNode;
+var addNode = function (id, position) { return ({
     id: id,
     name: 'add',
     position: position,
-    type: NodeType.BINARY,
+    type: graph_types_1.NodeType.BINARY,
     engine: false,
     stage: undefined,
     config: {
@@ -103,13 +109,14 @@ export var addNode = function (id, position) { return ({
     ],
     source: "a + b",
     operator: '+',
-    sourceType: SourceType.EXPRESSION,
+    sourceType: code_nodes_1.SourceType.EXPRESSION,
     biStage: true,
 }); };
-export var multiplyNode = function (id, position) { return ({
+exports.addNode = addNode;
+var multiplyNode = function (id, position) { return ({
     id: id,
     name: 'multiply',
-    type: NodeType.BINARY,
+    type: graph_types_1.NodeType.BINARY,
     engine: false,
     stage: undefined,
     position: position,
@@ -130,6 +137,7 @@ export var multiplyNode = function (id, position) { return ({
     ],
     source: "a * b",
     operator: '*',
-    sourceType: SourceType.EXPRESSION,
+    sourceType: code_nodes_1.SourceType.EXPRESSION,
     biStage: true,
 }); };
+exports.multiplyNode = multiplyNode;