@shaderfrog/core 2.0.1 → 3.0.1

package/graph/graph.js

@@ -73,12 +73,12 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 import { renameBindings, renameFunctions, } from '@shaderfrog/glsl-parser/parser/utils';
 import { computeGraphContext, isError, } from './context';
 import { shaderSectionsCons, findShaderSections, mergeShaderSections, shaderSectionsToProgram, } from './shader-sections';
-import { backfillAst, makeExpression, } from '../util/ast';
+import { backfillAst, makeExpression } from '../util/ast';
 import { ensure } from '../util/ensure';
 import { SourceType } from './code-nodes';
 import { nodeInput } from './base-node';
 import { makeId } from '../util/id';
-import { coreParsers } from './parsers';
+import { alphabet, coreParsers } from './parsers';
 import { toGlsl } from './evaluate';
 import { EdgeLink, MAGIC_OUTPUT_STMTS, NodeType, } from './graph-types';
 import { generate } from '@shaderfrog/glsl-parser';
@@ -173,9 +173,58 @@ export var resetGraphIds = function (graph) {
         edges: graph.edges.map(function (e) { return (__assign(__assign({}, e), { id: map(e.id), from: map(e.from), to: map(e.to) })); }),
     };
 };
-export var findLinkedNode = function (graph, id) {
-    var edgeLink = graph.edges.find(function (e) { return e.type === EdgeLink.NEXT_STAGE && (e.from === id || e.to === id); });
-    var otherId = (edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from) === id ? edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.to : edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from;
+/**
+ * A binary node automatically adds/removes inputs based on how many edges
+ * connect to it. If a binary node has edges to "a" and "b", removing the edge
+ * to "a" means the edge to "b" needs to be moved down to the "a" one. This
+ * function essentially groups edges by target node id, and resets the edge
+ * target to its index. This doesn't feel good to do here but I don't have a
+ * better idea at the moment. One reason the inputs to binary nodes are
+ * automatically updated after compile, but the edges are updated here
+ * at the editor layer, before compile. This also hard codes assumptions about
+ * (binary) node inputs into the graph, namely they can't have blank inputs.
+ */
+export var collapseBinaryGraphEdges = function (graph) {
+    // Find all edges that flow into a binary node, grouped by the target node's
+    // id, since we need to know the total number of edges per node first
+    var binaryEdges = graph.edges.reduce(function (acc, edge) {
+        var _a;
+        var toNode = findNode(graph, edge.to);
+        return toNode.type === NodeType.BINARY
+            ? __assign(__assign({}, acc), (_a = {}, _a[toNode.id] = __spreadArray(__spreadArray([], __read((acc[toNode.id] || [])), false), [edge], false), _a)) : acc;
+    }, {});
+    // Then collapse them
+    var updatedEdges = graph.edges.map(function (edge) {
+        return edge.to in binaryEdges
+            ? __assign(__assign({}, edge), { input: alphabet.charAt(binaryEdges[edge.to].indexOf(edge)) }) : edge;
+    });
+    return __assign(__assign({}, graph), { edges: updatedEdges });
+};
+/**
+ * Restrict edges so that an input handle can't have multiple edges going to it
+ */
+export var addEdgeAndPruneRestrictions = function (edges, newEdge) {
+    return edges
+        .filter(function (edge) {
+        // Prevent one input handle from having multiple inputs
+        return !(edge.to === newEdge.to && edge.input === newEdge.input);
+    })
+        .concat(newEdge);
+};
+/**
+ * Adds an edge to the graph and enforces graph edge business logic rules:
+ * - Makes sure "binary" (add/multiply) nodes edges are collapsed
+ * - Makes sure two edges can't flow into the same input.
+ * See also editor/flow-helpers.ts
+ */
+export var addGraphEdge = function (graph, newEdge) {
+    return collapseBinaryGraphEdges(__assign(__assign({}, graph), { edges: addEdgeAndPruneRestrictions(graph.edges, newEdge) }));
+};
+export var findLinkedNode = function (graph, nodeId) {
+    var edgeLink = graph.edges.find(function (e) {
+        return e.type === EdgeLink.NEXT_STAGE && (e.from === nodeId || e.to === nodeId);
+    });
+    var otherId = (edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from) === nodeId ? edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.to : edgeLink === null || edgeLink === void 0 ? void 0 : edgeLink.from;
     // Only source nodes can be linked, so cast it
     return graph.nodes.find(function (node) { return node.id === otherId; });
 };
@@ -204,12 +253,12 @@ export var findLinkedVertexNodes = function (graph, existingIds) {
 export var consSearchResult = function () { return ({
     nodes: {},
     inputs: {},
-    edges: [],
+    edges: {},
 }); };
 export var mergeSearchResults = function (a, b) { return ({
     nodes: __assign(__assign({}, a.nodes), b.nodes),
     inputs: __assign(__assign({}, a.inputs), b.inputs),
-    edges: __spreadArray(__spreadArray([], __read(a.edges), false), __read(b.edges), false),
+    edges: __assign(__assign({}, a.edges), b.edges),
 }); };
 /**
  * Create the inputs on a node from the properties. This used to be done at
@@ -237,23 +286,24 @@ export var filterGraphFromNode = function (graph, node, predicates, depth, lastR
         ? (_a = {}, _a[node.id] = node, _a) : {}));
     var accumulatedResult = __assign(__assign({}, lastResult), { nodes: __assign(__assign({}, lastResult.nodes), nodeAcc) });
     return inputEdges.reduce(function (acc, inputEdge) {
-        var _a;
+        var _a, _b;
         var input = inputs.find(function (i) { return i.id === inputEdge.input; });
         var fromNode = inputEdge ? ensureFromNode(graph, inputEdge) : undefined;
         var inputAcc = __assign(__assign({}, acc.inputs), (input &&
             predicates.input &&
             predicates.input(input, node, inputEdge, fromNode, lastResult)
             ? (_a = {}, _a[node.id] = __spreadArray(__spreadArray([], __read((acc.inputs[node.id] || [])), false), [input], false), _a) : {}));
-        var edgeAcc = __spreadArray(__spreadArray([], __read(acc.edges), false), __read((predicates.edge &&
+        var edgeAcc = __assign(__assign({}, acc.edges), (predicates.edge &&
             predicates.edge(input, node, inputEdge, fromNode, lastResult)
-            ? [inputEdge]
-            : [])), false);
+            ? (_b = {}, _b[inputEdge.id] = inputEdge, _b) : {}));
         // Add in the latest result of edges and inputs so that when we recurse into
         // the next node, it has the latest accumulator
         var intermediateAcc = __assign(__assign({}, acc), { inputs: inputAcc, edges: edgeAcc });
         if (inputEdge && fromNode && depth > 1) {
             var result = filterGraphFromNode(graph, fromNode, predicates, depth - 1, intermediateAcc);
-            return mergeSearchResults(intermediateAcc, result);
+            // The result is automatically the combination of the currenet acc and the
+            // result of the recursed data
+            return result;
         }
         else {
             return intermediateAcc;
@@ -263,13 +313,20 @@ export var filterGraphFromNode = function (graph, node, predicates, depth, lastR
 export var collectConnectedNodes = function (graph, node) {
     return filterGraphFromNode(graph, node, { node: function () { return true; } }).nodes;
 };
+var merge = function (a, b) {
+    var keys = new Set(__spreadArray(__spreadArray([], __read(Object.keys(a)), false), __read(Object.keys(b)), false));
+    return Array.from(keys).reduce(function (acc, key) {
+        var _a;
+        return (__assign(__assign({}, acc), (_a = {}, _a[key] = __spreadArray(__spreadArray([], __read((a[key] || [])), false), __read((b[key] || [])), false), _a)));
+    }, {});
+};
 export var filterGraphNodes = function (graph, nodes, filter, depth) {
     if (depth === void 0) { depth = Infinity; }
     return nodes.reduce(function (acc, node) {
         var result = filterGraphFromNode(graph, node, filter, depth);
         return {
             nodes: __assign(__assign({}, acc.nodes), result.nodes),
-            inputs: __assign(__assign({}, acc.inputs), result.inputs),
+            inputs: merge(acc.inputs, result.inputs),
             edges: __assign(__assign({}, acc.edges), result.edges),
         };
     }, consSearchResult());
@@ -294,9 +351,9 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
     var nodeContext = isDataNode(node)
         ? null
         : ensure(engineContext.nodes[node.id], "No node context found for \"".concat(node.name, "\" (id ").concat(node.id, ")!"));
-    var _b = (nodeContext || {}), ast = _b.ast, inputFillers = _b.inputFillers;
-    if (!inputs) {
-        throw new Error("I'm drunk and I think this case should be impossible");
+    var _b = nodeContext || {}, ast = _b.ast, inputFillers = _b.inputFillers;
+    if (!ast || !inputFillers) {
+        throw new Error("I'm drunk while writing this code, and I think this case should be impossible, so I'm going to throw an error and ignore it");
     }
     var compiledIds = activeIds;
     var inputEdges = edges.filter(function (edge) { return edge.to === node.id; });
@@ -324,7 +381,6 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
         .forEach(function (_a) {
         var _b, _c;
         var fromNode = _a.fromNode, input = _a.input;
-        // const [inputSections, fillerFn, childIds, childDeps] = compileNode(
         var _d = __read(compileNode(engine, graph, edges, engineContext, fromNode, activeIds), 3), inputSections = _d[0], fillerFn = _d[1], childIds = _d[2];
         if (!fillerFn) {
             throw new TypeError("Expected a filler ast from node ID ".concat(fromNode.id, " (").concat(fromNode.type, ") but none was returned"));
@@ -352,7 +408,12 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
                 inputFillers: inputFillers,
                 fillerName: fillerName,
             });
-            throw new Error("Node \"".concat(node.name, "\"").concat(node.stage ? " (".concat(node.stage, ")") : '', " has no filler for input \"").concat(input.displayName, "\" named ").concat(fillerName));
+            return;
+            // throw new Error(
+            //   `Node "${node.name}"${
+            //     (node as SourceNode).stage ? ` (${(node as SourceNode).stage})` : ''
+            //   } has no filler for input "${input.displayName}" named ${fillerName}`,
+            // );
         }
         // Test if it needs to be backfilled - this only goes one level deep
         // because we're only backfilling fromNode
@@ -380,7 +441,7 @@ export var compileNode = function (engine, graph, edges, engineContext, node, ac
         codeNode.sourceType === SourceType.EXPRESSION ||
         codeNode.sourceType === SourceType.FN_BODY_FRAGMENT
         ? shaderSectionsCons()
-        : findShaderSections(ast));
+        : findShaderSections(node.id, ast));
     var filler = isDataNode(node)
         ? function () { return makeExpression(toGlsl(node)); }
         : parser.produceFiller(node, ast);
@@ -452,7 +513,7 @@ export var collectNodeProperties = function (graph) {
     };
 };
 export var compileSource = function (graph, engine, ctx) { return __awaiter(void 0, void 0, void 0, function () {
-    var result, compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
+    var result, updatedNodeContext, updatedContext, compileResult, fragmentResult, vertexResult, dataInputs, dataNodes;
     return __generator(this, function (_a) {
         switch (_a.label) {
             case 0: return [4 /*yield*/, computeGraphContext(ctx, engine, graph)];
@@ -461,9 +522,10 @@ export var compileSource = function (graph, engine, ctx) { return __awaiter(void
                 if (isError(result)) {
                     return [2 /*return*/, result];
                 }
-                compileResult = compileGraph(ctx, engine, graph);
-                fragmentResult = generate(shaderSectionsToProgram(compileResult.fragment, engine.mergeOptions)
-                    .program);
+                updatedNodeContext = __assign(__assign({}, ctx.nodes), result);
+                updatedContext = __assign(__assign({}, ctx), { nodes: updatedNodeContext });
+                compileResult = compileGraph(updatedContext, engine, graph);
+                fragmentResult = generate(shaderSectionsToProgram(compileResult.fragment, engine.mergeOptions).program);
                 vertexResult = generate(shaderSectionsToProgram(compileResult.vertex, engine.mergeOptions).program);
                 dataInputs = filterGraphNodes(graph, [compileResult.outputFrag, compileResult.outputVert], { input: isDataInput }).inputs;
                 dataNodes = Object.entries(dataInputs).reduce(function (acc, _a) {
@@ -476,11 +538,13 @@ export var compileSource = function (graph, engine, ctx) { return __awaiter(void
                     }, acc);
                 }, {});
                 return [2 /*return*/, {
+                        updatedNodeContext: updatedNodeContext,
                         compileResult: compileResult,
                         fragmentResult: fragmentResult,
                         vertexResult: vertexResult,
                         dataNodes: dataNodes,
                         dataInputs: dataInputs,
+                        compileMs: '',
                     }];
         }
     });

package/graph/graph.test.js

@@ -50,7 +50,7 @@ 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 { linkFromVertToFrag, makeEdge } from './edge';
 import { evaluateNode } from './evaluate';
@@ -64,8 +64,8 @@ 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,
@@ -73,7 +73,7 @@ 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,
     }));
@@ -435,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

@@ -5,9 +5,10 @@ import { Edge } from './edge';
 import { SourceNode } from './code-nodes';
 import { Graph } from './graph-types';
 import { Evaluate } from './evaluate';
+import { NodeContext } from './context';
 export declare const alphabet = "abcdefghijklmnopqrstuvwxyz";
 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;

package/graph/parsers.js

@@ -51,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;
@@ -59,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],
@@ -68,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],
@@ -78,13 +82,13 @@ export var coreParsers = (_a = {},
             }
             else {
                 var preprocessed = node.config.preprocess === false
-                    ? node.source
-                    : preprocess(node.source, {
+                    ? source
+                    : preprocess(source, {
                         preserve: {
                             version: function () { return true; },
                         },
                     });
-                ast = parser.parse(preprocessed);
+                ast = parser.parse(preprocessed, { stage: node.stage });
                 if (node.config.version === 2 && node.stage) {
                     from2To3(ast, node.stage);
                 }

package/graph/shader-sections.d.ts

@@ -1,18 +1,26 @@
 /**
  * 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 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,
@@ -20,9 +28,18 @@ declare enum Precision {
     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 {};

package/graph/shader-sections.js

@@ -36,6 +36,31 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 };
 import { generate } from '@shaderfrog/glsl-parser';
 import { makeStatement } from '../util/ast';
+export function extractSource(lineAndSource) {
+    return Array.isArray(lineAndSource)
+        ? lineAndSource.map(function (l) { return l.source; })
+        : lineAndSource.source;
+}
+export var filterSections = function (filter, sections) { return ({
+    precision: sections.precision.filter(filter),
+    version: sections.version.filter(filter),
+    preprocessor: sections.preprocessor.filter(filter),
+    structs: sections.structs.filter(filter),
+    inStatements: sections.inStatements.filter(filter),
+    outStatements: sections.outStatements.filter(filter),
+    uniforms: sections.uniforms.filter(filter),
+    program: sections.program.filter(filter),
+}); };
+export var mapSections = function (map, sections) { return ({
+    precision: sections.precision.map(map),
+    version: sections.version.map(map),
+    preprocessor: sections.preprocessor.map(map),
+    structs: sections.structs.map(map),
+    inStatements: sections.inStatements.map(map),
+    outStatements: sections.outStatements.map(map),
+    uniforms: sections.uniforms.map(map),
+    program: sections.program.map(map),
+}); };
 export var shaderSectionsCons = function () { return ({
     precision: [],
     preprocessor: [],
@@ -65,18 +90,65 @@ export var highestPrecisions = function (nodes) {
         return makeStatement("precision ".concat(precision, " ").concat(typeName))[0];
     });
 };
+export var extractDeclarationNameAndType = function (stmt) {
+    var dec = stmt.declaration;
+    return {
+        type: dec.specified_type.specifier.specifier.token,
+        names: dec.declarations.map(function (decl) { return decl.identifier.identifier; }),
+    };
+};
+export var filterQualifiedStatements = function (statements, filter) {
+    return statements.reduce(function (acc, line) {
+        var stmt = line.source;
+        var dec = stmt.declaration;
+        var filtered = dec.declarations.filter(function (decl) {
+            return filter(decl.identifier.identifier);
+        });
+        return filtered.length
+            ? acc.concat(__assign(__assign({}, line), { source: __assign(__assign({}, line.source), { declaration: __assign(__assign({}, dec), { declarations: filtered }) }) }))
+            : acc;
+    }, []);
+};
 export var dedupeQualifiedStatements = function (statements, qualifier) {
-    return Object.entries(statements.reduce(function (stmts, stmt) {
+    return Object.entries(statements.reduce(function (indexed, stmt) {
         var _a;
-        return (__assign(__assign({}, stmts), (_a = {}, _a[stmt.declaration.specified_type.specifier.specifier.token] = __assign(__assign({}, (stmts[stmt.declaration.specified_type.specifier.specifier.token] || {})), stmt.declaration.declarations.reduce(function (types, decl) {
-            var _a;
-            return (__assign(__assign({}, types), (_a = {}, _a[decl.identifier.identifier] = true, _a)));
-        }, {})), _a)));
+        var _b = extractDeclarationNameAndType(stmt), type = _b.type, names = _b.names;
+        return __assign(__assign({}, indexed), (_a = {}, _a[type] = new Set(__spreadArray(__spreadArray([], __read((indexed[type] || new Set())), false), __read(names), false)), _a));
     }, {})).map(function (_a) {
         var _b = __read(_a, 2), type = _b[0], varNames = _b[1];
-        return makeStatement("".concat(qualifier, " ").concat(type, " ").concat(Object.keys(varNames).join(', ')))[0];
+        return makeStatement("".concat(qualifier, " ").concat(type, " ").concat(Array.from(varNames).join(', ')))[0];
     });
 };
+/**
+ * Remove uniform declarations by the variable names they declare
+ */
+export var filterUniformNames = function (declarations, filter) {
+    return declarations.reduce(function (acc, line) {
+        var _a, _b;
+        var decl = line.source.declaration;
+        // Struct declarations like "uniform Light0 { vec4 y; } x;"
+        if (decl.type === 'interface_declarator') {
+            var identifier = (_b = (_a = decl.identifier) === null || _a === void 0 ? void 0 : _a.identifier) === null || _b === void 0 ? void 0 : _b.identifier;
+            // If there are no remaining declarations, remove the whole line
+            return !identifier || !filter(identifier) ? acc : __spreadArray(__spreadArray([], __read(acc), false), [line], false);
+            // Standard uniform declaration, like "uniform vec4 x, y;"
+        }
+        else if (decl.type === 'declarator_list') {
+            var filtered = decl.declarations.filter(function (d) {
+                return filter(d.identifier.identifier);
+            });
+            // If there are no remaining decalrations, remove the whole line.
+            // Otherwise, update the line to remove the filtered out names
+            return filtered.length
+                ? acc.concat(__assign(__assign({}, line), { source: __assign(__assign({}, line.source), { declaration: __assign(__assign({}, decl), { declarations: filtered }) }) }))
+                : acc;
+        }
+        else {
+            console.error('Unknown uniform declaration type to filter:', decl);
+            throw new Error("Unknown uniform declarationt type to filter: \"".concat(decl.type, "\""));
+        }
+    }, []);
+};
 /**
  * Merge uniforms together into lists of identifiers under the same type.
  * There's special case handling for mixing of uniforms with "interface blocks"
@@ -183,15 +255,17 @@ export var mergeShaderSections = function (s1, s2) {
 export var shaderSectionsToProgram = function (sections, mergeOptions) { return ({
     type: 'program',
     scopes: [],
-    program: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((mergeOptions.includeVersion ? [dedupeVersions(sections.version)] : [])), false), __read((mergeOptions.includePrecisions
-        ? highestPrecisions(sections.precision)
-        : [])), false), __read(sections.preprocessor), false), __read(sections.structs), false), __read(dedupeQualifiedStatements(sections.inStatements, 'in')), false), __read(dedupeQualifiedStatements(sections.outStatements, 'out')), false), __read(dedupeUniforms(sections.uniforms)), false), __read(sections.program), false),
+    program: __spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray(__spreadArray([], __read((mergeOptions.includeVersion
+        ? [dedupeVersions(extractSource(sections.version))]
+        : [])), false), __read((mergeOptions.includePrecisions
+        ? highestPrecisions(extractSource(sections.precision))
+        : [])), false), __read(extractSource(sections.preprocessor)), false), __read(extractSource(sections.structs)), false), __read(dedupeQualifiedStatements(extractSource(sections.inStatements), 'in')), false), __read(dedupeQualifiedStatements(extractSource(sections.outStatements), 'out')), false), __read(dedupeUniforms(extractSource(sections.uniforms))), false), __read(extractSource(sections.program)), false),
 }); };
 /**
  * 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 var findShaderSections = function (ast) {
+export var findShaderSections = function (nodeId, ast) {
     var initialValue = {
         precision: [],
         preprocessor: [],
@@ -205,19 +279,19 @@ export var findShaderSections = function (ast) {
     return ast.program.reduce(function (sections, node) {
         var _a, _b, _c, _d, _e, _f, _g, _h, _j, _k, _l, _m, _o, _p, _q;
         if (node.type === 'preprocessor' && node.line.startsWith('#version')) {
-            return __assign(__assign({}, sections), { version: sections.version.concat(node) });
+            return __assign(__assign({}, sections), { version: sections.version.concat({ nodeId: nodeId, source: node }) });
         }
         else if (node.type === 'declaration_statement' &&
             node.declaration.type === 'precision') {
-            return __assign(__assign({}, sections), { precision: sections.precision.concat(node) });
+            return __assign(__assign({}, sections), { precision: sections.precision.concat({ nodeId: nodeId, source: node }) });
         }
         else if (node.type === 'preprocessor') {
-            return __assign(__assign({}, sections), { preprocessor: sections.preprocessor.concat(node) });
+            return __assign(__assign({}, sections), { preprocessor: sections.preprocessor.concat({ nodeId: nodeId, source: node }) });
         }
         else if (node.type === 'declaration_statement' &&
             node.declaration.type === 'declarator_list' &&
             ((_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.type) === 'struct') {
-            return __assign(__assign({}, sections), { structs: sections.structs.concat(node) });
+            return __assign(__assign({}, sections), { structs: sections.structs.concat({ nodeId: nodeId, source: node }) });
             // This definition of a uniform lines up with the processing we do in
             // dedupeUniforms
         }
@@ -232,20 +306,20 @@ export var findShaderSections = function (ast) {
                 ((_g = node.declaration.specified_type.qualifiers) === null || _g === void 0 ? void 0 : _g.find(function (n) { return 'token' in n && n.token === 'uniform'; }))) ||
                 ('qualifiers' in node.declaration &&
                     ((_j = (_h = node.declaration) === null || _h === void 0 ? void 0 : _h.qualifiers) === null || _j === void 0 ? void 0 : _j.find(function (n) { return 'token' in n && n.token === 'uniform'; }))))) {
-            return __assign(__assign({}, sections), { uniforms: sections.uniforms.concat(node) });
+            return __assign(__assign({}, sections), { uniforms: sections.uniforms.concat({ nodeId: nodeId, source: node }) });
         }
         else if (node.type === 'declaration_statement' &&
             'specified_type' in node.declaration &&
             ((_m = (_l = (_k = node.declaration) === null || _k === void 0 ? void 0 : _k.specified_type) === null || _l === void 0 ? void 0 : _l.qualifiers) === null || _m === void 0 ? void 0 : _m.find(function (n) { return 'token' in n && n.token === 'in'; }))) {
-            return __assign(__assign({}, sections), { inStatements: sections.inStatements.concat(node) });
+            return __assign(__assign({}, sections), { inStatements: sections.inStatements.concat({ nodeId: nodeId, source: node }) });
         }
         else if (node.type === 'declaration_statement' &&
             'specified_type' in node.declaration &&
             ((_q = (_p = (_o = node.declaration) === null || _o === void 0 ? void 0 : _o.specified_type) === null || _p === void 0 ? void 0 : _p.qualifiers) === null || _q === void 0 ? void 0 : _q.find(function (n) { return 'token' in n && n.token === 'out'; }))) {
-            return __assign(__assign({}, sections), { outStatements: sections.outStatements.concat(node) });
+            return __assign(__assign({}, sections), { outStatements: sections.outStatements.concat({ nodeId: nodeId, source: node }) });
         }
         else {
-            return __assign(__assign({}, sections), { program: sections.program.concat(node) });
+            return __assign(__assign({}, sections), { program: sections.program.concat({ nodeId: nodeId, source: node }) });
         }
     }, initialValue);
 };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@shaderfrog/core",
-  "version": "2.0.1",
+  "version": "3.0.1",
   "description": "Shaderfrog core",
   "type": "module",
   "files": [
@@ -34,7 +34,7 @@
     "@babel/core": "^7.21.8",
     "@babel/preset-env": "^7.21.5",
     "@babel/preset-typescript": "^7.21.5",
-    "@shaderfrog/glsl-parser": "^5.2.0",
+    "@shaderfrog/glsl-parser": "^6.0.0-beta.7",
     "@swc/core": "^1.6.7",
     "@types/lodash.groupby": "^4.6.7",
     "@types/three": "^0.169.0",
@@ -48,7 +48,7 @@
     "lodash.groupby": "^4.6.0"
   },
   "peerDependencies": {
-    "@shaderfrog/glsl-parser": "^5.0.0-beta.4",
+    "@shaderfrog/glsl-parser": "^6.0.0-beta.7",
     "babylonjs": ">=4",
     "playcanvas": "^1.65.3",
     "three": ">=0.50"