@shaderfrog/core 0.0.2 → 0.1.1

package/dist/strategy/inject.js

@@ -0,0 +1,122 @@
+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 { nodeInput } from '../nodes/core-node';
+import { StrategyType } from '.';
+/**
+ * Inject source code into an AST, in a find-and-replace style. This only
+ * operates on statements right now
+ */
+export var injectStrategy = function (config) { return ({
+    type: StrategyType.INJECT,
+    config: config,
+}); };
+// Typescript fucked up flat https://stackoverflow.com/a/61420611/743464
+var combineWs = function (a, b) {
+    return [a, b].flat(Infinity);
+};
+// Move whitespace from one node to another. Since whitespace is trailing, if a
+// node is injected after a previous node, move the whitespace from the earlier
+// node to the later one. This keeps comments in the same place
+var transferWhitespace = function (to, from) {
+    return 'semi' in to && 'semi' in from
+        ? [
+            __assign(__assign({}, to), { semi: __assign(__assign({}, to.semi), { whitespace: from.semi.whitespace }) }),
+            __assign(__assign({}, from), { semi: __assign(__assign({}, from.semi), { whitespace: '\n' }) }),
+        ]
+        : 'whitespace' in to && 'semi' in from
+            ? [
+                __assign(__assign({}, to), { whitespace: combineWs(to.whitespace, from.semi.whitespace) }),
+                __assign(__assign({}, from), { semi: __assign(__assign({}, from.semi), { whitespace: '\n' }) }),
+            ]
+            : [to, from];
+};
+export var applyInjectStrategy = function (graphNode, ast, strategy) {
+    var program = ast.program;
+    var _a = strategy.config, find = _a.find, count = _a.count, insert = _a.insert;
+    // Total hack for now. Search each function body for statements that when
+    // generated, match the user's "find" string.
+    var matchedStatements = program.reduce(function (matches, statement) {
+        var newMatches = [];
+        if (statement.type === 'function') {
+            var bodyStatements_1 = statement.body.statements;
+            newMatches = bodyStatements_1.reduce(function (innerMatches, bodyStmt, index) {
+                var generated = generate(bodyStmt);
+                // console.log(`"${generated}"`);
+                var triple = [
+                    bodyStatements_1,
+                    bodyStmt,
+                    index,
+                ];
+                return __spreadArray(__spreadArray([], __read(innerMatches), false), __read((generated.includes(find) ? [triple] : [])), false);
+            }, []);
+        }
+        return __spreadArray(__spreadArray([], __read(matches), false), __read(newMatches), false);
+    }, []);
+    var name = "Inject ".concat(strategy.config.insert);
+    return [
+        [
+            nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
+            new Set(['code', 'data']), false),
+            function (fillerAst) {
+                var toInsert = Array.isArray(fillerAst)
+                    ? fillerAst
+                    : [fillerAst];
+                // Loop backwards through the matches because when we inject code into
+                // parent nodes, it modifies the statement list arrays
+                for (
+                // Only go as many count replacements as specified in the config
+                var i = Math.min(matchedStatements.length - 1, count); i >= 0; i--) {
+                    var _a = __read(matchedStatements[i], 3), parent = _a[0], stmt = _a[1], index = _a[2];
+                    if (insert === 'after') {
+                        var _b = __read(toInsert), first = _b[0], rest = _b.slice(1);
+                        var _c = __read(transferWhitespace(first, stmt), 2), newFirst = _c[0], updatedStmt = _c[1];
+                        var newStatements = __spreadArray([newFirst], __read(rest), false);
+                        parent.splice.apply(parent, __spreadArray([index, 1, updatedStmt], __read(newStatements), false));
+                    }
+                    else if (insert === 'before') {
+                        parent.splice.apply(parent, __spreadArray([index - 1, 0], __read(toInsert), false));
+                    }
+                    else if (insert === 'replace') {
+                        throw new Error('not yet implemented');
+                    }
+                }
+                return ast;
+            },
+        ],
+    ];
+};

package/dist/strategy/namedAttribute.js

@@ -0,0 +1,48 @@
+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;
+};
+import { nodeInput } from '../nodes/core-node';
+import { StrategyType } from '.';
+import { generateFiller } from '../util/ast';
+export var namedAttributeStrategy = function (attributeName) { return ({
+    type: StrategyType.NAMED_ATTRIBUTE,
+    config: { attributeName: attributeName },
+}); };
+export var applyNamedAttributeStrategy = function (node, ast, strategy) {
+    var program = ast;
+    var attributeName = strategy.config.attributeName;
+    return [
+        [
+            nodeInput(attributeName, "filler_".concat(attributeName), 'filler', undefined, // Data type for what plugs into this filler
+            new Set(['code', 'data']), true),
+            function (fillerAst) {
+                Object.entries(program.scopes[0].bindings).forEach(function (_a) {
+                    var _b = __read(_a, 2), name = _b[0], binding = _b[1];
+                    binding.references.forEach(function (ref) {
+                        // Rename the variable usage only if it's not the identifier, to
+                        // avoid filling in `in vec3 replaceMe;` with `replacer()`
+                        if (ref.type === 'identifier' &&
+                            ref !== binding.declaration &&
+                            ref.identifier === attributeName) {
+                            ref.identifier = generateFiller(fillerAst);
+                        }
+                    });
+                });
+                return ast;
+            },
+        ],
+    ];
+};

package/dist/strategy/texture2D.js

@@ -0,0 +1,83 @@
+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 { visit, } from '@shaderfrog/glsl-parser/ast';
+import { nodeInput } from '../nodes/core-node';
+import { StrategyType } from '.';
+export var texture2DStrategy = function () { return ({
+    type: StrategyType.TEXTURE_2D,
+    config: {},
+}); };
+export var applyTexture2DStrategy = function (node, ast, strategy) {
+    var texture2Dcalls = [];
+    var seen = {};
+    var visitors = {
+        function_call: {
+            enter: function (path) {
+                var identifier = path.node.identifier;
+                if (
+                // TODO: 100 vs 300
+                ((identifier === null || identifier === void 0 ? void 0 : identifier.identifier) === 'texture2D' ||
+                    (identifier === null || identifier === void 0 ? void 0 : identifier.identifier) === 'texture') &&
+                    path.key) {
+                    if (!path.parent) {
+                        throw new Error('This error is impossible. A function call always has a parent.');
+                    }
+                    var name = generate(path.node.args[0]);
+                    seen[name] = (seen[name] || 0) + 1;
+                    texture2Dcalls.push([
+                        name,
+                        path.parent,
+                        path.key,
+                        // Remove the first argument and comma
+                        path.node.args.slice(2),
+                    ]);
+                }
+            },
+        },
+    };
+    visit(ast, visitors);
+    var names = new Set(Object.entries(seen).reduce(function (arr, _a) {
+        var _b = __read(_a, 2), name = _b[0], count = _b[1];
+        return __spreadArray(__spreadArray([], __read(arr), false), __read((count > 1 ? [name] : [])), false);
+    }, []));
+    var inputs = texture2Dcalls.map(function (_a, index) {
+        var _b = __read(_a, 4), name = _b[0], parent = _b[1], key = _b[2], texture2dArgs = _b[3];
+        // Suffix input name if it's used more than once
+        var iName = names.has(name) ? "".concat(name, "_").concat(index) : name;
+        return [
+            nodeInput(iName, "filler_".concat(iName), 'filler', 'vector4', // Data type for what plugs into this filler
+            new Set(['code', 'data']), false),
+            function (fillerAst) {
+                // @ts-ignore
+                parent[key] = fillerAst;
+                return ast;
+            },
+            texture2dArgs,
+        ];
+    });
+    return inputs;
+};

package/dist/strategy/uniform.js

@@ -0,0 +1,190 @@
+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;
+};
+import { mangleName } from '../graph';
+import { nodeInput } from '../nodes/core-node';
+import { StrategyType } from '.';
+import { generateFiller } from '../util/ast';
+export var uniformStrategy = function () { return ({
+    type: StrategyType.UNIFORM,
+    config: {},
+}); };
+var DATA_TYPE_MAP = [
+    ['vector2', new Set(['bvec2', 'dvec2', 'ivec2', 'uvec2', 'vec2'])],
+    ['number', new Set(['float', 'double', 'int', 'uint', 'atomic_uint'])],
+    ['vector3', new Set(['bvec3', 'dvec3', 'ivec3', 'uvec3', 'vec3'])],
+    ['vector4', new Set(['bvec4', 'dvec4', 'ivec4', 'uvec4', 'vec4'])],
+    ['texture', new Set(['sampler2D'])],
+    ['mat2', new Set(['mat2', 'dmat2'])],
+    ['mat3', new Set(['mat3', 'dmat3'])],
+    ['mat4', new Set(['mat4', 'dmat4'])],
+    ['mat2x2', new Set(['mat2x2', 'dmat2x2'])],
+    ['mat2x3', new Set(['mat2x3', 'dmat2x3'])],
+    ['mat2x4', new Set(['mat2x4', 'dmat2x4'])],
+    ['mat3x2', new Set(['mat3x2', 'dmat3x2'])],
+    ['mat3x3', new Set(['mat3x3', 'dmat3x3'])],
+    ['mat3x4', new Set(['mat3x4', 'dmat3x4'])],
+    ['mat4x2', new Set(['mat4x2', 'dmat4x2'])],
+    ['mat4x3', new Set(['mat4x3', 'dmat4x3'])],
+    ['mat4x4', new Set(['mat4x4', 'dmat4x4'])],
+];
+/**
+ * Uncategorized:
+ *
+"sampler1D"
+"sampler3D"
+"samplerCube"
+"sampler1DShadow"
+"sampler2DShadow"
+"samplerCubeShadow"
+"sampler1DArray"
+"sampler2DArray"
+"sampler1DArrayShadow"
+"sampler2DArrayshadow"
+"isampler1D"
+"isampler2D"
+"isampler3D"
+"isamplerCube"
+"isampler1Darray"
+"isampler2DArray"
+"usampler1D"
+"usampler2D"
+"usampler3D"
+"usamplerCube"
+"usampler1DArray"
+"usampler2DArray"
+"sampler2DRect"
+"sampler2DRectshadow"
+"isampler2DRect"
+"usampler2DRect"
+"samplerBuffer"
+"isamplerBuffer"
+"usamplerBuffer"
+"samplerCubeArray"
+"samplerCubeArrayShadow"
+"isamplerCubeArray"
+"usamplerCubeArray"
+"sampler2DMS"
+"isampler2DMS"
+"usampler2DMS"
+"sampler2DMSArray"
+"isampler2DMSArray"
+"usampler2DMSArray"
+"image1D"
+"iimage1D"
+"uimage1D"
+"image2D"
+"iimage2D"
+"uimage2D"
+"image3D"
+"iimage3D"
+"uimage3D"
+"image2DRect"
+"iimage2DRect"
+"uimage2DRect"
+"imageCube"
+"iimageCube"
+"uimageCube"
+"imageBuffer"
+"iimageBuffer"
+"uimageBuffer"
+"image1DArray"
+"iimage1DArray"
+"uimage1DArray"
+"image2DArray"
+"iimage2DArray"
+"uimage2DArray"
+"imageCubeArray"
+"iimageCubeArray"
+"uimageCubeArray"
+"image2DMS"
+"iimage2DMS"
+"uimage2DMS"
+"image2DMArray"
+"iimage2DMSArray"
+"uimage2DMSArray"
+"struct"
+ */
+var mapUniformType = function (type) {
+    var found = DATA_TYPE_MAP.find(function (_a) {
+        var _b = __read(_a, 2), _ = _b[0], set = _b[1];
+        return set.has(type);
+    });
+    if (found) {
+        return found[0];
+    }
+    // console.log(`Unknown uniform type, can't map to graph: ${type}`);
+};
+export var applyUniformStrategy = function (graphNode, ast, strategy) {
+    var program = ast;
+    return (program.program || []).flatMap(function (node) {
+        var _a, _b, _c, _d, _e, _f, _g;
+        // The uniform declaration type, like vec4
+        var uniformType = (_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.token;
+        var graphDataType = mapUniformType(uniformType);
+        // If this is a uniform declaration line
+        if (node.type === 'declaration_statement' &&
+            node.declaration.type === 'declarator_list' &&
+            ((_g = (_f = (_e = node.declaration) === null || _e === void 0 ? void 0 : _e.specified_type) === null || _f === void 0 ? void 0 : _f.qualifiers) === null || _g === void 0 ? void 0 : _g.find(function (n) { return n.token === 'uniform'; }))
+        // commented this out to allow for sampler2D uniforms to appear as inputs
+        // && uniformType !== 'sampler2D'
+        ) {
+            // Capture all the declared names, removing mangling suffix
+            var declarations_1 = node.declaration.declarations;
+            var names = declarations_1.map(function (d) { return d.identifier.identifier; });
+            // Tricky code warning: The flow of preparing a node for the graph is:
+            // 1. Produce/mangle the AST (with unmangled names)
+            // 2. findInputs() (with unmangled names)
+            // 3. The AST is *then* mangled in graph.ts
+            // 4. Later, the inputs are filled in, and now, we have an input with
+            //    the name "x" but the ast now has the mangled name "x_1". So
+            //    here, we look for the *mangled* name in the strategy runner
+            return names.map(function (name) { return [
+                nodeInput(name, "uniform_".concat(name), 'uniform', graphDataType, new Set(['code', 'data']), true),
+                function (filler) {
+                    var mangledName = mangleName(name, graphNode);
+                    // Remove the declaration line, or the declared uniform
+                    if (declarations_1.length === 1) {
+                        program.program.splice(program.program.indexOf(node), 1);
+                    }
+                    else {
+                        var decl = node.declaration;
+                        decl.declarations = decl.declarations.filter(function (d) { return d.identifier.identifier !== mangledName; });
+                    }
+                    // And rename all the references to said uniform
+                    program.scopes[0].bindings[name].references.forEach(function (ref) {
+                        if (ref.type === 'identifier' && ref.identifier === mangledName) {
+                            ref.identifier = generateFiller(filler);
+                        }
+                        else if (ref.type === 'parameter_declaration' &&
+                            'identifier' in ref &&
+                            ref.identifier.identifier === mangledName) {
+                            ref.identifier.identifier = generateFiller(filler);
+                        }
+                        else if ('identifier' in ref) {
+                            ref.identifier = generateFiller(filler);
+                        }
+                        else {
+                            console.warn('Unknown uniform reference for', graphNode.name, 'ref');
+                        }
+                    });
+                    return ast;
+                },
+            ]; });
+        }
+        return [];
+    });
+};

package/dist/strategy/variable.js

@@ -0,0 +1,80 @@
+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 { nodeInput } from '../nodes/core-node';
+import { StrategyType } from '.';
+import { generateFiller } from '../util/ast';
+export var variableStrategy = function () { return ({
+    type: StrategyType.VARIABLE,
+    config: {},
+}); };
+export var applyVariableStrategy = function (node, ast, strategy) {
+    var program = ast;
+    return Object.values(program.scopes.reduce(function (acc, scope) { return (__assign(__assign({}, acc), scope.bindings)); }, {})).flatMap(function (binding) {
+        return binding.references.reduce(function (acc, ref) {
+            var identifier, replacer;
+            if (ref.type === 'declaration') {
+                identifier = ref.identifier.identifier;
+                replacer = function (fillerAst) {
+                    ref.identifier.identifier = generateFiller(fillerAst);
+                    return ast;
+                };
+            }
+            else if (ref.type === 'identifier') {
+                identifier = ref.identifier;
+                replacer = function (fillerAst) {
+                    ref.identifier = generateFiller(fillerAst);
+                    return ast;
+                };
+                // } else if (ref.type === 'parameter_declaration') {
+                //   identifier = ref.declaration.identifier.identifier;
+                //   replacer = (fillerAst: AstNode) => {
+                //     ref.declaration.identifier.identifier = generate(fillerAst);
+                //   };
+            }
+            else {
+                return acc;
+            }
+            return __spreadArray(__spreadArray([], __read(acc), false), [
+                [
+                    nodeInput(identifier, "filler_".concat(identifier), 'filler', undefined, // Data type for what plugs into this filler
+                    new Set(['code', 'data']), false),
+                    replacer,
+                ],
+            ], false);
+        }, []);
+    });
+};