@shaderfrog/core 0.1.0 → 0.1.1

package/dist/nodes/data-nodes.js

@@ -0,0 +1,123 @@
+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);
+};
+export var numberNode = function (id, name, position, value, optionals) { return ({
+    type: 'number',
+    id: id,
+    name: name,
+    position: position,
+    value: value,
+    inputs: (optionals === null || optionals === void 0 ? void 0 : optionals.inputs) || [],
+    outputs: (optionals === null || optionals === void 0 ? void 0 : optionals.outputs) || [
+        {
+            name: 'float',
+            id: '1',
+            category: 'data',
+        },
+    ],
+    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 ({
+    type: 'number',
+    name: name,
+    value: value,
+    range: range,
+    stepper: stepper,
+}); };
+export var textureNode = function (id, name, position, value) { return ({
+    type: 'texture',
+    id: id,
+    name: name,
+    position: position,
+    value: value,
+    inputs: [],
+    outputs: [
+        {
+            name: 'texture',
+            id: '1',
+            category: 'data',
+        },
+    ],
+}); };
+export var textureUniformData = function (name, value) { return ({ type: 'texture', name: name, value: value }); };
+export var samplerCubeNode = function (id, name, position, value) { return ({
+    type: 'samplerCube',
+    id: id,
+    name: name,
+    position: position,
+    value: value,
+    inputs: [],
+    outputs: [
+        {
+            name: 'samplerCube',
+            id: '1',
+            category: 'data',
+        },
+    ],
+}); };
+export var samplerCubeUniformData = function (name, value) { return ({ type: 'samplerCube', name: name, value: value }); };
+export function arrayNode(id, name, position, value) {
+    return {
+        id: id,
+        name: name,
+        position: position,
+        inputs: [],
+        outputs: [
+            {
+                name: 'array',
+                id: '1',
+                category: 'data',
+            },
+        ],
+        value: value,
+        dimensions: value.length,
+        type: 'array',
+    };
+}
+export function vectorNode(id, name, position, value) {
+    return __assign({ id: id, name: name, position: position, inputs: [], outputs: [
+            {
+                name: "vector".concat(value.length),
+                id: '1',
+                category: 'data',
+            },
+        ] }, (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 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
+    ? { 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) {
+    return __assign({ id: id, name: name, position: position, inputs: [], outputs: [
+            {
+                name: value.length === 3 ? 'rgb' : 'rgba',
+                id: '1',
+                category: 'data',
+            },
+        ] }, (value.length === 3
+        ? { 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
+    ? { value: value, dimensions: 3, type: 'rgb' }
+    : { value: value, dimensions: 4, type: 'rgba' }))); };

package/dist/nodes/edge.js

@@ -0,0 +1 @@
+export var makeEdge = function (id, from, to, output, input, type) { return ({ id: id, from: from, to: to, output: output, input: input, type: type }); };

package/dist/nodes/engine-node.js

@@ -0,0 +1,189 @@
+import { EngineNodeType } from '../engine';
+import { prepopulatePropertyInputs } from '../graph';
+import { NodeType } from '../graph-types';
+import { assignemntToStrategy, namedAttributeStrategy, texture2DStrategy, uniformStrategy, variableStrategy, } from '../strategy';
+import { SourceType, property, } from './code-nodes';
+/**
+ * TODO: These definitions should live outside of core since I'm trying to
+ * refactor out this core folder to only know about nodes with config config,
+ * where nodes like output/phong/physical are all configured at the
+ * implementation level. "phong" shouldn't be in the core
+ */
+export var sourceNode = function (id, name, position, config, source, stage, originalEngine, nextStageNodeId) { return ({
+    id: id,
+    name: name,
+    groupId: undefined,
+    type: NodeType.SOURCE,
+    config: config,
+    position: position,
+    inputs: [],
+    outputs: [
+        {
+            name: 'vector4',
+            category: 'data',
+            id: '1',
+        },
+    ],
+    source: source,
+    stage: stage,
+    originalEngine: originalEngine,
+    nextStageNodeId: nextStageNodeId,
+}); };
+export var outputNode = function (id, name, position, stage) { return ({
+    id: id,
+    name: name,
+    position: position,
+    groupId: undefined,
+    type: NodeType.OUTPUT,
+    config: {
+        version: 3,
+        mangle: false,
+        preprocess: false,
+        uniforms: [],
+        inputMapping: stage === 'fragment'
+            ? {
+                filler_frogFragOut: 'Color',
+            }
+            : {
+                filler_gl_Position: 'Position',
+            },
+        strategies: [
+            assignemntToStrategy(stage === 'fragment' ? 'frogFragOut' : 'gl_Position'),
+        ],
+    },
+    inputs: [],
+    outputs: [],
+    // Consumed by findVec4Constructo4
+    source: stage === 'fragment'
+        ? "\n#version 300 es\nprecision highp float;\n\nout vec4 frogFragOut;\nvoid main() {\n  frogFragOut = vec4(1.0);\n}\n"
+        : // gl_Position isn't "out"-able apparently https://stackoverflow.com/a/24425436/743464
+            "\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 ({
+    id: id,
+    name: name,
+    position: position,
+    type: NodeType.SOURCE,
+    sourceType: SourceType.EXPRESSION,
+    groupId: undefined,
+    stage: undefined,
+    config: {
+        uniforms: [],
+        version: 3,
+        preprocess: false,
+        inputMapping: {},
+        strategies: [variableStrategy()],
+    },
+    inputs: [],
+    outputs: [
+        {
+            name: 'expression',
+            category: 'data',
+            id: '1',
+        },
+    ],
+    source: source,
+}); };
+export var phongNode = function (id, name, groupId, position, stage, nextStageNodeId) {
+    return prepopulatePropertyInputs({
+        id: id,
+        name: name,
+        groupId: groupId,
+        position: position,
+        type: EngineNodeType.phong,
+        config: {
+            version: 3,
+            uniforms: [],
+            preprocess: true,
+            mangle: false,
+            properties: [
+                property('Color', 'color', 'rgb', 'uniform_diffuse'),
+                property('Emissive', 'emissive', 'rgb', 'uniform_emissive'),
+                property('Emissive Map', 'emissiveMap', 'texture', 'filler_emissiveMap'),
+                property('Emissive Intensity', 'emissiveIntensity', 'number', 'uniform_emissive'),
+                property('Texture', 'map', 'texture', 'filler_map'),
+                property('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
+                property('Normal Scale', 'normalScale', 'vector2'),
+                property('Shininess', 'shininess', 'number'),
+                property('Reflectivity', 'reflectivity', 'number'),
+                property('Refraction Ratio', 'refractionRatio', 'number'),
+                property('Specular', 'specular', 'rgb', 'uniform_specular'),
+                property('Specular Map', 'specularMap', 'texture', 'filler_specularMap'),
+                property('Displacement Map', 'displacementMap', 'texture'),
+                property('Env Map', 'envMap', 'samplerCube'),
+            ],
+            strategies: [
+                uniformStrategy(),
+                stage === 'fragment'
+                    ? texture2DStrategy()
+                    : namedAttributeStrategy('position'),
+            ],
+        },
+        inputs: [],
+        outputs: [
+            {
+                name: 'vector4',
+                category: 'data',
+                id: '1',
+            },
+        ],
+        source: '',
+        stage: stage,
+        nextStageNodeId: nextStageNodeId,
+    });
+};
+export var addNode = function (id, position) { return ({
+    id: id,
+    name: 'add',
+    position: position,
+    type: NodeType.BINARY,
+    groupId: undefined,
+    stage: undefined,
+    config: {
+        mangle: false,
+        version: 3,
+        preprocess: true,
+        strategies: [],
+        uniforms: [],
+    },
+    inputs: [],
+    outputs: [
+        {
+            name: 'sum',
+            category: 'data',
+            id: '1',
+        },
+    ],
+    source: "a + b",
+    operator: '+',
+    sourceType: SourceType.EXPRESSION,
+    biStage: true,
+}); };
+export var multiplyNode = function (id, position) { return ({
+    id: id,
+    name: 'multiply',
+    type: NodeType.BINARY,
+    groupId: undefined,
+    stage: undefined,
+    position: position,
+    config: {
+        version: 3,
+        uniforms: [],
+        mangle: false,
+        preprocess: true,
+        strategies: [],
+    },
+    inputs: [],
+    outputs: [
+        {
+            name: 'product',
+            category: 'data',
+            id: '1',
+        },
+    ],
+    source: "a * b",
+    operator: '*',
+    sourceType: SourceType.EXPRESSION,
+    biStage: true,
+}); };

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);