@shaderfrog/core 0.0.2 → 0.1.1

package/dist/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 './ast/manipulate';
+import { applyStrategy } from './strategy';
+import { SourceType } from './nodes/code-nodes';
+import { nodeInput } from './nodes/core-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, node, ast) {
+            var seen = new Set();
+            return node.config.strategies
+                .flatMap(function (strategy) { return applyStrategy(strategy, node, ast); })
+                .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, node, ast) {
+            return __spreadArray(__spreadArray([], __read(node.config.strategies.flatMap(function (strategy) {
+                return applyStrategy(strategy, node, ast);
+            })), false), [
+                [
+                    nodeInput(MAGIC_OUTPUT_STMTS, "filler_".concat(MAGIC_OUTPUT_STMTS), 'filler', 'rgba', new Set(['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, node, ast, inputEdges) {
+            return new Array(Math.max(inputEdges.length + 1, 2))
+                .fill(0)
+                .map(function (_, index) {
+                var letter = alphabet.charAt(index);
+                return [
+                    nodeInput(letter, letter, 'filler', undefined, new Set(['data', 'code']), false),
+                    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);