@shaderfrog/core 1.2.0 → 1.3.0

package/esm/graph/index.d.ts

@@ -0,0 +1,11 @@
+export * from './base-node';
+export * from './data-nodes';
+export * from './graph-node';
+export * from './code-nodes';
+export * from './edge';
+export * from './parsers';
+export * from './context';
+export * from './evaluate';
+export * from './graph-types';
+export * from './graph';
+export * from './shader-sections';

package/esm/graph/index.js

@@ -0,0 +1,11 @@
+export * from './base-node';
+export * from './data-nodes';
+export * from './graph-node';
+export * from './code-nodes';
+export * from './edge';
+export * from './parsers';
+export * from './context';
+export * from './evaluate';
+export * from './graph-types';
+export * from './graph';
+export * from './shader-sections';

package/esm/graph/parsers.d.ts

@@ -0,0 +1,39 @@
+import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
+import { Engine, EngineContext } from '../engine';
+import { Edge } from './edge';
+import { SourceNode } from './code-nodes';
+import { NodeInput } from './base-node';
+import { Graph } from './graph-types';
+import { Evaluate } from './evaluate';
+export declare const alphabet = "abcdefghijklmnopqrstuvwxyz";
+export type Filler = AstNode | AstNode[] | void;
+export type InputFiller = (filler: Filler) => AstNode | Program;
+export type InputFillerGroup = {
+    filler: InputFiller;
+    backfillArgs?: AstNode[];
+};
+export type InputFillers = Record<string, InputFillerGroup>;
+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, 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, ast: Program | AstNode, inputEdges: Edge[], node: SourceNode, sibling: SourceNode) => ComputedInput[];
+export type ProduceNodeFiller = (node: SourceNode, ast: Program | AstNode) => Filler;
+type CoreNodeParser = {
+    produceAst: ProduceAst;
+    findInputs: FindInputs;
+    produceFiller: ProduceNodeFiller;
+    evaluate?: Evaluate;
+};
+type CoreParser = {
+    [key: string]: CoreNodeParser;
+};
+export declare const coreParsers: CoreParser;
+export {};

package/esm/graph/parsers.js

@@ -0,0 +1,213 @@
+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));
+};
+var _a;
+import { generate, parser } from '@shaderfrog/glsl-parser';
+import { visit, } from '@shaderfrog/glsl-parser/ast';
+import preprocess from '@shaderfrog/glsl-parser/preprocessor';
+import { convert300MainToReturn, from2To3, makeExpression, makeExpressionWithScopes, makeFnBodyStatementWithScopes, makeFnStatement, } from '../util/ast';
+import { applyStrategy } from '../strategy';
+import { SourceType } from './code-nodes';
+import { nodeInput } from './base-node';
+import { MAGIC_OUTPUT_STMTS, NodeType } from './graph-types';
+import { nodeName } from './graph';
+import { generateFiller } from '../util/ast';
+/*
+ * Core graph parsers, which is the plumbing/interface the graph and context
+ * calls into, to parse, find inputs, etc, and define this per-node type.
+ */
+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.parsers)\x1b[0m'], __read(args), false));
+};
+export var alphabet = 'abcdefghijklmnopqrstuvwxyz';
+export var coreParsers = (_a = {},
+    _a[NodeType.SOURCE] = {
+        produceAst: function (engineContext, engine, graph, node, inputEdges) {
+            var ast;
+            // @ts-ignore
+            if (node.expressionOnly) {
+                node.sourceType = SourceType.EXPRESSION;
+                // @ts-ignore
+                delete node.expressionOnly;
+            }
+            if (node.sourceType === SourceType.FN_BODY_FRAGMENT) {
+                var _a = makeFnBodyStatementWithScopes(node.source), statements = _a.statements, scope = _a.scope;
+                ast = {
+                    type: 'program',
+                    scopes: [scope],
+                    // @ts-ignore
+                    program: statements,
+                };
+            }
+            else if (node.sourceType === SourceType.EXPRESSION) {
+                var _b = makeExpressionWithScopes(node.source), expression = _b.expression, scope = _b.scope;
+                ast = {
+                    type: 'program',
+                    scopes: [scope],
+                    // @ts-ignore
+                    program: [expression],
+                };
+            }
+            else {
+                var preprocessed = node.config.preprocess === false
+                    ? node.source
+                    : preprocess(node.source, {
+                        preserve: {
+                            version: function () { return true; },
+                        },
+                    });
+                ast = parser.parse(preprocessed);
+                if (node.config.version === 2 && node.stage) {
+                    from2To3(ast, node.stage);
+                    log('converted ', node, 'to version 3', {
+                        code: generate(ast),
+                    });
+                }
+                // This assumes that expressionOnly nodes don't have a stage and that all
+                // fragment source code shades have main function, which is probably wrong
+                if (node.stage === 'fragment') {
+                    convert300MainToReturn(node.id, ast);
+                }
+            }
+            return ast;
+        },
+        findInputs: function (engineContext, ast, edges, node, sibling) {
+            var seen = new Set();
+            return node.config.strategies
+                .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)) {
+                    seen.add(input.id);
+                    return true;
+                }
+                return false;
+            });
+        },
+        produceFiller: function (node, ast) {
+            return node.sourceType === SourceType.EXPRESSION
+                ? ast.program[0]
+                : node.sourceType === SourceType.FN_BODY_FRAGMENT
+                    ? ast.program
+                    : makeExpression("".concat(nodeName(node), "()"));
+        },
+    },
+    // TODO: Output node assumes strategies are still passed in on node creation,
+    // which might be a little awkward for graph creators?
+    _a[NodeType.OUTPUT] = {
+        produceAst: function (engineContext, engine, graph, node, inputEdges) {
+            return parser.parse(node.source);
+        },
+        findInputs: function (engineContext, ast, edges, node, sibling) {
+            return __spreadArray(__spreadArray([], __read(node.config.strategies.flatMap(function (strategy) {
+                return applyStrategy(strategy, ast, node, sibling);
+            })), 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)));
+                        return ast;
+                    },
+                ],
+            ], false);
+        },
+        produceFiller: function (node, ast) {
+            return makeExpression('impossible_call()');
+        },
+    },
+    _a[NodeType.BINARY] = {
+        produceAst: function (engineContext, engine, graph, iNode, inputEdges) {
+            var node = iNode;
+            return makeExpression('(' +
+                (inputEdges.length
+                    ? inputEdges
+                        .map(function (_, index) { return alphabet.charAt(index); })
+                        .join(" ".concat(node.operator, " "))
+                    : "a ".concat(node.operator, " b")) +
+                ')');
+        },
+        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, ['data', 'code'], false),
+                    function (fillerAst) {
+                        var foundPath;
+                        var visitors = {
+                            identifier: {
+                                enter: function (path) {
+                                    if (path.node.identifier === letter) {
+                                        foundPath = path;
+                                    }
+                                },
+                            },
+                        };
+                        visit(ast, visitors);
+                        if (!foundPath) {
+                            throw new Error("Im drunk and I think this case is impossible, no \"".concat(letter, "\" found in binary node?"));
+                        }
+                        if (foundPath.parent && foundPath.key) {
+                            // @ts-ignore
+                            foundPath.parent[foundPath.key] = fillerAst;
+                            return ast;
+                        }
+                        else {
+                            return fillerAst;
+                        }
+                    },
+                ];
+            });
+        },
+        produceFiller: function (node, ast) {
+            return ast;
+        },
+        evaluate: function (node, inputEdges, inputNodes, evaluateNode) {
+            var operator = node.operator;
+            return inputNodes.map(evaluateNode).reduce(function (num, next) {
+                if (operator === '+') {
+                    return num + next;
+                }
+                else if (operator === '*') {
+                    return num * next;
+                }
+                else if (operator === '-') {
+                    return num - next;
+                }
+                else if (operator === '/') {
+                    return num / next;
+                }
+                throw new Error("Don't know how to evaluate ".concat(operator, " for node ").concat(node.name, " (").concat(node.id, ")"));
+            });
+        },
+    },
+    _a);

package/esm/graph/shader-sections.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Categorizing / deduping parts of shaders to help merge them together
+ */
+import { AstNode, DeclarationStatementNode, PreprocessorNode } from '@shaderfrog/glsl-parser/ast';
+import { Program } from '@shaderfrog/glsl-parser/ast';
+export interface ShaderSections {
+    precision: DeclarationStatementNode[];
+    version: AstNode[];
+    preprocessor: PreprocessorNode[];
+    structs: AstNode[];
+    inStatements: DeclarationStatementNode[];
+    outStatements: DeclarationStatementNode[];
+    uniforms: DeclarationStatementNode[];
+    program: AstNode[];
+}
+export declare const emptyShaderSections: () => ShaderSections;
+declare enum Precision {
+    highp = 2,
+    mediump = 1,
+    lowp = 0
+}
+export declare const higherPrecision: (p1: Precision, p2: Precision) => Precision;
+export declare const dedupeVersions: (nodes: AstNode[]) => AstNode;
+export declare const highestPrecisions: (nodes: DeclarationStatementNode[]) => DeclarationStatementNode[];
+export declare const dedupeQualifiedStatements: (statements: DeclarationStatementNode[], qualifier: string) => any;
+/**
+ * Merge uniforms together into lists of identifiers under the same type.
+ * There's special case handling for mixing of uniforms with "interface blocks"
+ * and those without when merging to make sure the interface block definition is
+ * preserved. Check out the tests for more.
+ *
+ * This function consumes uniforms as found by findShaderSections, so the
+ * definitions must line up
+ */
+export declare const dedupeUniforms: (statements: DeclarationStatementNode[]) => any;
+export declare const mergeShaderSections: (s1: ShaderSections, s2: ShaderSections) => ShaderSections;
+export type MergeOptions = {
+    includePrecisions: boolean;
+    includeVersion: boolean;
+};
+export declare const shaderSectionsToProgram: (sections: ShaderSections, mergeOptions: MergeOptions) => Program;
+/**
+ * Group an AST into logical sections. The output of this funciton is consumed
+ * by the dedupe methods, namely dedupeUniforms, so the data shapes are coupled
+ */
+export declare const findShaderSections: (ast: Program) => ShaderSections;
+export {};

package/esm/graph/shader-sections.js

@@ -0,0 +1,256 @@
+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 { generate } from '@shaderfrog/glsl-parser';
+import { makeStatement } from '../util/ast';
+export var emptyShaderSections = function () { return ({
+    precision: [],
+    preprocessor: [],
+    version: [],
+    structs: [],
+    program: [],
+    inStatements: [],
+    outStatements: [],
+    uniforms: [],
+}); };
+var Precision;
+(function (Precision) {
+    Precision[Precision["highp"] = 2] = "highp";
+    Precision[Precision["mediump"] = 1] = "mediump";
+    Precision[Precision["lowp"] = 0] = "lowp";
+})(Precision || (Precision = {}));
+export var higherPrecision = function (p1, p2) {
+    return Precision[p1] > Precision[p2] ? p1 : p2;
+};
+export var dedupeVersions = function (nodes) { return nodes[0]; };
+export var highestPrecisions = function (nodes) {
+    return Object.entries(nodes.reduce(function (precisions, stmt) {
+        var _a;
+        return (__assign(__assign({}, precisions), (_a = {}, _a[stmt.declaration.specifier.specifier.token] = higherPrecision(precisions[stmt.declaration.specifier.specifier.token], stmt.declaration.qualifier.token), _a)));
+    }, {})).map(function (_a) {
+        var _b = __read(_a, 2), typeName = _b[0], precision = _b[1];
+        return makeStatement("precision ".concat(precision, " ").concat(typeName));
+    });
+};
+export var dedupeQualifiedStatements = function (statements, qualifier) {
+    return Object.entries(statements.reduce(function (stmts, stmt) {
+        var _a;
+        return (__assign(__assign({}, stmts), (_a = {}, _a[stmt.declaration.specified_type.specifier.specifier.token] = __assign(__assign({}, (stmts[stmt.declaration.specified_type.specifier.specifier.token] || {})), stmt.declaration.declarations.reduce(function (types, decl) {
+            var _a;
+            return (__assign(__assign({}, types), (_a = {}, _a[decl.identifier.identifier] = true, _a)));
+        }, {})), _a)));
+    }, {})).map(function (_a) {
+        var _b = __read(_a, 2), type = _b[0], varNames = _b[1];
+        return makeStatement("".concat(qualifier, " ").concat(type, " ").concat(Object.keys(varNames).join(', ')));
+    });
+};
+/**
+ * Merge uniforms together into lists of identifiers under the same type.
+ * There's special case handling for mixing of uniforms with "interface blocks"
+ * and those without when merging to make sure the interface block definition is
+ * preserved. Check out the tests for more.
+ *
+ * This function consumes uniforms as found by findShaderSections, so the
+ * definitions must line up
+ */
+export var dedupeUniforms = function (statements) {
+    var groupedByTypeName = Object.entries(statements.reduce(function (stmts, stmt) {
+        var _a, _b, _c;
+        var _d;
+        var decl = stmt.declaration;
+        // This is the standard case, a uniform like "uniform vec2 x"
+        if ('specified_type' in decl) {
+            var specified_type = decl.specified_type;
+            var specifier = specified_type.specifier.specifier;
+            // Token is for "vec2", "identifier" is for custom names like struct
+            var type_1 = 'token' in specifier
+                ? specifier.token
+                : 'identifier' in specifier
+                    ? specifier.identifier
+                    : undefined;
+            if (!type_1) {
+                console.error('Unknown statement: ', stmt);
+                throw new Error("Unknown specifier: ".concat(specifier.type));
+            }
+            // Groups uniforms into their return type, and for each type, collapses
+            // uniform names into an object where the keys determine uniqueness
+            // "vec2": { x: x[1] }
+            var grouped = decl.declarations.reduce(function (types, decl) {
+                var _a;
+                var _b, _c, _d;
+                var identifier = decl.identifier;
+                var quantifier = '';
+                if (decl.quantifier) {
+                    if (!('token' in decl.quantifier[0].expression)) {
+                        console.error('Unknown expression in quantifier: ', decl);
+                        throw new Error("Unknown expression in quantifier: ".concat(generate(decl)));
+                    }
+                    quantifier = "[".concat(decl.quantifier[0].expression.token, "]");
+                }
+                return __assign(__assign({}, types), (_a = {}, _a[identifier.identifier] = ((_c = (_b = stmts[type_1]) === null || _b === void 0 ? void 0 : _b[identifier.identifier]) === null || _c === void 0 ? void 0 : _c.hasInterface)
+                    ? (_d = stmts[type_1]) === null || _d === void 0 ? void 0 : _d[identifier.identifier]
+                    : {
+                        hasInterface: false,
+                        generated: identifier.identifier + quantifier,
+                    }, _a));
+            }, {});
+            return __assign(__assign({}, stmts), (_a = {}, _a[type_1] = __assign(__assign({}, (stmts[type_1] || {})), grouped), _a));
+            // This is the less common case, a uniform like "uniform Light { vec3 position; } name"
+        }
+        else if ('interface_type' in decl) {
+            var interface_type = decl.interface_type, identifier = decl.identifier;
+            // If this is an interface block only, like uniform Scene { mat4 view; };
+            // then group the interface block declaration under ''
+            var interfaceDeclaredUniform = ((_d = identifier === null || identifier === void 0 ? void 0 : identifier.identifier) === null || _d === void 0 ? void 0 : _d.identifier) || '';
+            var node = {
+                type: 'interface_declarator',
+                lp: decl.lp,
+                declarations: decl.declarations,
+                qualifiers: [],
+                // This is non-nullable, to produce "X" in "uniform X { ... } varName"
+                // But it appears "X" is in declarations above
+                interface_type: {
+                    type: 'identifier',
+                    identifier: '',
+                    whitespace: '',
+                },
+                rp: decl.rp,
+            };
+            return __assign(__assign({}, stmts), (_b = {}, _b[interface_type.identifier] = (_c = {},
+                _c[interfaceDeclaredUniform] = {
+                    generated: "".concat(generate(node)).concat(interfaceDeclaredUniform),
+                    hasInterface: true,
+                },
+                _c), _b));
+        }
+        else {
+            console.error('Unknown uniform AST', { stmt: stmt, code: generate(stmt) });
+            throw new Error('Unknown uniform AST encountered when merging uniforms');
+        }
+    }, {}));
+    return groupedByTypeName.map(function (_a) {
+        var _b = __read(_a, 2), type = _b[0], variables = _b[1];
+        return makeStatement("uniform ".concat(type, " ").concat(Object.values(variables)
+            .map(function (v) { return v.generated; })
+            .join(', ')));
+    });
+};
+export var mergeShaderSections = function (s1, s2) {
+    return {
+        version: __spreadArray(__spreadArray([], __read(s1.version), false), __read(s2.version), false),
+        precision: __spreadArray(__spreadArray([], __read(s1.precision), false), __read(s2.precision), false),
+        preprocessor: __spreadArray(__spreadArray([], __read(s1.preprocessor), false), __read(s2.preprocessor), false),
+        inStatements: __spreadArray(__spreadArray([], __read(s1.inStatements), false), __read(s2.inStatements), false),
+        outStatements: __spreadArray(__spreadArray([], __read(s1.outStatements), false), __read(s2.outStatements), false),
+        structs: __spreadArray(__spreadArray([], __read(s1.structs), false), __read(s2.structs), false),
+        uniforms: __spreadArray(__spreadArray([], __read(s1.uniforms), false), __read(s2.uniforms), false),
+        program: __spreadArray(__spreadArray([], __read(s1.program), false), __read(s2.program), false),
+    };
+};
+export var shaderSectionsToProgram = function (sections, mergeOptions) { return ({
+    type: 'program',
+    scopes: [],
+    program: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((mergeOptions.includeVersion ? [dedupeVersions(sections.version)] : [])), false), __read((mergeOptions.includePrecisions
+        ? highestPrecisions(sections.precision)
+        : [])), false), __read(sections.preprocessor), false), __read(sections.structs), false), __read(dedupeQualifiedStatements(sections.inStatements, 'in')), false), __read(dedupeQualifiedStatements(sections.outStatements, 'out')), false), __read(dedupeUniforms(sections.uniforms)), false), __read(sections.program), false),
+}); };
+/**
+ * Group an AST into logical sections. The output of this funciton is consumed
+ * by the dedupe methods, namely dedupeUniforms, so the data shapes are coupled
+ */
+export var findShaderSections = function (ast) {
+    var initialValue = {
+        precision: [],
+        preprocessor: [],
+        version: [],
+        structs: [],
+        inStatements: [],
+        outStatements: [],
+        uniforms: [],
+        program: [],
+    };
+    return ast.program.reduce(function (sections, node) {
+        var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
+        if (node.type === 'preprocessor' && node.line.startsWith('#version')) {
+            return __assign(__assign({}, sections), { version: sections.version.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            node.declaration.type === 'precision') {
+            return __assign(__assign({}, sections), { precision: sections.precision.concat(node) });
+        }
+        else if (node.type === 'preprocessor') {
+            return __assign(__assign({}, sections), { preprocessor: sections.preprocessor.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            node.declaration.type === 'declarator_list' &&
+            ((_d = (_c = (_b = (_a = node.declaration) === null || _a === void 0 ? void 0 : _a.specified_type) === null || _b === void 0 ? void 0 : _b.specifier) === null || _c === void 0 ? void 0 : _c.specifier) === null || _d === void 0 ? void 0 : _d.type) === 'struct') {
+            return __assign(__assign({}, sections), { structs: sections.structs.concat(node) });
+            // This definition of a uniform lines up with the processing we do in
+            // dedupeUniforms
+        }
+        else if (node.type === 'declaration_statement' &&
+            // Ignore lines like "layout(std140,column_major) uniform;"
+            !('qualifiers' in node.declaration &&
+                ((_f = (_e = node.declaration) === null || _e === void 0 ? void 0 : _e.qualifiers) === null || _f === void 0 ? void 0 : _f.find(function (q) { return 'layout' in q; }))) &&
+            // One of these checks is for a uniform with an interface block, and the
+            // other is for vanilla uniforms. I don't remember which is which
+            (('specified_type' in node.declaration &&
+                'qualifiers' in node.declaration.specified_type &&
+                ((_g = node.declaration.specified_type.qualifiers) === null || _g === void 0 ? void 0 : _g.find(function (n) { return 'token' in n && n.token === 'uniform'; }))) ||
+                ('qualifiers' in node.declaration &&
+                    ((_j = (_h = node.declaration) === null || _h === void 0 ? void 0 : _h.qualifiers) === null || _j === void 0 ? void 0 : _j.find(function (n) { return 'token' in n && n.token === 'uniform'; }))))) {
+            return __assign(__assign({}, sections), { uniforms: sections.uniforms.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            'specified_type' in node.declaration &&
+            ((_m = (_l = (_k = node.declaration) === null || _k === void 0 ? void 0 : _k.specified_type) === null || _l === void 0 ? void 0 : _l.qualifiers) === null || _m === void 0 ? void 0 : _m.find(function (n) { return 'token' in n && n.token === 'in'; }))) {
+            if (generate(node).includes('main_Fireball')) {
+                console.log('findShaderSections\n', generate(ast));
+                console.log("Tracking inStatement \"".concat(generate(node), "\""), node);
+                debugger;
+            }
+            return __assign(__assign({}, sections), { inStatements: sections.inStatements.concat(node) });
+        }
+        else if (node.type === 'declaration_statement' &&
+            'specified_type' in node.declaration &&
+            ((_q = (_p = (_o = node.declaration) === null || _o === void 0 ? void 0 : _o.specified_type) === null || _p === void 0 ? void 0 : _p.qualifiers) === null || _q === void 0 ? void 0 : _q.find(function (n) { return 'token' in n && n.token === 'out'; }))) {
+            return __assign(__assign({}, sections), { outStatements: sections.outStatements.concat(node) });
+        }
+        else {
+            return __assign(__assign({}, sections), { program: sections.program.concat(node) });
+        }
+    }, initialValue);
+};

package/esm/index.d.ts

@@ -0,0 +1,3 @@
+export * from './graph';
+export * from './strategy';
+export * from './engine';

package/esm/index.js

@@ -0,0 +1,3 @@
+export * from './graph';
+export * from './strategy';
+export * from './engine';

package/esm/package.json

@@ -0,0 +1 @@
+{"type": "module"}

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

@@ -0,0 +1,28 @@
+import { PBRMaterial, Camera, Scene } from 'babylonjs';
+import { Engine } from '../../engine';
+import { ShaderStage } from '../../graph/graph-types';
+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, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
+export type RuntimeContext = {
+    scene: Scene;
+    camera: Camera;
+    BABYLON: any;
+    sceneData: any;
+    cache: {
+        data: {
+            [key: string]: any;
+        };
+        nodes: {
+            [id: string]: {
+                fragment: string;
+                vertex: string;
+            };
+        };
+    };
+};
+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;