@shaderfrog/core 1.2.0 → 1.3.0

package/esm/strategy/hardCode.d.ts

@@ -0,0 +1,15 @@
+import { NodeInput } from '../graph/base-node';
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+/**
+ * I don't actually know if anything uses this, nor do I remember how it would
+ * be used, since the filler strategy has no effect on the AST. TODO: Remove
+ * this strategy if no one uses it!
+ */
+export interface HardCodeStrategy extends BaseStrategy {
+    type: StrategyType.HARD_CODE_INPUTS;
+    config: {
+        inputs: NodeInput[];
+    };
+}
+export declare const hardCodeStrategy: (inputs: NodeInput[]) => HardCodeStrategy;
+export declare const applyHardCodeStrategy: ApplyStrategy<HardCodeStrategy>;

package/esm/strategy/hardCode.js

@@ -0,0 +1,23 @@
+import { StrategyType } from '.';
+export var hardCodeStrategy = function (inputs) { return ({
+    type: StrategyType.HARD_CODE_INPUTS,
+    config: { inputs: inputs },
+}); };
+export var applyHardCodeStrategy = function (strategy, ast, graphNode, siblingNode) {
+    return strategy.config.inputs.map(function (input) {
+        // Broken out into two lines to enforce type checking on the array.
+        var ci = [
+            input,
+            // Fillers have to return AstNode | Program, and filler is type Filler,
+            // so this awkward branch is to make types line up. But I don't think
+            // this code path would ever get called
+            function (filler) {
+                if (!filler || Array.isArray(filler)) {
+                    throw new Error('Cannot use void filler');
+                }
+                return filler;
+            },
+        ];
+        return ci;
+    });
+};

package/esm/strategy/index.d.ts

@@ -0,0 +1,9 @@
+export * from './hardCode';
+export * from './uniform';
+export * from './assignemntTo';
+export * from './inject';
+export * from './declarationOf';
+export * from './texture2D';
+export * from './namedAttribute';
+export * from './variable';
+export * from './strategy';

package/esm/strategy/index.js

@@ -0,0 +1,9 @@
+export * from './hardCode';
+export * from './uniform';
+export * from './assignemntTo';
+export * from './inject';
+export * from './declarationOf';
+export * from './texture2D';
+export * from './namedAttribute';
+export * from './variable';
+export * from './strategy';

package/esm/strategy/inject.d.ts

@@ -0,0 +1,15 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface InjectStrategy extends BaseStrategy {
+    type: StrategyType.INJECT;
+    config: {
+        find: string;
+        insert: 'before' | 'after' | 'replace';
+        count: number;
+    };
+}
+/**
+ * Inject source code into an AST, in a find-and-replace style. This only
+ * operates on statements right now
+ */
+export declare const injectStrategy: (config: InjectStrategy['config']) => InjectStrategy;
+export declare const applyInjectStrategy: ApplyStrategy<InjectStrategy>;

package/esm/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 '../graph/base-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 (strategy, ast, graphNode, siblingNode) {
+    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
+            ['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/esm/strategy/namedAttribute.d.ts

@@ -0,0 +1,9 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export declare const namedAttributeStrategy: (attributeName: string) => NamedAttributeStrategy;
+export interface NamedAttributeStrategy extends BaseStrategy {
+    type: StrategyType.NAMED_ATTRIBUTE;
+    config: {
+        attributeName: string;
+    };
+}
+export declare const applyNamedAttributeStrategy: ApplyStrategy<NamedAttributeStrategy>;

package/esm/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 '../graph/base-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 (strategy, ast, graphNode, siblingNode) {
+    var program = ast;
+    var attributeName = strategy.config.attributeName;
+    return [
+        [
+            nodeInput(attributeName, "filler_".concat(attributeName), 'filler', undefined, // Data type for what plugs into this filler
+            ['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/esm/strategy/strategy.d.ts

@@ -0,0 +1,28 @@
+import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
+import { SourceNode } from '../graph/code-nodes';
+import { HardCodeStrategy } from './hardCode';
+import { UniformStrategy } from './uniform';
+import { AssignemntToStrategy } from './assignemntTo';
+import { DeclarationOfStrategy } from './declarationOf';
+import { Texture2DStrategy } from './texture2D';
+import { NamedAttributeStrategy } from './namedAttribute';
+import { VariableStrategy } from './variable';
+import { InjectStrategy } from './inject';
+import { ComputedInput } from '../graph/parsers';
+export declare enum StrategyType {
+    VARIABLE = "Variable Names",
+    ASSIGNMENT_TO = "Assignment To",
+    DECLARATION_OF = "Variable Declaration",
+    TEXTURE_2D = "Texture2D",
+    NAMED_ATTRIBUTE = "Named Attribute",
+    UNIFORM = "Uniform",
+    INJECT = "Inject",
+    HARD_CODE_INPUTS = "Hard Code Inputs"
+}
+export interface BaseStrategy {
+    type: StrategyType;
+    config: Object;
+}
+export type Strategy = UniformStrategy | AssignemntToStrategy | Texture2DStrategy | NamedAttributeStrategy | VariableStrategy | HardCodeStrategy | InjectStrategy | DeclarationOfStrategy;
+export type ApplyStrategy<T> = (strategy: T, ast: AstNode | Program, node: SourceNode, sibling: SourceNode) => ComputedInput[];
+export declare const applyStrategy: (strategy: Strategy, ast: AstNode | Program, node: SourceNode, sibling: SourceNode) => ComputedInput[];

package/esm/strategy/strategy.js

@@ -0,0 +1,31 @@
+var _a;
+import { applyHardCodeStrategy } from './hardCode';
+import { applyUniformStrategy } from './uniform';
+import { applyAssignmentToStrategy, } from './assignemntTo';
+import { constApplyDeclarationOf as constApplyDeclarationOfStrategy, } from './declarationOf';
+import { applyTexture2DStrategy } from './texture2D';
+import { applyNamedAttributeStrategy, } from './namedAttribute';
+import { applyVariableStrategy } from './variable';
+import { applyInjectStrategy } from './inject';
+export var StrategyType;
+(function (StrategyType) {
+    StrategyType["VARIABLE"] = "Variable Names";
+    StrategyType["ASSIGNMENT_TO"] = "Assignment To";
+    StrategyType["DECLARATION_OF"] = "Variable Declaration";
+    StrategyType["TEXTURE_2D"] = "Texture2D";
+    StrategyType["NAMED_ATTRIBUTE"] = "Named Attribute";
+    StrategyType["UNIFORM"] = "Uniform";
+    StrategyType["INJECT"] = "Inject";
+    StrategyType["HARD_CODE_INPUTS"] = "Hard Code Inputs";
+})(StrategyType || (StrategyType = {}));
+var strategyRunners = (_a = {},
+    _a[StrategyType.INJECT] = applyInjectStrategy,
+    _a[StrategyType.HARD_CODE_INPUTS] = applyHardCodeStrategy,
+    _a[StrategyType.UNIFORM] = applyUniformStrategy,
+    _a[StrategyType.ASSIGNMENT_TO] = applyAssignmentToStrategy,
+    _a[StrategyType.DECLARATION_OF] = constApplyDeclarationOfStrategy,
+    _a[StrategyType.TEXTURE_2D] = applyTexture2DStrategy,
+    _a[StrategyType.NAMED_ATTRIBUTE] = applyNamedAttributeStrategy,
+    _a[StrategyType.VARIABLE] = applyVariableStrategy,
+    _a);
+export var applyStrategy = function (strategy, ast, node, sibling) { return strategyRunners[strategy.type](strategy, ast, node, sibling); };

package/esm/strategy/stratgies.test.d.ts

@@ -0,0 +1 @@
+export {};

package/esm/strategy/stratgies.test.js

@@ -0,0 +1,164 @@
+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 { parser } from '@shaderfrog/glsl-parser';
+import { generate } from '@shaderfrog/glsl-parser';
+import { applyStrategy, StrategyType } from '.';
+import * as graphModule from '../graph/graph';
+import { makeExpression } from '../util/ast';
+import preprocess from '@shaderfrog/glsl-parser/preprocessor';
+var orig;
+beforeEach(function () {
+    orig = graphModule.mangleName;
+    // Terrible hack. in the real world, strategies are applied after mangling
+    // @ts-ignore
+    graphModule.mangleName = function (name) { return name; };
+});
+afterEach(function () {
+    // @ts-ignore
+    graphModule.mangleName = orig;
+});
+it('named attribute strategy`', function () {
+    var source = "\nin vec3 replaceThisAtrribute;\nvoid main() {\n  vec2 y = replaceThisAtrribute;\n}\n";
+    var ast = parser.parse(source, { quiet: true });
+    var fillers = applyStrategy({
+        type: StrategyType.NAMED_ATTRIBUTE,
+        config: {
+            attributeName: 'replaceThisAtrribute',
+        },
+    }, ast, { source: source }, {});
+    expect(fillers.length).toBe(1);
+    fillers[0][1]({
+        type: 'literal',
+        literal: "myFiller()",
+        whitespace: '',
+    });
+    var result = generate(ast);
+    // Should replace the use of the filler, but not the declaration
+    expect(result).toBe("\nin vec3 replaceThisAtrribute;\nvoid main() {\n  vec2 y = myFiller();\n}\n");
+});
+it('inject strategy after', function () {
+    var source = "\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\n// Middle comment\nre(x, y, z);\n// Final comment\n}";
+    var ast = parser.parse(source, { quiet: true });
+    var fillers = applyStrategy({
+        type: StrategyType.INJECT,
+        config: {
+            find: 're(x, y, z);',
+            insert: 'after',
+            count: Infinity,
+        },
+    }, ast, { source: source }, {});
+    expect(fillers.length).toBe(1);
+    fillers[0][1]({
+        type: 'literal',
+        literal: "someOtherCall(x, y, z);\nsomeOtherCall(x, y, z);",
+        whitespace: '',
+    });
+    var result = generate(ast);
+    // Should fill references
+    expect(result).toBe("\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\n// Middle comment\nre(x, y, z);\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\n// Final comment\n}");
+});
+it('inject strategy before', function () {
+    var source = "\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nre(x, y, z);\n// Middle comment\nre(x, y, z);\n// Final comment\n}";
+    var ast = parser.parse(source, { quiet: true });
+    var fillers = applyStrategy({
+        type: StrategyType.INJECT,
+        config: {
+            find: 're(x, y, z);',
+            insert: 'before',
+            count: Infinity,
+        },
+    }, ast, { source: source }, {});
+    expect(fillers.length).toBe(1);
+    fillers[0][1]({
+        type: 'literal',
+        literal: "someOtherCall(x, y, z);\nsomeOtherCall(x, y, z);",
+        whitespace: '\n',
+    });
+    var result = generate(ast);
+    // Should fill references
+    expect(result).toBe("\nuniform float x;\n// Some comment\nvoid main() {\n/* some comment */\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\nre(x, y, z);\n// Middle comment\nsomeOtherCall(x, y, z);\nsomeOtherCall(x, y, z);\nre(x, y, z);\n// Final comment\n}");
+});
+it('correctly fills with uniform strategy', function () {
+    var _a, _b, _c;
+    var ast = parser.parse("\nlayout(std140,column_major) uniform;\nuniform sampler2D image;\nuniform vec4 input, output, other;\nuniform vec4 zenput;\nuniform Light0 { vec4 y; } x;\nvec3 topLevel = vec3(0.0);\nvoid other(in vec3 param) {}\nvoid main() {\n  vec4 computed = texture2D(image, uvPow * 1.0);\n  vec4 x = input;\n  vec4 y = output;\n  vec4 z = zenput;\n}", { quiet: true });
+    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, {}, {});
+    // It should find uniforms with simple types, excluding sampler2D
+    expect(fillers.map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual([
+        'image',
+        'input',
+        'output',
+        'other',
+        'zenput',
+    ]);
+    (_a = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'input';
+    })) === null || _a === void 0 ? void 0 : _a[1](makeExpression('a'));
+    (_b = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'output';
+    })) === null || _b === void 0 ? void 0 : _b[1](makeExpression('b'));
+    (_c = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'zenput';
+    })) === null || _c === void 0 ? void 0 : _c[1](makeExpression('c'));
+    var result = generate(ast);
+    // Should fill references
+    expect(result).toContain('vec4 x = a;');
+    expect(result).toContain('vec4 y = b;');
+    expect(result).toContain('vec4 z = c;');
+    // Should preserve things it shouldn't touch
+    expect(result).toContain('layout(std140,column_major) uniform;');
+    expect(result).toContain('uniform sampler2D image;');
+    expect(result).toContain('uniform Light0 { vec4 y; } x;');
+    // Should remove uniforms from declarator list
+    expect(result).toContain('uniform vec4 other;');
+    // Should remove uniform lines
+    expect(result).not.toContain('uniform vec4 zenput');
+});
+it('uses name without suffix for single call', function () {
+    var ast = parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n}", { quiet: true });
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual(['noiseImage']);
+});
+it('finds multiple texture2D inputs for one uniform', function () {
+    var ast = parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n  computed += texture2D(noiseImage, uvPow * 2.0);\n}", { quiet: true });
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual(['noiseImage_0', 'noiseImage_1']);
+});
+it('Make sure texture2D finds preprocessed texture() call', function () {
+    // I thought this was a regression, but it wasn't a real bug, but tests seems
+    // benign to keep anyway
+    var program = "\n#define texture2DBias texture\n\nuniform sampler2D normalMap;\n\nvoid getNormal() {\n    vec3 normalMap = unpackNormal(texture2DBias(normalMap, vUv0, textureBias));\n}";
+    var pp = preprocess(program, {
+        preserve: {
+            version: function () { return true; },
+        },
+    });
+    var ast = parser.parse(pp, { quiet: true });
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name;
+    })).toEqual(['normalMapx']);
+});

package/esm/strategy/texture2D.d.ts

@@ -0,0 +1,6 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface Texture2DStrategy extends BaseStrategy {
+    type: StrategyType.TEXTURE_2D;
+}
+export declare const texture2DStrategy: () => Texture2DStrategy;
+export declare const applyTexture2DStrategy: ApplyStrategy<Texture2DStrategy>;

package/esm/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 '../graph/base-node';
+import { StrategyType } from '.';
+export var texture2DStrategy = function () { return ({
+    type: StrategyType.TEXTURE_2D,
+    config: {},
+}); };
+export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingNode) {
+    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
+            ['code', 'data'], false),
+            function (fillerAst) {
+                // @ts-ignore
+                parent[key] = fillerAst;
+                return ast;
+            },
+            texture2dArgs,
+        ];
+    });
+    return inputs;
+};

package/esm/strategy/uniform.d.ts

@@ -0,0 +1,6 @@
+import { BaseStrategy, ApplyStrategy, StrategyType } from '.';
+export interface UniformStrategy extends BaseStrategy {
+    type: StrategyType.UNIFORM;
+}
+export declare const uniformStrategy: () => UniformStrategy;
+export declare const applyUniformStrategy: ApplyStrategy<UniformStrategy>;