@shaderfrog/core 0.1.0 → 0.1.1

package/dist/graph.js

@@ -0,0 +1,381 @@
+var __assign = (this && this.__assign) || function () {
+    __assign = Object.assign || function(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p))
+                t[p] = s[p];
+        }
+        return t;
+    };
+    return __assign.apply(this, arguments);
+};
+var __read = (this && this.__read) || function (o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
+    }
+    return ar;
+};
+var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
+    if (pack || arguments.length === 2) for (var i = 0, l = from.length, ar; i < l; i++) {
+        if (ar || !(i in from)) {
+            if (!ar) ar = Array.prototype.slice.call(from, 0, i);
+            ar[i] = from[i];
+        }
+    }
+    return to.concat(ar || Array.prototype.slice.call(from));
+};
+import { renameBindings, renameFunctions, } from '@shaderfrog/glsl-parser/parser/utils';
+import { emptyShaderSections, findShaderSections, mergeShaderSections, } from './ast/shader-sections';
+import { makeExpression } from './ast/manipulate';
+import { ensure } from './util/ensure';
+import { SourceType } from './nodes/code-nodes';
+import { nodeInput } from './nodes/core-node';
+import { makeId } from './util/id';
+import { coreParsers } from './parsers';
+import { toGlsl } from './evaluate';
+import { MAGIC_OUTPUT_STMTS, NodeType } from './graph-types';
+var log = function () {
+    var _a;
+    var args = [];
+    for (var _i = 0; _i < arguments.length; _i++) {
+        args[_i] = arguments[_i];
+    }
+    return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[31m(core.graph)\x1b[0m'], __read(args), false));
+};
+export var isDataNode = function (node) {
+    return 'value' in node;
+};
+export var isSourceNode = function (node) {
+    return !isDataNode(node);
+};
+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; });
+    if (edges.length === 0) {
+        return false;
+    }
+    return edges.reduce(function (foundShader, edge) {
+        var upstreamNode = ensure(graph.nodes.find(function (node) { return node.id === edge.to; }));
+        return (foundShader ||
+            // TODO: LARD this probably will introduce some insidius hard to track
+            // down bug, as I try to pull toon and phong up out of core, I need to
+            // know if a graph links through a "shader" which now means somehting
+            // different... does a config object need isShader? Can we compute it from
+            // inputs/ outputs/source?
+            (upstreamNode.sourceType !== SourceType.EXPRESSION &&
+                upstreamNode.type !== NodeType.OUTPUT) ||
+            doesLinkThruShader(graph, upstreamNode));
+    }, false);
+};
+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;
+    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) {
+    renameBindings(ast.scopes[0], function (name, n) {
+        return n.doNotDescope ? name : mangleVar(name, engine, node);
+    });
+    mangleMainFn(ast, node);
+};
+export var mangleMainFn = function (ast, node) {
+    renameFunctions(ast.scopes[0], function (name) {
+        return name === 'main' ? nodeName(node) : mangleName(name, node);
+    });
+};
+/**
+ * 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
+        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.
+ *
+ * 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) {
+    var _a;
+    if (depth === void 0) { depth = Infinity; }
+    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)
+        ? (_a = {}, _a[node.id] = node, _a) : {}));
+    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 inputAcc = __assign(__assign({}, acc.inputs), (input &&
+            predicates.input &&
+            predicates.input(input, node, inputEdge, fromNode)
+            ? (_a = {}, _a[node.id] = __spreadArray(__spreadArray([], __read((acc.inputs[node.id] || [])), false), [input], false), _a) : {}));
+        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),
+            };
+        }
+        return __assign(__assign({}, acc), { inputs: __assign(__assign({}, acc.inputs), inputAcc) });
+    }, { inputs: {}, nodes: nodeAcc });
+};
+export var collectConnectedNodes = function (graph, node) {
+    return filterGraphFromNode(graph, node, { node: function () { return true; } }).nodes;
+};
+export var filterGraphNodes = function (graph, nodes, filter, depth) {
+    if (depth === void 0) { depth = Infinity; }
+    return nodes.reduce(function (acc, node) {
+        var result = filterGraphFromNode(graph, node, filter, depth);
+        return {
+            nodes: __assign(__assign({}, acc.nodes), result.nodes),
+            inputs: __assign(__assign({}, acc.inputs), result.inputs),
+        };
+    }, {
+        nodes: {},
+        inputs: {},
+    });
+};
+// 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
+// way to know if we're plugging in code or data?
+export var isDataInput = function (input) {
+    return (input.type === 'uniform' || input.type === 'property') && !input.baked;
+};
+export var compileNode = function (engine, graph, edges, engineContext, node, activeIds) {
+    var _a, _b;
+    if (activeIds === void 0) { activeIds = {}; }
+    // THIS DUPLICATES OTHER LINE
+    var parser = __assign(__assign({}, (coreParsers[node.type] || coreParsers[NodeType.SOURCE])), (engine.parsers[node.type] || {}));
+    var inputs = node.inputs;
+    if (!parser) {
+        console.error(node);
+        throw new Error("No parser found for ".concat(node.name, " (").concat(node.type, ", id ").concat(node.id, ")"));
+    }
+    var nodeContext = isDataNode(node)
+        ? null
+        : ensure(engineContext.nodes[node.id], "No node context found for \"".concat(node.name, "\" (id ").concat(node.id, ")!"));
+    var _c = (nodeContext || {}), ast = _c.ast, inputFillers = _c.inputFillers;
+    if (!inputs) {
+        throw new Error("I'm drunk and I think this case should be impossible");
+    }
+    var compiledIds = activeIds;
+    var inputEdges = edges.filter(function (edge) { return edge.to === node.id; });
+    if (inputEdges.length) {
+        var continuation_1 = emptyShaderSections();
+        inputEdges
+            .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) {
+                var id = _a.id;
+                return id;
+            }).join(', '))),
+        }); })
+            .filter(function (_a) {
+            var input = _a.input;
+            return !isDataInput(input);
+        })
+            .forEach(function (_a) {
+            var _b;
+            var fromNode = _a.fromNode, edge = _a.edge, input = _a.input;
+            var _c = __read(compileNode(engine, graph, edges, engineContext, fromNode, activeIds), 3), inputSections = _c[0], fillerAst = _c[1], childIds = _c[2];
+            if (!fillerAst) {
+                throw new TypeError("Expected a filler ast from node ID ".concat(fromNode.id, " (").concat(fromNode.type, ") but none was returned"));
+            }
+            continuation_1 = mergeShaderSections(continuation_1, inputSections);
+            compiledIds = __assign(__assign({}, compiledIds), childIds);
+            var filler;
+            var fillerName;
+            if (nodeContext) {
+                if (input.property) {
+                    fillerName = ensure((_b = (node.config.properties || []).find(function (p) { return p.property === input.property; })) === null || _b === void 0 ? void 0 : _b.fillerName, "Node \"".concat(node.name, "\" has no property named \"").concat(input.property, "\" to find the filler for"));
+                    filler = inputFillers[fillerName];
+                }
+                else {
+                    filler = inputFillers[input.id];
+                }
+                if (!filler) {
+                    console.error('No filler for property', {
+                        input: input,
+                        node: node,
+                        inputFillers: inputFillers,
+                        fillerName: fillerName,
+                    });
+                    throw new Error("Node \"".concat(node.name, "\" has no filler for input \"").concat(input.displayName, "\" named ").concat(fillerName));
+                }
+                /**
+                 *      +------+    +------+
+                 * a -- o add  o -- o tex  |
+                 * b -- o      |    +------+
+                 *      +------+
+                 *
+                 * This could produce:
+                 *     main_a(v1) + main_b(v2)
+                 * I guess it has to? or it could produce
+                 *     function add(v1) { return main_a(v1) + main_b(v2); }
+                 * It can't replace the arg _expression_ in the from shaders, because
+                 * the expression isn't available there.
+                 */
+                // TODO: This is a hard coded hack for vUv backfilling. It works in
+                // the simple case. Doesn't work for hell (based on world position).
+                if (filler.backfillArgs &&
+                    !Array.isArray(fillerAst) &&
+                    fillerAst.type === 'function_call') {
+                    // Object.values(filterGraphFromNode(graph, node, {
+                    //   node: (n) => n.type === 'source'
+                    // }).nodes).forEach(sourceNode => {
+                    if (fromNode.type === 'source') {
+                        // @ts-ignore
+                        fillerAst.args = filler.backfillArgs;
+                        // const fc = engineContext.nodes[sourceNode.id];
+                        var fc = engineContext.nodes[fromNode.id];
+                        var main = Object.values(fc.ast.scopes[0].functions.main)[0].declaration;
+                        main.prototype.parameters = [
+                            'vec2 vv',
+                        ];
+                        // @ts-ignore
+                        var scope = fc.ast.scopes[0];
+                        renameBindings(scope, function (name, node) {
+                            return node.type !== 'declaration' && name === 'vUv'
+                                ? 'vv'
+                                : name;
+                        });
+                    }
+                    // })
+                }
+                // Fill in the input! The return value is the new AST of the filled in
+                // fromNode.
+                nodeContext.ast = filler.filler(fillerAst);
+            }
+            // log(generate(ast.program));
+        });
+        // Order matters here! *Prepend* the input nodes to this one, because
+        // you have to declare functions in order of use in GLSL
+        var sections = mergeShaderSections(continuation_1, isDataNode(node) ||
+            node.sourceType === SourceType.EXPRESSION ||
+            node.sourceType === SourceType.FN_BODY_FRAGMENT
+            ? emptyShaderSections()
+            : findShaderSections(ast));
+        var filler = isDataNode(node)
+            ? makeExpression(toGlsl(node))
+            : parser.produceFiller(node, ast);
+        return [sections, filler, __assign(__assign({}, compiledIds), (_a = {}, _a[node.id] = node, _a))];
+    }
+    else {
+        // TODO: This duplicates the above branch, and also does this mean we
+        // recalculate the shader sections and filler for every edge? Can I move
+        // these lines above the loop?
+        var sections = isDataNode(node) ||
+            node.sourceType === SourceType.EXPRESSION ||
+            node.sourceType === SourceType.FN_BODY_FRAGMENT
+            ? emptyShaderSections()
+            : findShaderSections(ast);
+        var filler = isDataNode(node)
+            ? makeExpression(toGlsl(node))
+            : parser.produceFiller(node, ast);
+        return [sections, filler, __assign(__assign({}, compiledIds), (_b = {}, _b[node.id] = node, _b))];
+    }
+};
+export var compileGraph = function (engineContext, engine, graph) {
+    // computeGraphContext(engineContext, engine, graph);
+    var outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
+    if (!outputFrag) {
+        throw new Error('No fragment output in graph');
+    }
+    var _a = __read(compileNode(engine, graph, graph.edges, engineContext, outputFrag), 3), fragment = _a[0], fragmentIds = _a[2];
+    var outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
+    if (!outputVert) {
+        throw new Error('No vertex output in graph');
+    }
+    var vertexIds = collectConnectedNodes(graph, outputVert);
+    // Some fragment shaders reference vertex shaders which may not have been
+    // 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 orphanEdges = orphanNodes.map(function (node) { return ({
+        id: makeId(),
+        from: node.id,
+        to: outputVert.id,
+        output: 'main',
+        input: "filler_".concat(MAGIC_OUTPUT_STMTS),
+        stage: 'vertex',
+        category: 'code',
+    }); });
+    var _b = __read(compileNode(engine, graph, __spreadArray(__spreadArray([], __read(graph.edges), false), __read(orphanEdges), false), engineContext, outputVert), 2), vertex = _b[0];
+    // Every compileNode returns the AST so far, as well as the filler for the
+    // next node with inputs. On the final step, we discard the filler
+    return {
+        fragment: fragment,
+        vertex: vertex,
+        outputFrag: outputFrag,
+        outputVert: outputVert,
+        orphanNodes: orphanNodes,
+        activeNodeIds: new Set(__spreadArray(__spreadArray(__spreadArray([], __read(Object.keys(vertexIds)), false), __read(Object.keys(fragmentIds)), false), __read(orphanNodes.map(function (node) { return node.id; })), false)),
+    };
+};
+/**
+ * Find engine nodes to set properties on, like find a Physical node so
+ * consumers can set physicalNode.myProperty = 123.
+ *
+ * Finds all active nodes in the graph that have inputs that are properties,
+ * which currently means it will find all active engine nodes.
+ */
+export var collectNodeProperties = function (graph) {
+    var nodesWithProperties = {
+        node: function (node) {
+            var _a;
+            return 'config' in node &&
+                'properties' in node.config &&
+                !!((_a = node.config.properties) === null || _a === void 0 ? void 0 : _a.length);
+        },
+        input: function (input) { return !!input.property; },
+    };
+    var outputFrag = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'fragment'; });
+    var outputVert = graph.nodes.find(function (node) { return node.type === 'output' && node.stage === 'vertex'; });
+    var fragProperties = filterGraphFromNode(graph, outputFrag, nodesWithProperties);
+    var vertProperties = filterGraphFromNode(graph, outputVert, nodesWithProperties);
+    return {
+        nodes: __assign(__assign({}, fragProperties.nodes), vertProperties.nodes),
+        inputs: __assign(__assign({}, fragProperties.inputs), vertProperties.inputs),
+    };
+};

package/dist/graph.test.js

@@ -0,0 +1,168 @@
+import util from 'util';
+import { parser } from '@shaderfrog/glsl-parser';
+import { generate } from '@shaderfrog/glsl-parser';
+import { shaderSectionsToProgram } from './ast/shader-sections';
+import { addNode } from './nodes/engine-node';
+import { mergeShaderSections, findShaderSections } from './ast/shader-sections';
+import { numberNode } from './nodes/data-nodes';
+import { makeEdge } from './nodes/edge';
+import { evaluateNode } from './evaluate';
+var inspect = function (thing) {
+    return console.log(util.inspect(thing, false, null, true));
+};
+var mergeBlocks = function (ast1, ast2) {
+    var s1 = findShaderSections(ast1);
+    var s2 = findShaderSections(ast2);
+    var merged = mergeShaderSections(s1, s2);
+    return generate(shaderSectionsToProgram(merged, {
+        includePrecisions: true,
+        includeVersion: true,
+    }));
+};
+var dedupe = function (code) {
+    return generate(shaderSectionsToProgram(findShaderSections(parser.parse(code)), {
+        includePrecisions: true,
+        includeVersion: true,
+    }));
+};
+var counter = 0;
+var p = { x: 0, y: 0 };
+var id = function () { return '' + counter++; };
+var constructor = function () { return ({
+    config: {
+        version: 3,
+        preprocess: false,
+        strategies: [],
+        uniforms: [],
+    },
+    id: '1',
+    name: '1',
+    type: '',
+    inputs: [],
+    outputs: [],
+    position: { x: 0, y: 0 },
+    source: '',
+    stage: undefined,
+    groupId: null,
+}); };
+var engine = {
+    name: 'three',
+    evaluateNode: function (node) {
+        if (node.type === 'number') {
+            return parseFloat(node.value);
+        }
+        return node.value;
+    },
+    constructors: {
+        physical: constructor,
+        toon: constructor,
+    },
+    mergeOptions: {
+        includePrecisions: true,
+        includeVersion: true,
+    },
+    importers: {},
+    preserve: new Set(),
+    parsers: {},
+};
+// it('graph compiler arbitrary helper test', () => {
+//   const graph: Graph = {
+//     nodes: [
+//       outputNode('0', 'Output v', p, 'vertex'),
+//       outputNode('1', 'Output f', p, 'fragment'),
+//       makeSourceNode(
+//         '2',
+//         `uniform sampler2D image1;
+// uniform sampler2D image2;
+// void main() {
+//   vec3 col = texture2D(image1, posTurn - 0.4 * time).rgb + 1.0;
+//   vec3 col = texture2D(image2, negTurn - 0.4 * time).rgb + 2.0;
+// }
+// `,
+//         'fragment'
+//       ),
+//       makeSourceNode(
+//         '3',
+//         `void main() {
+//     return vec4(0.0);
+// }
+// `,
+//         'fragment'
+//       ),
+//       makeSourceNode(
+//         '4',
+//         `void main() {
+//     return vec4(1.0);
+// }
+// `,
+//         'fragment'
+//       ),
+//     ],
+//     edges: [
+//       makeEdge(id(), '2', '1', 'out', 'filler_frogFragOut', 'fragment'),
+//       makeEdge(id(), '3', '2', 'out', 'filler_image1', 'fragment'),
+//       makeEdge(id(), '4', '2', 'out', 'filler_image2', 'fragment'),
+//     ],
+//   };
+//   const engineContext: EngineContext = {
+//     engine: 'three',
+//     nodes: {},
+//     runtime: {},
+//     debuggingNonsense: {},
+//   };
+//   const result = compileGraph(engineContext, engine, graph);
+//   const built = generate(
+//     shaderSectionsToProgram(result.fragment, {
+//       includePrecisions: true,
+//       includeVersion: true,
+//     }).program
+//   );
+//   expect(built).toBe('hi');
+// });
+describe('evaluateNode()', function () {
+    it('evaluates binary nodes', function () {
+        var finalAdd = addNode(id(), p);
+        var add2 = addNode(id(), p);
+        var num1 = numberNode(id(), 'number', p, '3');
+        var num2 = numberNode(id(), 'number', p, '5');
+        var num3 = numberNode(id(), 'number', p, '7');
+        var graph = {
+            nodes: [num1, num2, num3, finalAdd, add2],
+            edges: [
+                makeEdge(id(), num1.id, finalAdd.id, 'out', 'a'),
+                makeEdge(id(), add2.id, finalAdd.id, 'out', 'b'),
+                makeEdge(id(), num2.id, add2.id, 'out', 'a'),
+                makeEdge(id(), num3.id, add2.id, 'out', 'b'),
+            ],
+        };
+        expect(evaluateNode(engine, graph, finalAdd)).toBe(15);
+    });
+});
+it('should merge uniforms with interface blocks', function () {
+    var astX = parser.parse("uniform vec2 x;");
+    var astY = parser.parse("uniform vec2 y, z;\nuniform vec3 a;");
+    expect(mergeBlocks(astX, astY)).toEqual("uniform vec2 x, y, z;\nuniform vec3 a;\n");
+    var astL01 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    var astL02 = parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
+    expect(mergeBlocks(astL01, astL02)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    var astL001 = parser.parse("uniform Light0 { vec4 y; } x;", {
+        quiet: true,
+    });
+    var astL002 = parser.parse("uniform Light0 x;", { quiet: true });
+    expect(mergeBlocks(astL001, astL002)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    var astLo01 = parser.parse("uniform Light0 x;", { quiet: true });
+    var astLo02 = parser.parse("uniform Light0 { vec4 y; } x;", {
+        quiet: true,
+    });
+    expect(mergeBlocks(astLo01, astLo02)).toEqual("uniform Light0 { vec4 y; } x;\n");
+    // This may be a bug, look at how the uniforms are merged. I at least want to
+    // note its current behavior in this test
+    var vec2Arr1 = parser.parse("uniform vec2 y[5];");
+    var vec2Arr2 = parser.parse("uniform vec2 y[10];");
+    expect(mergeBlocks(vec2Arr1, vec2Arr2)).toEqual("uniform vec2 y[10];\n");
+    var block1 = parser.parse("uniform Scene { mat4 view; };");
+    var block2 = parser.parse("uniform Scene { mat4 view; };");
+    expect(mergeBlocks(block1, block2)).toEqual("uniform Scene { mat4 view; };\n");
+    // Verify these lines are preserved (they go through dedupeUniforms)
+    expect(dedupe("layout(std140,column_major) uniform;")).toEqual("layout(std140,column_major) uniform;");
+});

package/dist/nodes/code-nodes.js

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

package/dist/nodes/core-node.js

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