@shaderfrog/core 2.0.0-beta.3 → 2.0.1

package/plugins/three/threngine.test.js

@@ -37,15 +37,17 @@ var __generator = (this && this.__generator) || function (thisArg, body) {
 import { expect, it } from 'vitest';
 import { outputNode, sourceNode } from '../../graph/graph-node';
 import { makeEdge } from '../../graph/edge';
-import { compileSource } from '../../graph/graph';
-import { texture2DStrategy } from '../../strategy';
+import { compileSource, nodeName } from '../../graph/graph';
+import { namedAttributeStrategy, texture2DStrategy } from '../../strategy';
 import { isError } from '../../graph/context';
 import { threngine } from './threngine';
 import { makeId } from '../../util/id';
 import { fail } from '../../test-util';
+import importers from './importers';
+import { generate, parser } from '@shaderfrog/glsl-parser';
 var p = { x: 0, y: 0 };
 var makeSourceNode = function (id, source, stage, strategies) {
-    if (strategies === void 0) { strategies = [texture2DStrategy()]; }
+    if (strategies === void 0) { strategies = [texture2DStrategy(), namedAttributeStrategy('position')]; }
     return sourceNode(id, "Shader ".concat(id), p, {
         version: 2,
         preprocess: false,
@@ -82,8 +84,54 @@ it('threngine compileSource() and manipulateAst()', function () { return __await
                 // Threngine has parsers for vertex shaders, make sure that is set properly
                 expect(result.vertexResult).toContain("vec4 main_Shader_".concat(vertInput.id, "() {\n  vec4 frogOut = modelViewMatrix * vec4(position, 1.0);\n  return frogOut;\n}"));
                 // Check that it inlned. For fun.
-                expect(result.vertexResult).toContain("gl_Position = main_Shader_".concat(vertInput.id, "();"));
+                expect(result.vertexResult).toContain("gl_Position = ".concat(nodeName(vertInput), "();"));
                 return [2 /*return*/];
         }
     });
 }); });
+it('threngine compileSource() linking through vertex', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var outV, outF, vert1, vert2, graph, engineContext, result;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                outV = outputNode(makeId(), 'Output v', p, 'vertex');
+                outF = outputNode(makeId(), 'Output f', p, 'fragment');
+                vert1 = makeSourceNode(makeId(), "void main() {\n  gl_Position = modelViewMatrix * vec4(position, 1.0);\n}\n", 'vertex');
+                vert2 = makeSourceNode(makeId(), "void main() {\n  gl_Position = modelViewMatrix * vec4(position, 1.0);\n}\n", 'vertex');
+                graph = {
+                    nodes: [outV, outF, vert1, vert2],
+                    edges: [
+                        makeEdge(makeId(), vert1.id, outV.id, 'out', 'filler_gl_Position', 'vertex'),
+                        makeEdge(makeId(), vert2.id, vert1.id, 'out', 'filler_position', 'vertex'),
+                    ],
+                };
+                engineContext = {
+                    engine: 'three',
+                    nodes: {},
+                    runtime: {},
+                    debuggingNonsense: {},
+                };
+                return [4 /*yield*/, compileSource(graph, threngine, engineContext)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    fail(result);
+                }
+                // Because vert2 links through vert1, it should be a vec3, not a vec4
+                expect(result.vertexResult).toContain("vec3 ".concat(nodeName(vert2), "() {"));
+                expect(result.vertexResult).toContain("vec4 ".concat(nodeName(vert1), "() {"));
+                return [2 /*return*/];
+        }
+    });
+}); });
+it('threngine shadertoy import', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var testImport, p;
+    return __generator(this, function (_a) {
+        testImport = "\nvoid mainImage( out vec4 fragColor, in vec2 fragCoord ){\n  vec3 rd = normalize(vec3(2.*fragCoord - iResolution.xy, iResolution.y));\n  fragColor = vec4(sqrt(clamp(col, 0., 1.)), 1.0 * iTime);\n}\n";
+        p = parser.parse(testImport);
+        importers.shadertoy.convertAst(p, 'fragment');
+        console.log(generate(p));
+        expect(generate(p)).toContain("\nprecision highp float;\nprecision highp int;\n\nuniform vec2 mouse;\nuniform float time;\nuniform vec2 renderResolution;\n\nvoid main() {\n  vec3 rd = normalize(vec3(2.*gl_FragCoord.xy - renderResolution.xy, renderResolution.y));\n  gl_FragColor = vec4(sqrt(clamp(col, 0., 1.)), 1.0 * time);\n}\n");
+        return [2 /*return*/];
+    });
+}); });

package/strategy/assignemntTo.js

@@ -18,13 +18,14 @@ export var applyAssignmentToStrategy = function (strategy, ast, graphNode, sibli
             [
                 nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
                 ['code', 'data'], false),
-                function (fillerAst) {
+                function (filler) {
+                    var filled = filler();
                     if ('expression' in assignNode) {
                         assignNode.expression.right =
-                            fillerAst;
+                            filled;
                     }
                     else {
-                        assignNode.initializer = fillerAst;
+                        assignNode.initializer = filled;
                     }
                     return ast;
                 },

package/strategy/declarationOf.js

@@ -13,8 +13,8 @@ export var constApplyDeclarationOf = function (strategy, ast, graphNode, sibling
             [
                 nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
                 ['code', 'data'], false),
-                function (fillerAst) {
-                    declaration.initializer = fillerAst;
+                function (filler) {
+                    declaration.initializer = filler();
                     return ast;
                 },
             ],

package/strategy/hardCode.js

@@ -12,10 +12,7 @@ export var applyHardCodeStrategy = function (strategy, ast, graphNode, siblingNo
             // 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 filler();
             },
         ];
         return ci;

package/strategy/inject.js

@@ -62,10 +62,9 @@ export var applyInjectStrategy = function (strategy, ast, graphNode, siblingNode
         [
             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];
+            function (filler) {
+                var result = filler();
+                var toInsert = Array.isArray(result) ? result : [result];
                 // Loop backwards through the matches because when we inject code into
                 // parent nodes, it modifies the statement list arrays
                 for (

package/strategy/namedAttribute.js

@@ -28,7 +28,7 @@ export var applyNamedAttributeStrategy = function (strategy, ast, graphNode, sib
         [
             nodeInput(attributeName, "filler_".concat(attributeName), 'filler', undefined, // Data type for what plugs into this filler
             ['code', 'data'], true),
-            function (fillerAst) {
+            function (filler) {
                 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) {
@@ -37,7 +37,7 @@ export var applyNamedAttributeStrategy = function (strategy, ast, graphNode, sib
                         if (ref.type === 'identifier' &&
                             ref !== binding.declaration &&
                             ref.identifier === attributeName) {
-                            ref.identifier = generateFiller(fillerAst);
+                            ref.identifier = generateFiller(filler());
                         }
                     });
                 });

package/strategy/strategy.d.ts

@@ -8,7 +8,32 @@ import { Texture2DStrategy } from './texture2D';
 import { NamedAttributeStrategy } from './namedAttribute';
 import { VariableStrategy } from './variable';
 import { InjectStrategy } from './inject';
-import { ComputedInput } from '../graph/parsers';
+import { NodeInput } from '../graph';
+/**
+ * Fillers are generated by *strategies*. Strategies are applied to the AST
+ * by applyStrategy() in strategy.ts, which runs strategy functions like
+ * applyTexture2DStrategy(), which returns a list of fillers found by each
+ * strategy.
+ */
+export type Filler = (...args: string[]) => AstNode | AstNode[] | void;
+export type InputFiller = (filler: Filler) => AstNode | Program;
+export type FillerArguments = AstNode[];
+export type FillerStmt = AstNode;
+export type InputFillerGroup = {
+    filler: InputFiller;
+    fillerArgs?: FillerArguments;
+    fillerStmt?: AstNode;
+};
+export type InputFillers = Record<string, InputFillerGroup>;
+/**
+ * A computed input is ultimately what the strategy application process returns
+ */
+export type ComputedInput = [
+    NodeInput,
+    InputFiller,
+    FillerArguments?,
+    FillerStmt?
+];
 export declare enum StrategyType {
     VARIABLE = "Variable Names",
     ASSIGNMENT_TO = "Assignment To",
@@ -24,5 +49,5 @@ export interface BaseStrategy {
     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[];
+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/strategy/stratgies.test.js

@@ -20,6 +20,8 @@ import { generate } from '@shaderfrog/glsl-parser';
 import { applyStrategy, StrategyType } from '.';
 import { makeExpression } from '../util/ast';
 import preprocess from '@shaderfrog/glsl-parser/preprocessor';
+import { NodeType } from '../graph/graph-types';
+import { mangleEntireProgram } from '../graph';
 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 });
@@ -30,11 +32,11 @@ it('named attribute strategy`', function () {
         },
     }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
-    fillers[0][1]({
+    fillers[0][1](function () { return ({
         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");
@@ -51,11 +53,11 @@ it('inject strategy after', function () {
         },
     }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
-    fillers[0][1]({
+    fillers[0][1](function () { return ({
         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}");
@@ -72,11 +74,11 @@ it('inject strategy before', function () {
         },
     }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
-    fillers[0][1]({
+    fillers[0][1](function () { return ({
         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}");
@@ -91,7 +93,7 @@ var constructor = function () { return ({
     id: '1',
     name: '1',
     engine: true,
-    type: '',
+    type: NodeType.SOURCE,
     inputs: [],
     outputs: [],
     position: { x: 0, y: 0 },
@@ -122,25 +124,7 @@ var engine = {
 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 });
-    // TODO: Experimenting with strategy tests where we mangle in the test to
-    // avoid having to mangle in the strategy, in service of maybe mangling the
-    // AST as part of producing context. But as the test shows -
-    // mangleEntireProgram does NOT modify binding names
-    //
-    // You started updating binding names in the parser but realized that
-    // technically a mangler can produce different results for different nodes
-    // during the rename, since the parser takes in the node to mangle.
-    //
-    // which raised the question about why pass in the node at all to the mangler?
-    // looks like it's for "doNotDescope" hack to avoid renaming a specific
-    // varaible.
-    //
-    // But maybe that could be done here instead? And mangleEntireProgram could be
-    // aware of the output varaibles to ignore? Which means we need to track the
-    // output varialbe names somewhere... do we alredy?
-    var node = { name: 'fake', id: '1' };
-    // mangleEntireProgram(engine, ast, node);
-    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, {}, {});
+    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;
@@ -155,15 +139,21 @@ it('correctly fills with uniform strategy', function () {
     (_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'));
+    })) === null || _a === void 0 ? void 0 : _a[1](function () {
+        return 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'));
+    })) === null || _b === void 0 ? void 0 : _b[1](function () {
+        return 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'));
+    })) === null || _c === void 0 ? void 0 : _c[1](function () {
+        return makeExpression('c');
+    });
     var result = generate(ast);
     // Should fill references
     expect(result).toContain('vec4 x = a;');
@@ -178,6 +168,44 @@ it('correctly fills with uniform strategy', function () {
     // Should remove uniform lines
     expect(result).not.toContain('uniform vec4 zenput');
 });
+it('correctly fills with uniform strategy through mangling', function () {
+    var _a, _b, _c;
+    var ast = parser.parse("\nuniform sampler2D image;\nuniform vec4 input, output;\nvoid main() {\n  vec4 computed = texture2D(image, uvPow * 1.0);\n  vec4 x = input;\n  vec4 y = output;\n}", { quiet: true });
+    var node = { id: '1', name: 'fake' };
+    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, node);
+    mangleEntireProgram(engine, ast, node);
+    // 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',
+    ]);
+    var a = (_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];
+    (_b = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'input';
+    })) === null || _b === void 0 ? void 0 : _b[1](function () {
+        return makeExpression('a');
+    });
+    (_c = fillers.find(function (_a) {
+        var _b = __read(_a, 1), name = _b[0].displayName;
+        return name === 'output';
+    })) === null || _c === void 0 ? void 0 : _c[1](function () {
+        return makeExpression('b');
+    });
+    var result = generate(ast);
+    // Should fill references
+    expect(result).toContain('vec4 x = a;');
+    expect(result).toContain('vec4 y = b;');
+    // Should preserve things it shouldn't touch
+    expect(result).toContain("uniform sampler2D image_".concat(node.id, ";"));
+});
 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) {
@@ -185,12 +213,12 @@ it('uses name without suffix for single call', function () {
         return name;
     })).toEqual(['noiseImage']);
 });
-it('finds multiple texture2D inputs for one uniform', function () {
+it('finds one texture2D input for one texture2D() call', 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']);
+    })).toEqual(['noiseImage']);
 });
 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

package/strategy/texture2D.js

@@ -33,7 +33,7 @@ export var texture2DStrategy = function () { return ({
 }); };
 export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingNode) {
     var texture2Dcalls = [];
-    var seen = {};
+    var references = {};
     var visitors = {
         function_call: {
             enter: function (path) {
@@ -47,36 +47,34 @@ export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingN
                         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),
-                    ]);
+                    if (!(name in references)) {
+                        references[name] = [];
+                        texture2Dcalls.push(name);
+                    }
+                    references[name].push({
+                        parent: path.parent,
+                        key: path.key,
+                        args: 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;
+    var inputs = texture2Dcalls.map(function (name) {
         return [
-            nodeInput(iName, "filler_".concat(iName), 'filler', 'vector4', // Data type for what plugs into this filler
+            nodeInput(name, "filler_".concat(name), 'filler', 'vector4', // Data type for what plugs into this filler
             ['code', 'data'], false),
-            function (fillerAst) {
-                // @ts-ignore
-                parent[key] = fillerAst;
+            function (filler) {
+                references[name].forEach(function (_a) {
+                    var parent = _a.parent, key = _a.key, args = _a.args;
+                    // Backfilling into the filler! Similar to parsers.ts filler
+                    var f = filler.apply(void 0, __spreadArray([], __read(args.map(generate)), false));
+                    // @ts-ignore
+                    parent[key] = f;
+                });
                 return ast;
             },
-            texture2dArgs,
         ];
     });
     return inputs;

package/strategy/uniform.js

@@ -1,3 +1,14 @@
+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;
@@ -17,6 +28,7 @@ var __read = (this && this.__read) || function (o, n) {
 import { nodeInput } from '../graph/base-node';
 import { StrategyType } from '.';
 import { generateFiller } from '../util/ast';
+import { renameBinding } from '@shaderfrog/glsl-parser/parser/utils';
 export var uniformStrategy = function () { return ({
     type: StrategyType.UNIFORM,
     config: {},
@@ -127,64 +139,50 @@ var mapUniformType = function (type) {
     }
     // console.log(`Unknown uniform type, can't map to graph: ${type}`);
 };
-export var applyUniformStrategy = function (strategy, ast, graphNode, siblingNode) {
+var isUniformDeclaration = function (node) {
+    var _a, _b, _c;
+    return node.type === 'declaration_statement' &&
+        node.declaration.type === 'declarator_list' &&
+        !!((_c = (_b = (_a = node.declaration) === null || _a === void 0 ? void 0 : _a.specified_type) === null || _b === void 0 ? void 0 : _b.qualifiers) === null || _c === void 0 ? void 0 : _c.find(function (n) { return n.token === 'uniform'; }));
+};
+// commented this out to allow for sampler2D uniforms to appear as inputs
+// && uniformType !== 'sampler2D'
+export var applyUniformStrategy = function (strategy, ast, graphNode) {
     var program = ast;
-    return (program.program || []).flatMap(function (node) {
-        var _a, _b, _c, _d, _e, _f, _g;
+    return (program.program || [])
+        .filter(isUniformDeclaration)
+        .flatMap(function (node) {
+        var _a, _b, _c;
+        var declaration = node.declaration;
         // 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;
+        // TODO: File VSCode bug, this is highlighted like a function
+        var uniformType = (_c = (_b = (_a = declaration === null || declaration === void 0 ? void 0 : declaration.specified_type) === null || _a === void 0 ? void 0 : _a.specifier) === null || _b === void 0 ? void 0 : _b.specifier) === null || _c === void 0 ? void 0 : _c.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, ['code', 'data'], true),
-                function (filler) {
-                    //const mangledName = mangleName(name, graphNode, siblingNode);
-                    var mangledName = name;
-                    // 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 [];
+        var declarations = declaration.declarations;
+        // Capture the uniform names, and then capture their references in the
+        // closure. This allows the scope binding to be renamed when the AST is
+        // mangled, but this strategy can still find the original named variables
+        // to work with
+        var names = declarations.map(function (d) { return d.identifier.identifier; });
+        var references = names.reduce(function (acc, name) {
+            var _a;
+            return (__assign(__assign({}, acc), (_a = {}, _a[name] = program.scopes[0].bindings[name], _a)));
+        }, {});
+        return names.map(function (name) { return [
+            nodeInput(name, "uniform_".concat(name), 'uniform', graphDataType, ['code', 'data'], true),
+            function (filler) {
+                // Remove the declaration line, or the declared uniform
+                if (declarations.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 !== name; });
+                }
+                // Rename all the references to said uniform
+                renameBinding(references[name], generateFiller(filler()));
+                return ast;
+            },
+        ]; });
     });
 };

package/strategy/variable.js

@@ -35,7 +35,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 import { nodeInput } from '../graph/base-node';
-import { StrategyType } from '.';
+import { StrategyType, } from '.';
 import { generateFiller } from '../util/ast';
 export var variableStrategy = function () { return ({
     type: StrategyType.VARIABLE,
@@ -48,15 +48,15 @@ export var applyVariableStrategy = function (strategy, ast, graphNode, siblingNo
             var identifier, replacer;
             if (ref.type === 'declaration') {
                 identifier = ref.identifier.identifier;
-                replacer = function (fillerAst) {
-                    ref.identifier.identifier = generateFiller(fillerAst);
+                replacer = function (filler) {
+                    ref.identifier.identifier = generateFiller(filler());
                     return ast;
                 };
             }
             else if (ref.type === 'identifier') {
                 identifier = ref.identifier;
-                replacer = function (fillerAst) {
-                    ref.identifier = generateFiller(fillerAst);
+                replacer = function (filler) {
+                    ref.identifier = generateFiller(filler());
                     return ast;
                 };
                 // } else if (ref.type === 'parameter_declaration') {

package/util/ast.d.ts

@@ -1,8 +1,10 @@
+/**
+ * Utility functions to work with ASTs
+ */
 import { AstNode, ExpressionStatementNode, FunctionNode, DeclarationStatementNode, DeclarationNode } from '@shaderfrog/glsl-parser/ast';
 import { Program } from '@shaderfrog/glsl-parser/ast';
 import { ShaderStage } from '../graph/graph-types';
 import { Scope } from '@shaderfrog/glsl-parser/parser/scope';
-import { Filler } from '../graph/parsers';
 export interface FrogProgram extends Program {
     outVar?: string;
 }
@@ -10,7 +12,7 @@ export declare const findVec4Constructor: (ast: AstNode) => AstNode | undefined;
 export declare const findAssignmentTo: (ast: AstNode | Program, assignTo: string, nth?: number) => DeclarationNode | ExpressionStatementNode | undefined;
 export declare const findDeclarationOf: (ast: AstNode | Program, declarationOf: string) => DeclarationNode | undefined;
 export declare const from2To3: (ast: Program, stage: ShaderStage) => void;
-export declare const makeStatement: (stmt: string) => readonly [DeclarationStatementNode | FunctionNode | import("@shaderfrog/glsl-parser/ast").PreprocessorNode, Scope];
+export declare const makeStatement: (stmt: string, ws?: string) => readonly [DeclarationStatementNode | FunctionNode | import("@shaderfrog/glsl-parser/ast").PreprocessorNode, Scope];
 export declare const makeFnStatement: (fnStmt: string) => readonly [AstNode, Scope];
 /**
  * Add a new scope into an existing one. Meant to be used for adding net new
@@ -46,4 +48,6 @@ export declare const returnGlPositionVec3Right: (fnName: string, ast: Program) =
  * returns a vec4.
  */
 export declare const convert300MainToReturn: (ast: FrogProgram) => void;
-export declare const generateFiller: (filler: Filler) => string;
+export declare const generateFiller: (ast: AstNode | AstNode[] | void) => string;
+export declare const isDeclarationStatement: (node: Program["program"][0]) => node is DeclarationStatementNode;
+export declare const backfillAst: (ast: Program, fromType: string, targetVariable: string, mainFn?: FunctionNode) => Program;