@shaderfrog/core 1.3.0 → 1.3.2

package/cjs/graph/graph.test.js

@@ -1,173 +0,0 @@
-"use strict";
-var __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-var util_1 = __importDefault(require("util"));
-var glsl_parser_1 = require("@shaderfrog/glsl-parser");
-var glsl_parser_2 = require("@shaderfrog/glsl-parser");
-var graph_node_1 = require("./graph-node");
-var shader_sections_1 = require("./shader-sections");
-var data_nodes_1 = require("./data-nodes");
-var edge_1 = require("./edge");
-var evaluate_1 = require("./evaluate");
-var inspect = function (thing) {
-    return console.log(util_1.default.inspect(thing, false, null, true));
-};
-var mergeBlocks = function (ast1, ast2) {
-    var s1 = (0, shader_sections_1.findShaderSections)(ast1);
-    var s2 = (0, shader_sections_1.findShaderSections)(ast2);
-    var merged = (0, shader_sections_1.mergeShaderSections)(s1, s2);
-    return (0, glsl_parser_2.generate)((0, shader_sections_1.shaderSectionsToProgram)(merged, {
-        includePrecisions: true,
-        includeVersion: true,
-    }));
-};
-var dedupe = function (code) {
-    return (0, glsl_parser_2.generate)((0, shader_sections_1.shaderSectionsToProgram)((0, shader_sections_1.findShaderSections)(glsl_parser_1.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',
-    engine: true,
-    type: '',
-    inputs: [],
-    outputs: [],
-    position: { x: 0, y: 0 },
-    source: '',
-    stage: undefined,
-}); };
-var engine = {
-    name: 'three',
-    displayName: 'Three.js',
-    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 = (0, graph_node_1.addNode)(id(), p);
-        var add2 = (0, graph_node_1.addNode)(id(), p);
-        var num1 = (0, data_nodes_1.numberNode)(id(), 'number', p, '3');
-        var num2 = (0, data_nodes_1.numberNode)(id(), 'number', p, '5');
-        var num3 = (0, data_nodes_1.numberNode)(id(), 'number', p, '7');
-        var graph = {
-            nodes: [num1, num2, num3, finalAdd, add2],
-            edges: [
-                (0, edge_1.makeEdge)(id(), num1.id, finalAdd.id, 'out', 'a'),
-                (0, edge_1.makeEdge)(id(), add2.id, finalAdd.id, 'out', 'b'),
-                (0, edge_1.makeEdge)(id(), num2.id, add2.id, 'out', 'a'),
-                (0, edge_1.makeEdge)(id(), num3.id, add2.id, 'out', 'b'),
-            ],
-        };
-        expect((0, evaluate_1.evaluateNode)(engine, graph, finalAdd)).toBe(15);
-    });
-});
-it('should merge uniforms with interface blocks', function () {
-    var astX = glsl_parser_1.parser.parse("uniform vec2 x;");
-    var astY = glsl_parser_1.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 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
-    var astL02 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", { quiet: true });
-    expect(mergeBlocks(astL01, astL02)).toEqual("uniform Light0 { vec4 y; } x;\n");
-    var astL001 = glsl_parser_1.parser.parse("uniform Light0 { vec4 y; } x;", {
-        quiet: true,
-    });
-    var astL002 = glsl_parser_1.parser.parse("uniform Light0 x;", { quiet: true });
-    expect(mergeBlocks(astL001, astL002)).toEqual("uniform Light0 { vec4 y; } x;\n");
-    var astLo01 = glsl_parser_1.parser.parse("uniform Light0 x;", { quiet: true });
-    var astLo02 = glsl_parser_1.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 = glsl_parser_1.parser.parse("uniform vec2 y[5];");
-    var vec2Arr2 = glsl_parser_1.parser.parse("uniform vec2 y[10];");
-    expect(mergeBlocks(vec2Arr1, vec2Arr2)).toEqual("uniform vec2 y[10];\n");
-    var block1 = glsl_parser_1.parser.parse("uniform Scene { mat4 view; };");
-    var block2 = glsl_parser_1.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/cjs/graph/index.js

@@ -1,27 +0,0 @@
-"use strict";
-var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    var desc = Object.getOwnPropertyDescriptor(m, k);
-    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
-      desc = { enumerable: true, get: function() { return m[k]; } };
-    }
-    Object.defineProperty(o, k2, desc);
-}) : (function(o, m, k, k2) {
-    if (k2 === undefined) k2 = k;
-    o[k2] = m[k];
-}));
-var __exportStar = (this && this.__exportStar) || function(m, exports) {
-    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
-};
-Object.defineProperty(exports, "__esModule", { value: true });
-__exportStar(require("./base-node"), exports);
-__exportStar(require("./data-nodes"), exports);
-__exportStar(require("./graph-node"), exports);
-__exportStar(require("./code-nodes"), exports);
-__exportStar(require("./edge"), exports);
-__exportStar(require("./parsers"), exports);
-__exportStar(require("./context"), exports);
-__exportStar(require("./evaluate"), exports);
-__exportStar(require("./graph-types"), exports);
-__exportStar(require("./graph"), exports);
-__exportStar(require("./shader-sections"), exports);

package/cjs/graph/parsers.js

@@ -1,219 +0,0 @@
-"use strict";
-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 __importDefault = (this && this.__importDefault) || function (mod) {
-    return (mod && mod.__esModule) ? mod : { "default": mod };
-};
-var _a;
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.coreParsers = exports.alphabet = void 0;
-var glsl_parser_1 = require("@shaderfrog/glsl-parser");
-var ast_1 = require("@shaderfrog/glsl-parser/ast");
-var preprocessor_1 = __importDefault(require("@shaderfrog/glsl-parser/preprocessor"));
-var ast_2 = require("../util/ast");
-var strategy_1 = require("../strategy");
-var code_nodes_1 = require("./code-nodes");
-var base_node_1 = require("./base-node");
-var graph_types_1 = require("./graph-types");
-var graph_1 = require("./graph");
-var ast_3 = require("../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));
-};
-exports.alphabet = 'abcdefghijklmnopqrstuvwxyz';
-exports.coreParsers = (_a = {},
-    _a[graph_types_1.NodeType.SOURCE] = {
-        produceAst: function (engineContext, engine, graph, node, inputEdges) {
-            var ast;
-            // @ts-ignore
-            if (node.expressionOnly) {
-                node.sourceType = code_nodes_1.SourceType.EXPRESSION;
-                // @ts-ignore
-                delete node.expressionOnly;
-            }
-            if (node.sourceType === code_nodes_1.SourceType.FN_BODY_FRAGMENT) {
-                var _a = (0, ast_2.makeFnBodyStatementWithScopes)(node.source), statements = _a.statements, scope = _a.scope;
-                ast = {
-                    type: 'program',
-                    scopes: [scope],
-                    // @ts-ignore
-                    program: statements,
-                };
-            }
-            else if (node.sourceType === code_nodes_1.SourceType.EXPRESSION) {
-                var _b = (0, ast_2.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
-                    : (0, preprocessor_1.default)(node.source, {
-                        preserve: {
-                            version: function () { return true; },
-                        },
-                    });
-                ast = glsl_parser_1.parser.parse(preprocessed);
-                if (node.config.version === 2 && node.stage) {
-                    (0, ast_2.from2To3)(ast, node.stage);
-                    log('converted ', node, 'to version 3', {
-                        code: (0, glsl_parser_1.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') {
-                    (0, ast_2.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 (0, strategy_1.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 === code_nodes_1.SourceType.EXPRESSION
-                ? ast.program[0]
-                : node.sourceType === code_nodes_1.SourceType.FN_BODY_FRAGMENT
-                    ? ast.program
-                    : (0, ast_2.makeExpression)("".concat((0, graph_1.nodeName)(node), "()"));
-        },
-    },
-    // TODO: Output node assumes strategies are still passed in on node creation,
-    // which might be a little awkward for graph creators?
-    _a[graph_types_1.NodeType.OUTPUT] = {
-        produceAst: function (engineContext, engine, graph, node, inputEdges) {
-            return glsl_parser_1.parser.parse(node.source);
-        },
-        findInputs: function (engineContext, ast, edges, node, sibling) {
-            return __spreadArray(__spreadArray([], __read(node.config.strategies.flatMap(function (strategy) {
-                return (0, strategy_1.applyStrategy)(strategy, ast, node, sibling);
-            })), false), [
-                [
-                    (0, base_node_1.nodeInput)(graph_types_1.MAGIC_OUTPUT_STMTS, "filler_".concat(graph_types_1.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((0, ast_2.makeFnStatement)((0, ast_3.generateFiller)(fillerAst)));
-                        return ast;
-                    },
-                ],
-            ], false);
-        },
-        produceFiller: function (node, ast) {
-            return (0, ast_2.makeExpression)('impossible_call()');
-        },
-    },
-    _a[graph_types_1.NodeType.BINARY] = {
-        produceAst: function (engineContext, engine, graph, iNode, inputEdges) {
-            var node = iNode;
-            return (0, ast_2.makeExpression)('(' +
-                (inputEdges.length
-                    ? inputEdges
-                        .map(function (_, index) { return exports.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 = exports.alphabet.charAt(index);
-                return [
-                    (0, base_node_1.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;
-                                    }
-                                },
-                            },
-                        };
-                        (0, ast_1.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);