@shaderfrog/core 2.0.0-beta.3 → 2.0.1

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) {
@@ -41,12 +52,14 @@ import { generate } from '@shaderfrog/glsl-parser';
 import { addNode, outputNode, sourceNode } from './graph-node';
 import { shaderSectionsToProgram, mergeShaderSections, findShaderSections, } 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));
 };
@@ -65,9 +78,7 @@ var dedupe = function (code) {
         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);

package/graph/parsers.d.ts

@@ -1,20 +1,11 @@
 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';
 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 ManipulateAst = (engineContext: EngineContext, engine: Engine, graph: Graph, ast: AstNode | Program, inputEdges: Edge[], node: SourceNode, sibling: SourceNode) => AstNode | Program;
@@ -24,7 +15,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.
@@ -109,11 +110,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 +138,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 +168,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 +185,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

@@ -13,7 +13,7 @@ export interface ShaderSections {
     uniforms: DeclarationStatementNode[];
     program: AstNode[];
 }
-export declare const emptyShaderSections: () => ShaderSections;
+export declare const shaderSectionsCons: () => ShaderSections;
 declare enum Precision {
     highp = 2,
     mediump = 1,

package/graph/shader-sections.js

@@ -36,7 +36,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import { generate } from '@shaderfrog/glsl-parser';
 import { makeStatement } from '../util/ast';
-export var emptyShaderSections = function () { return ({
+export var shaderSectionsCons = function () { return ({
     precision: [],
     preprocessor: [],
     version: [],

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaderfrog/core",
-  "version": "2.0.0-beta.3",
+  "version": "2.0.1",
   "description": "Shaderfrog core",
   "type": "module",
   "files": [
@@ -34,13 +34,13 @@
     "@babel/core": "^7.21.8",
     "@babel/preset-env": "^7.21.5",
     "@babel/preset-typescript": "^7.21.5",
-    "@shaderfrog/glsl-parser": "^5.0.0-beta.4",
+    "@shaderfrog/glsl-parser": "^5.2.0",
     "@swc/core": "^1.6.7",
     "@types/lodash.groupby": "^4.6.7",
-    "@types/three": "^0.156.0",
+    "@types/three": "^0.169.0",
     "babylonjs": "^6.2.0",
     "prettier": "^3.3.2",
-    "three": "^0.156.1",
+    "three": "^0.169.0",
     "typescript": "^5.5.3",
     "vitest": "^1.6.0"
   },

package/plugins/babylon/bablyengine.js

@@ -531,7 +531,6 @@ export var babylengine = {
         'normal',
         'uv',
         'world',
-        'time',
         'Light0',
         'Light1',
         'Light2',
@@ -555,6 +554,10 @@ export var babylengine = {
         'vSphericalL22',
         'vAlbedoInfos',
         'reflectionSampler',
+        // passed by shaderfrog. maybe should have separate names? duplicated across
+        // all the engines.
+        'time',
+        'renderResolution',
     ]),
     parsers: (_b = {},
         _b[NodeType.SOURCE] = {

package/plugins/playcanvas/playengine.js

@@ -472,7 +472,6 @@ export var playengine = {
         'matrix_normal',
         'matrix_view',
         'matrix_viewProjection',
-        'time',
         'vertex_color',
         'vertex_normal',
         'vertex_position',
@@ -483,6 +482,10 @@ export var playengine = {
         'vNormalW',
         'vPositionW',
         'vUv0',
+        // passed by shaderfrog. maybe should have separate names? duplicated across
+        // all the engines.
+        'time',
+        'renderResolution',
     ]),
     parsers: (_b = {},
         _b[NodeType.SOURCE] = {

package/plugins/three/importers.d.ts

@@ -1,3 +1,4 @@
 import { EngineImporters } from '../../engine';
+export declare const defaultShadertoyVertex = "\nprecision highp float;\nprecision highp int;\n\nattribute vec3 position;\nattribute vec2 uv;\nvarying vec2 vUv;\n\nvoid main() {\n  vUv = uv;\n  gl_Position = vec4(position * 2.0, 1.0);\n}\n";
 declare const importers: EngineImporters;
 export default importers;

package/plugins/three/importers.js

@@ -1,5 +1,53 @@
-import { renameBindings } from '@shaderfrog/glsl-parser/parser/utils';
+import { renameBindings, renameFunction, } from '@shaderfrog/glsl-parser/parser/utils';
+import { findMainOrThrow, makeStatement } from '../../util/ast';
+export var defaultShadertoyVertex = "\nprecision highp float;\nprecision highp int;\n\nattribute vec3 position;\nattribute vec2 uv;\nvarying vec2 vUv;\n\nvoid main() {\n  vUv = uv;\n  gl_Position = vec4(position * 2.0, 1.0);\n}\n";
 var importers = {
+    shadertoy: {
+        code: {
+            defaultShadertoyVertex: defaultShadertoyVertex,
+        },
+        convertAst: function (ast, type) {
+            ast.program.unshift(makeStatement('uniform vec2 renderResolution', '\n')[0]);
+            // These do not catch variables in preprocessor definitions! See "SAD HACK"
+            //if (ast.scopes.some((s) => 'iTime' in s.bindings)) {
+            ast.program.unshift(makeStatement('uniform float time')[0]);
+            //}
+            //if (ast.scopes.some((s) => 'iMouse' in s.bindings)) {
+            ast.program.unshift(makeStatement('uniform vec2 mouse')[0]);
+            //}
+            ast.program.unshift(makeStatement('precision highp int', '\n')[0]);
+            ast.program.unshift(makeStatement('precision highp float')[0]);
+            ast.scopes[0].functions.main = renameFunction(ast.scopes[0].functions.mainImage, 'main');
+            var main = findMainOrThrow(ast);
+            main.prototype.parameters = [];
+            main.prototype.header.lp.whitespace = '';
+            main.prototype.rp.whitespace = ' ';
+            // These renames do not catch variables in preprocessor definitions! See
+            // "SAD HACK" comment in Editor.tsx
+            for (var i = 0; i < ast.scopes.length; i++) {
+                ast.scopes[i].bindings = renameBindings(ast.scopes[i].bindings, function (name) {
+                    if (name === 'iTime') {
+                        return 'time';
+                    }
+                    if (name === 'iMouse') {
+                        return 'mouse';
+                    }
+                    if (name === 'iResolution') {
+                        return 'renderResolution';
+                    }
+                    if (name === 'fragColor') {
+                        return 'gl_FragColor';
+                    }
+                    if (name === 'fragCoord') {
+                        return 'gl_FragCoord.xy';
+                    }
+                    return name;
+                });
+            }
+        },
+        nodeInputMap: {},
+        edgeMap: {},
+    },
     babylon: {
         convertAst: function (ast, type) {
             ast.scopes[0].bindings = renameBindings(ast.scopes[0].bindings, function (name) {

package/plugins/three/threngine.js

@@ -460,7 +460,6 @@ export var threngine = {
         'opacity',
         'map',
         'specularTint',
-        'time',
         'normalScale',
         'normalMap',
         'envMap',
@@ -502,6 +501,10 @@ export var threngine = {
         'displacementMap',
         'displacementScale',
         'displacementBias',
+        // passed by shaderfrog. maybe should have separate names? duplicated across
+        // all the engines.
+        'time',
+        'renderResolution',
     ]),
     parsers: (_b = {},
         _b[NodeType.SOURCE] = {
@@ -561,7 +564,7 @@ export var threngine = {
 };
 export var createMaterial = function (compileResult, ctx) {
     var engineMaterial = ctx.runtime.engineMaterial;
-    var finalUniforms = __assign(__assign(__assign(__assign({}, ShaderLib.phong.uniforms), ShaderLib.toon.uniforms), ShaderLib.physical.uniforms), { time: { value: 0 }, cameraPosition: { value: new Vector3(1.0) } });
+    var finalUniforms = __assign(__assign(__assign(__assign({}, ShaderLib.phong.uniforms), ShaderLib.toon.uniforms), ShaderLib.physical.uniforms), { time: { value: 0 }, cameraPosition: { value: new Vector3(1.0) }, renderResolution: { value: new Vector2(1.0) } });
     // Also the ThreeComponent's sceneConfig properties modify the material
     var initialProperties = {
         name: 'ShaderFrog Material',