@shaderfrog/core 2.0.0-beta.3 → 3.0.0

package/graph/graph.test.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 __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -39,20 +50,22 @@ import util from 'util';
 import { parser } from '@shaderfrog/glsl-parser';
 import { generate } from '@shaderfrog/glsl-parser';
 import { addNode, outputNode, sourceNode } from './graph-node';
-import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, } from './shader-sections';
+import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, extractSource, filterUniformNames, filterQualifiedStatements, } from './shader-sections';
 import { numberNode } from './data-nodes';
-import { makeEdge } from './edge';
+import { linkFromVertToFrag, makeEdge } from './edge';
 import { evaluateNode } from './evaluate';
-import { compileSource } from './graph';
+import { compileSource, nodeName } from './graph';
 import { texture2DStrategy } from '../strategy';
 import { isError } from './context';
 import { fail } from '../test-util';
+import { SourceType } from './code-nodes';
+import { makeId } from 'src/util/id';
 var inspect = function (thing) {
     return console.log(util.inspect(thing, false, null, true));
 };
 var mergeBlocks = function (ast1, ast2) {
-    var s1 = findShaderSections(ast1);
-    var s2 = findShaderSections(ast2);
+    var s1 = findShaderSections('', ast1);
+    var s2 = findShaderSections('', ast2);
     var merged = mergeShaderSections(s1, s2);
     return generate(shaderSectionsToProgram(merged, {
         includePrecisions: true,
@@ -60,14 +73,12 @@ var mergeBlocks = function (ast1, ast2) {
     }));
 };
 var dedupe = function (code) {
-    return generate(shaderSectionsToProgram(findShaderSections(parser.parse(code)), {
+    return generate(shaderSectionsToProgram(findShaderSections('', parser.parse(code)), {
         includePrecisions: true,
         includeVersion: true,
     }));
 };
-var counter = 0;
 var p = { x: 0, y: 0 };
-var id = function () { return '' + counter++; };
 var constructor = function () { return ({
     config: {
         version: 3,
@@ -103,7 +114,7 @@ var engine = {
         includeVersion: true,
     },
     importers: {},
-    preserve: new Set(),
+    preserve: new Set('vUv'),
     parsers: {},
 };
 var makeSourceNode = function (id, source, stage, strategies) {
@@ -115,45 +126,22 @@ var makeSourceNode = function (id, source, stage, strategies) {
         uniforms: [],
     }, source, stage);
 };
-/**
- * What exactly am I doing here?
- *
- * I opened shaderfrog to start looking at the backfilling case and inlining
- * function calls at the top of functions
- *
- * WHie doing that I found jest not to work well anyore and switched to vitest,
- * which is fine, but with esm by default I can't stub the mangleName() function
- * call, which means mangling happens as-is in the tests.
- *
- * Without changing the mangling strategy, the strategies.test.ts file fails
- * because the uniform strategy looks for a mangled variable name, but the
- * program itself isn't mangled.
- *
- * One way to fix this is to make fillers not have to care about mangling names,
- * which would be simpler on the surface.
- *
- * Then everything in the tests broke and you found out the reason why was
- * trying to use scopes to rename things, and most of the ast manipulation steps
- * don't modify scopes, so you made some of them modify scopes, and now things
- * are fucked
- */
-it('compileSource() fragment produces inlined output', function () { return __awaiter(void 0, void 0, void 0, function () {
+it('compileSource() fragment produces inlined output without', function () { return __awaiter(void 0, void 0, void 0, function () {
     var outV, outF, imageReplacemMe, input1, input2, graph, engineContext, result, imgOut;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                outV = outputNode(id(), 'Output v', p, 'vertex');
-                outF = outputNode(id(), 'Output f', p, 'fragment');
-                imageReplacemMe = makeSourceNode(id(), "uniform sampler2D image1;\nuniform sampler2D image2;\nvoid main() {\n  vec3 col1 = texture2D(image1, posTurn - 0.4 * time).rgb + 1.0;\n  vec3 col2 = texture2D(image2, negTurn - 0.4 * time).rgb + 2.0;\n  gl_FragColor = vec4(col1 + col2, 1.0);\n}\n", 'fragment');
-                input1 = makeSourceNode(id(), "float a = 1.0;\nvoid main() {\n  gl_FragColor = vec4(0.0);\n}\n", 'fragment');
-                input2 = makeSourceNode(id(), "float a = 2.0;\nvoid main() {\n  gl_FragColor = vec4(1.0);\n}\n", 'fragment');
+                outV = outputNode(makeId(), 'Output v', p, 'vertex');
+                outF = outputNode(makeId(), 'Output f', p, 'fragment');
+                imageReplacemMe = makeSourceNode(makeId(), "uniform sampler2D image1;\nuniform sampler2D image2;\nvoid main() {\n  vec3 col1 = texture2D(image1, posTurn - 0.4 * time).rgb + 1.0;\n  vec3 col2 = texture2D(image2, negTurn - 0.4 * time).rgb + 2.0;\n  gl_FragColor = vec4(col1 + col2, 1.0);\n}\n", 'fragment');
+                input1 = makeSourceNode(makeId(), "float a = 1.0;\nvoid main() {\n  gl_FragColor = vec4(0.0);\n}\n", 'fragment');
+                input2 = makeSourceNode(makeId(), "float a = 2.0;\nvoid main() {\n  gl_FragColor = vec4(1.0);\n}\n", 'fragment');
                 graph = {
                     nodes: [outV, outF, imageReplacemMe, input1, input2],
                     edges: [
-                        makeEdge(id(), imageReplacemMe.id, outF.id, 'out', 'filler_frogFragOut', 'fragment'),
-                        makeEdge(id(), input1.id, imageReplacemMe.id, 'out', 'filler_image1', 'fragment'),
-                        makeEdge(id(), input2.id, imageReplacemMe.id, 'out', 'filler_image2', 'fragment'),
-                        makeEdge(id(), input2.id, imageReplacemMe.id, 'out', 'filler_image2', 'fragment'),
+                        makeEdge(makeId(), imageReplacemMe.id, outF.id, 'out', 'filler_frogFragOut', 'fragment'),
+                        makeEdge(makeId(), input1.id, imageReplacemMe.id, 'out', 'filler_image1', 'fragment'),
+                        makeEdge(makeId(), input2.id, imageReplacemMe.id, 'out', 'filler_image2', 'fragment'),
                     ],
                 };
                 engineContext = {
@@ -178,18 +166,206 @@ it('compileSource() fragment produces inlined output', function () { return __aw
         }
     });
 }); });
+it('compileSource() vertex produces inlined output', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var outV, outF, vert, graph, engineContext, result, iMainName;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                outV = outputNode(makeId(), 'Output v', p, 'vertex');
+                outF = outputNode(makeId(), 'Output f', p, 'fragment');
+                vert = makeSourceNode(makeId(), "uniform vec4 modelViewMatrix;\nattribute vec3 position;\nfloat a = 2.0;\nvoid main() {\n  gl_Position = modelViewMatrix * vec4(position, 1.0);\n}\n", 'vertex');
+                graph = {
+                    nodes: [outV, outF, vert],
+                    edges: [
+                        makeEdge(makeId(), vert.id, outV.id, 'out', 'filler_gl_Position', 'vertex'),
+                    ],
+                };
+                engineContext = {
+                    engine: 'three',
+                    nodes: {},
+                    runtime: {},
+                    debuggingNonsense: {},
+                };
+                return [4 /*yield*/, compileSource(graph, engine, engineContext)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    fail(result);
+                }
+                iMainName = nodeName(vert);
+                expect(result.vertexResult).toContain("\nvoid main() {\n  gl_Position = ".concat(iMainName, "();\n}"));
+                return [2 /*return*/];
+        }
+    });
+}); });
+it('compileSource() fragment backfilling one level', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var outV, outF, imageReplacemMe, input1, graph, engineContext, preserver, result, inputMain, imageMain;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                outV = outputNode(makeId(), 'Output v', p, 'vertex');
+                outF = outputNode(makeId(), 'Output f', p, 'fragment');
+                imageReplacemMe = makeSourceNode(makeId(), "attribute vec2 vUv;\nuniform sampler2D image1;\nuniform sampler2D image2;\nvoid main() {\n  vec3 col1 = texture2D(image1, vUv - 0.4 * time).rgb + 1.0;\n  vec3 other1 = texture2D(image1, vUv + 1.0).rgb;\n  vec3 col2 = texture2D(image2, negTurn - 0.4 * time).rgb + 2.0;\n  gl_FragColor = vec4(col1 + col2, 1.0);\n}\n", 'fragment');
+                imageReplacemMe.backfillers = {
+                    filler_image1: [
+                        {
+                            argType: 'vec2',
+                            targetVariable: 'vUv',
+                        },
+                    ],
+                };
+                input1 = makeSourceNode(makeId(), "attribute vec2 vUv;\nvoid main() {\n  gl_FragColor = vec4(vUv, 1.0, 1.0);\n}\n", 'fragment');
+                graph = {
+                    nodes: [outV, outF, imageReplacemMe, input1],
+                    edges: [
+                        makeEdge(makeId(), imageReplacemMe.id, outF.id, 'out', 'filler_frogFragOut', 'fragment'),
+                        makeEdge(makeId(), input1.id, imageReplacemMe.id, 'out', 'filler_image1', 'fragment'),
+                    ],
+                };
+                engineContext = {
+                    engine: 'three',
+                    nodes: {},
+                    runtime: {},
+                    debuggingNonsense: {},
+                };
+                preserver = __assign(__assign({}, engine), { preserve: new Set(['vUv']) });
+                return [4 /*yield*/, compileSource(graph, preserver, engineContext)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    fail(result);
+                }
+                inputMain = nodeName(input1);
+                imageMain = nodeName(imageReplacemMe);
+                // Should preserve global variable despite backfilling
+                expect(result.fragmentResult).toContain("in vec2 vUv;");
+                // Backfilled variable should be in the main fn parameters
+                // I don't think is inlined? I think this is expected by convertToMain
+                expect(result.fragmentResult).toContain("\nvec4 ".concat(inputMain, "(vec2 vUv) {\n  frogOut_").concat(input1.id, " = vec4(vUv, 1.0, 1.0);\n  return frogOut_").concat(input1.id, ";\n}"));
+                // The image function should pass its parameters to the child
+                expect(result.fragmentResult).toContain("\nvec4 ".concat(imageMain, "() {\n  vec3 col1 = ").concat(inputMain, "(vUv - 0.4 * time).rgb + 1.0;\n  vec3 other1 = ").concat(inputMain, "(vUv + 1.0).rgb;\n  vec3 col2 = texture(image2"));
+                return [2 /*return*/];
+        }
+    });
+}); });
+it('compileSource() orphaned vertex nodes are called properly in output', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var outV, outF, vert, frag, graph, engineContext, result, iMainName;
+    return __generator(this, function (_a) {
+        switch (_a.label) {
+            case 0:
+                outV = outputNode(makeId(), 'Output v', p, 'vertex');
+                outF = outputNode(makeId(), 'Output f', p, 'fragment');
+                vert = makeSourceNode(makeId(), "uniform vec4 modelViewMatrix;\nattribute vec3 position;\nfloat a = 2.0;\nvoid main() {\n  gl_Position = modelViewMatrix * vec4(position, 1.0);\n}\n", 'vertex');
+                frag = makeSourceNode(makeId(), "attribute vec2 vUv;\nvoid main() {\n  gl_FragColor = vec4(vUv, 0.0, 1.0);\n}\n", 'fragment');
+                graph = {
+                    nodes: [outV, outF, frag, vert],
+                    edges: [
+                        makeEdge(makeId(), frag.id, outF.id, 'out', 'filler_frogFragOut', 'fragment'),
+                        linkFromVertToFrag(makeId(), vert.id, frag.id),
+                    ],
+                };
+                engineContext = {
+                    engine: 'three',
+                    nodes: {},
+                    runtime: {},
+                    debuggingNonsense: {},
+                };
+                return [4 /*yield*/, compileSource(graph, engine, engineContext)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    fail(result);
+                }
+                iMainName = nodeName(vert);
+                expect(result.vertexResult).toContain("\nvoid main() {\n  ".concat(iMainName, "();\n  gl_Position = vec4(1.0);\n}"));
+                return [2 /*return*/];
+        }
+    });
+}); });
+it('compileSource() inlining a fragment expression', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var outV, outF, imageReplacemMe, input, 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');
+                imageReplacemMe = makeSourceNode(makeId(), "uniform sampler2D image1;\nvoid main() {\n  vec3 col1 = texture2D(image1, posTurn - 0.4 * time).rgb + 1.0;\n  gl_FragColor = vec4(col1, 1.0);\n}\n", 'fragment');
+                input = makeSourceNode(makeId(), "vec4(1.0)", 'fragment');
+                input.sourceType = SourceType.EXPRESSION;
+                graph = {
+                    nodes: [outV, outF, imageReplacemMe, input],
+                    edges: [
+                        makeEdge(makeId(), imageReplacemMe.id, outF.id, 'out', 'filler_frogFragOut', 'fragment'),
+                        makeEdge(makeId(), input.id, imageReplacemMe.id, 'out', 'filler_image1', 'fragment'),
+                    ],
+                };
+                engineContext = {
+                    engine: 'three',
+                    nodes: {},
+                    runtime: {},
+                    debuggingNonsense: {},
+                };
+                return [4 /*yield*/, compileSource(graph, engine, engineContext)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    fail(result);
+                }
+                // Verify it inlined the expression and did not memoize the source into a
+                // varaible
+                expect(result.fragmentResult).toContain("vec4 ".concat(nodeName(imageReplacemMe), "() {\n  vec3 col1 = vec4(1.0).rgb + 1.0;"));
+                return [2 /*return*/];
+        }
+    });
+}); });
+it('compileSource() binary properly inlines dependencies', function () { return __awaiter(void 0, void 0, void 0, function () {
+    var outV, outF, color, expr, add, 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');
+                color = makeSourceNode(makeId(), "uniform sampler2D image;\nvoid main() {\n  vec3 col = texture2D(image, vec2(0.0)).rgb;\n  gl_FragColor = vec4(col, 1.0);\n}\n", 'fragment');
+                expr = makeSourceNode(makeId(), "vec4(1.0)", 'fragment');
+                expr.sourceType = SourceType.EXPRESSION;
+                add = addNode(makeId(), p);
+                graph = {
+                    nodes: [color, expr, add, outV, outF],
+                    edges: [
+                        makeEdge(makeId(), color.id, add.id, 'out', 'a'),
+                        makeEdge(makeId(), expr.id, add.id, 'out', 'b'),
+                        makeEdge(makeId(), add.id, outF.id, 'out', 'filler_frogFragOut', 'fragment'),
+                    ],
+                };
+                engineContext = {
+                    engine: 'three',
+                    nodes: {},
+                    runtime: {},
+                    debuggingNonsense: {},
+                };
+                return [4 /*yield*/, compileSource(graph, engine, engineContext)];
+            case 1:
+                result = _a.sent();
+                if (isError(result)) {
+                    fail(result);
+                }
+                expect(result.fragmentResult).toContain("void main() {\n  frogFragOut = (".concat(nodeName(color), "()+ vec4(1.0));\n}"));
+                return [2 /*return*/];
+        }
+    });
+}); });
 it('compileSource() base case', function () { return __awaiter(void 0, void 0, void 0, function () {
     var outV, outF, imageReplacemMe, graph, engineContext, result, imgOut;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0:
-                outV = outputNode(id(), 'Output v', p, 'vertex');
-                outF = outputNode(id(), 'Output f', p, 'fragment');
-                imageReplacemMe = makeSourceNode(id(), "float a = 1.0;\nvoid main() {\n  gl_FragColor = vec4(1.0);\n}\n", 'fragment');
+                outV = outputNode(makeId(), 'Output v', p, 'vertex');
+                outF = outputNode(makeId(), 'Output f', p, 'fragment');
+                imageReplacemMe = makeSourceNode(makeId(), "float a = 1.0;\nvoid main() {\n  gl_FragColor = vec4(1.0);\n}\n", 'fragment');
                 graph = {
                     nodes: [outV, outF, imageReplacemMe],
                     edges: [
-                        makeEdge(id(), imageReplacemMe.id, outF.id, 'out', 'filler_frogFragOut', 'fragment'),
+                        makeEdge(makeId(), imageReplacemMe.id, outF.id, 'out', 'filler_frogFragOut', 'fragment'),
                     ],
                 };
                 engineContext = {
@@ -214,18 +390,18 @@ it('compileSource() base case', function () { return __awaiter(void 0, void 0, v
 }); });
 describe('evaluateNode()', function () {
     it('evaluates binary nodes', function () {
-        var finalAdd = addNode(id(), p);
-        var add2 = addNode(id(), p);
-        var num1 = numberNode(id(), 'number', p, '3');
-        var num2 = numberNode(id(), 'number', p, '5');
-        var num3 = numberNode(id(), 'number', p, '7');
+        var finalAdd = addNode(makeId(), p);
+        var add2 = addNode(makeId(), p);
+        var num1 = numberNode(makeId(), 'number', p, '3');
+        var num2 = numberNode(makeId(), 'number', p, '5');
+        var num3 = numberNode(makeId(), 'number', p, '7');
         var graph = {
             nodes: [num1, num2, num3, finalAdd, add2],
             edges: [
-                makeEdge(id(), num1.id, finalAdd.id, 'out', 'a'),
-                makeEdge(id(), add2.id, finalAdd.id, 'out', 'b'),
-                makeEdge(id(), num2.id, add2.id, 'out', 'a'),
-                makeEdge(id(), num3.id, add2.id, 'out', 'b'),
+                makeEdge(makeId(), num1.id, finalAdd.id, 'out', 'a'),
+                makeEdge(makeId(), add2.id, finalAdd.id, 'out', 'b'),
+                makeEdge(makeId(), num2.id, add2.id, 'out', 'a'),
+                makeEdge(makeId(), num3.id, add2.id, 'out', 'b'),
             ],
         };
         expect(evaluateNode(engine, graph, finalAdd)).toBe(15);
@@ -259,3 +435,17 @@ it('should merge uniforms with interface blocks', function () {
     // Verify these lines are preserved (they go through dedupeUniforms)
     expect(dedupe("layout(std140,column_major) uniform;")).toEqual("layout(std140,column_major) uniform;");
 });
+it('filterUniformNames', function () {
+    var stmts = parser
+        .parse("uniform vec4 x,y;\nuniform vec2 x, y[5];\nuniform Light0 { vec4 y; } x;\nuniform Light0 { vec4 x; } y;\n")
+        .program.filter(function (s) { return s.type === 'declaration_statement'; });
+    var filtered = filterUniformNames(stmts.map(function (x) { return ({ nodeId: '', source: x }); }), function (name) { return name !== 'x'; });
+    expect(generate(extractSource(filtered))).toEqual("uniform vec4 y;\nuniform vec2 y[5];\nuniform Light0 { vec4 x; } y;\n");
+});
+it('filterQualifiedStatements', function () {
+    var stmts = parser
+        .parse("in vec2 x, y;\nout vec2 x;\n")
+        .program.filter(function (s) { return s.type === 'declaration_statement'; });
+    var filtered = filterQualifiedStatements(stmts.map(function (x) { return ({ nodeId: '', source: x }); }), function (name) { return name !== 'x'; });
+    expect(generate(extractSource(filtered))).toEqual("in vec2 y;\n");
+});

package/graph/parsers.d.ts

@@ -1,22 +1,14 @@
 import { AstNode, Program } from '@shaderfrog/glsl-parser/ast';
 import { Engine, EngineContext } from '../engine';
+import { ComputedInput, Filler } from '../strategy';
 import { Edge } from './edge';
 import { SourceNode } from './code-nodes';
-import { NodeInput } from './base-node';
 import { Graph } from './graph-types';
 import { Evaluate } from './evaluate';
+import { NodeContext } from './context';
 export declare const alphabet = "abcdefghijklmnopqrstuvwxyz";
-export type Filler = AstNode | AstNode[] | void;
-export type InputFiller = (filler: Filler) => AstNode | Program;
-export type InputFillerGroup = {
-    filler: InputFiller;
-    backfillArgs?: AstNode[];
-};
-export type InputFillers = Record<string, InputFillerGroup>;
-type FillerArguments = AstNode[];
-export type ComputedInput = [NodeInput, InputFiller, FillerArguments?];
 export type ProduceAst = (engineContext: EngineContext, engine: Engine, graph: Graph, node: SourceNode, inputEdges: Edge[]) => AstNode | Program;
-export type OnBeforeCompile = (graph: Graph, engineContext: EngineContext, node: SourceNode, sibling?: SourceNode) => Promise<void>;
+export type OnBeforeCompile = (graph: Graph, engineContext: EngineContext, node: SourceNode, sibling?: SourceNode) => Promise<Partial<NodeContext> | void>;
 export type ManipulateAst = (engineContext: EngineContext, engine: Engine, graph: Graph, ast: AstNode | Program, inputEdges: Edge[], node: SourceNode, sibling: SourceNode) => AstNode | Program;
 export type NodeParser = {
     onBeforeCompile?: OnBeforeCompile;
@@ -24,7 +16,7 @@ export type NodeParser = {
     findInputs?: FindInputs;
     produceFiller?: ProduceNodeFiller;
 };
-export type FindInputs = (engineContext: EngineContext, ast: Program | AstNode, inputEdges: Edge[], node: SourceNode, sibling: SourceNode) => ComputedInput[];
+export type FindInputs = (engineContext: EngineContext, ast: Program | AstNode, inputEdges: Edge[], node: SourceNode, sibling?: SourceNode) => ComputedInput[];
 export type ProduceNodeFiller = (node: SourceNode, ast: Program | AstNode) => Filler;
 type CoreNodeParser = {
     produceAst: ProduceAst;

package/graph/parsers.js

@@ -27,13 +27,14 @@ var _a;
 import { 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 '../util/ast';
+import { convert300MainToReturn, findMainOrThrow, from2To3, makeExpression, makeExpressionWithScopes, makeFnBodyStatementWithScopes, } from '../util/ast';
 import { applyStrategy } from '../strategy';
 import { SourceType } from './code-nodes';
 import { nodeInput } from './base-node';
 import { MAGIC_OUTPUT_STMTS, NodeType } from './graph-types';
 import { nodeName } from './graph';
 import { generateFiller } from '../util/ast';
+import { unshiftFnStmtWithIndent } from '../util/whitespace';
 /*
  * 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.
@@ -50,7 +51,11 @@ export var alphabet = 'abcdefghijklmnopqrstuvwxyz';
 export var coreParsers = (_a = {},
     _a[NodeType.SOURCE] = {
         produceAst: function (engineContext, engine, graph, node, inputEdges) {
+            var _a;
             var ast;
+            // Load the source either from the computed source at runtime, or the
+            // node's source code itself
+            var source = ((_a = engineContext.nodes[node.id]) === null || _a === void 0 ? void 0 : _a.computedSource) || node.source;
             // @ts-ignore
             if (node.expressionOnly) {
                 node.sourceType = SourceType.EXPRESSION;
@@ -58,7 +63,7 @@ export var coreParsers = (_a = {},
                 delete node.expressionOnly;
             }
             if (node.sourceType === SourceType.FN_BODY_FRAGMENT) {
-                var _a = makeFnBodyStatementWithScopes(node.source), statements = _a.statements, scope = _a.scope;
+                var _b = makeFnBodyStatementWithScopes(source), statements = _b.statements, scope = _b.scope;
                 ast = {
                     type: 'program',
                     scopes: [scope],
@@ -67,7 +72,7 @@ export var coreParsers = (_a = {},
                 };
             }
             else if (node.sourceType === SourceType.EXPRESSION) {
-                var _b = makeExpressionWithScopes(node.source), expression = _b.expression, scope = _b.scope;
+                var _c = makeExpressionWithScopes(source), expression = _c.expression, scope = _c.scope;
                 ast = {
                     type: 'program',
                     scopes: [scope],
@@ -77,8 +82,8 @@ export var coreParsers = (_a = {},
             }
             else {
                 var preprocessed = node.config.preprocess === false
-                    ? node.source
-                    : preprocess(node.source, {
+                    ? source
+                    : preprocess(source, {
                         preserve: {
                             version: function () { return true; },
                         },
@@ -109,11 +114,20 @@ export var coreParsers = (_a = {},
             });
         },
         produceFiller: function (node, ast) {
-            return node.sourceType === SourceType.EXPRESSION
-                ? ast.program[0]
-                : node.sourceType === SourceType.FN_BODY_FRAGMENT
-                    ? ast.program
-                    : makeExpression("".concat(nodeName(node), "()"));
+            return function () {
+                var args = [];
+                for (var _i = 0; _i < arguments.length; _i++) {
+                    args[_i] = arguments[_i];
+                }
+                var fillerNode = node.sourceType === SourceType.EXPRESSION
+                    ? ast.program[0]
+                    : node.sourceType === SourceType.FN_BODY_FRAGMENT
+                        ? ast.program
+                        : // Backfilling into the call of this program's filler.
+                            // Similar to texutre2D.ts filler
+                            makeExpression("".concat(nodeName(node), "(").concat(args.join(', '), ")"));
+                return fillerNode;
+            };
         },
     },
     // TODO: Output node assumes strategies are still passed in on node creation,
@@ -128,16 +142,16 @@ export var coreParsers = (_a = {},
             })), false), [
                 [
                     nodeInput(MAGIC_OUTPUT_STMTS, "filler_".concat(MAGIC_OUTPUT_STMTS), 'filler', 'rgba', ['code'], false),
-                    function (fillerAst) {
-                        var fn = ast.program.find(function (stmt) { return stmt.type === 'function'; });
-                        fn === null || fn === void 0 ? void 0 : fn.body.statements.unshift(makeFnStatement(generateFiller(fillerAst))[0]);
+                    function (filler) {
+                        var main = findMainOrThrow(ast);
+                        main.body.statements = unshiftFnStmtWithIndent(main, generateFiller(filler()));
                         return ast;
                     },
                 ],
             ], false);
         },
         produceFiller: function (node, ast) {
-            return makeExpression('impossible_call()');
+            return function () { return makeExpression('impossible_call()'); };
         },
     },
     _a[NodeType.BINARY] = {
@@ -158,7 +172,7 @@ export var coreParsers = (_a = {},
                 var letter = alphabet.charAt(index);
                 return [
                     nodeInput(letter, letter, 'filler', undefined, ['data', 'code'], false),
-                    function (fillerAst) {
+                    function (filler) {
                         var foundPath;
                         var visitors = {
                             identifier: {
@@ -175,18 +189,18 @@ export var coreParsers = (_a = {},
                         }
                         if (foundPath.parent && foundPath.key) {
                             // @ts-ignore
-                            foundPath.parent[foundPath.key] = fillerAst;
+                            foundPath.parent[foundPath.key] = filler();
                             return ast;
                         }
                         else {
-                            return fillerAst;
+                            return filler();
                         }
                     },
                 ];
             });
         },
         produceFiller: function (node, ast) {
-            return ast;
+            return function () { return ast; };
         },
         evaluate: function (node, inputEdges, inputNodes, evaluateNode) {
             var operator = node.operator;

package/graph/shader-sections.d.ts

@@ -1,28 +1,45 @@
 /**
  * Categorizing / deduping parts of shaders to help merge them together
  */
-import { AstNode, DeclarationStatementNode, PreprocessorNode } from '@shaderfrog/glsl-parser/ast';
+import { DeclarationStatementNode, PreprocessorNode, ProgramStatement } from '@shaderfrog/glsl-parser/ast';
 import { Program } from '@shaderfrog/glsl-parser/ast';
+export type LineAndSource<T = any> = {
+    nodeId: string;
+    source: T;
+};
+export declare function extractSource<T>(lineAndSource: LineAndSource<T>): T;
+export declare function extractSource<T>(lineAndSource: LineAndSource<T>[]): T[];
 export interface ShaderSections {
-    precision: DeclarationStatementNode[];
-    version: AstNode[];
-    preprocessor: PreprocessorNode[];
-    structs: AstNode[];
-    inStatements: DeclarationStatementNode[];
-    outStatements: DeclarationStatementNode[];
-    uniforms: DeclarationStatementNode[];
-    program: AstNode[];
+    precision: LineAndSource<DeclarationStatementNode>[];
+    version: LineAndSource<PreprocessorNode>[];
+    preprocessor: LineAndSource<PreprocessorNode>[];
+    structs: LineAndSource<DeclarationStatementNode>[];
+    inStatements: LineAndSource<DeclarationStatementNode>[];
+    outStatements: LineAndSource<DeclarationStatementNode>[];
+    uniforms: LineAndSource<DeclarationStatementNode>[];
+    program: LineAndSource<ProgramStatement>[];
 }
-export declare const emptyShaderSections: () => ShaderSections;
+export declare const filterSections: (filter: (s: LineAndSource) => boolean, sections: ShaderSections) => ShaderSections;
+export declare const mapSections: (map: (s: LineAndSource) => LineAndSource, sections: ShaderSections) => ShaderSections;
+export declare const shaderSectionsCons: () => ShaderSections;
 declare enum Precision {
     highp = 2,
     mediump = 1,
     lowp = 0
 }
 export declare const higherPrecision: (p1: Precision, p2: Precision) => Precision;
-export declare const dedupeVersions: (nodes: AstNode[]) => AstNode;
+export declare const dedupeVersions: (nodes: PreprocessorNode[]) => PreprocessorNode;
 export declare const highestPrecisions: (nodes: DeclarationStatementNode[]) => DeclarationStatementNode[];
-export declare const dedupeQualifiedStatements: (statements: DeclarationStatementNode[], qualifier: string) => any;
+export declare const extractDeclarationNameAndType: (stmt: DeclarationStatementNode) => {
+    type: string;
+    names: string[];
+};
+export declare const filterQualifiedStatements: (statements: LineAndSource<DeclarationStatementNode>[], filter: (name: string) => boolean) => LineAndSource<DeclarationStatementNode>[];
+export declare const dedupeQualifiedStatements: (statements: DeclarationStatementNode[], qualifier: string) => ProgramStatement[];
+/**
+ * Remove uniform declarations by the variable names they declare
+ */
+export declare const filterUniformNames: (declarations: LineAndSource<DeclarationStatementNode>[], filter: (name: string) => boolean) => LineAndSource<DeclarationStatementNode>[];
 /**
  * Merge uniforms together into lists of identifiers under the same type.
  * There's special case handling for mixing of uniforms with "interface blocks"
@@ -32,7 +49,7 @@ export declare const dedupeQualifiedStatements: (statements: DeclarationStatemen
  * This function consumes uniforms as found by findShaderSections, so the
  * definitions must line up
  */
-export declare const dedupeUniforms: (statements: DeclarationStatementNode[]) => any;
+export declare const dedupeUniforms: (statements: DeclarationStatementNode[]) => DeclarationStatementNode[];
 export declare const mergeShaderSections: (s1: ShaderSections, s2: ShaderSections) => ShaderSections;
 export type MergeOptions = {
     includePrecisions: boolean;
@@ -43,5 +60,5 @@ export declare const shaderSectionsToProgram: (sections: ShaderSections, mergeOp
  * Group an AST into logical sections. The output of this funciton is consumed
  * by the dedupe methods, namely dedupeUniforms, so the data shapes are coupled
  */
-export declare const findShaderSections: (ast: Program) => ShaderSections;
+export declare const findShaderSections: (nodeId: string, ast: Program) => ShaderSections;
 export {};