@shaderfrog/core 2.0.0-beta.3 → 3.0.0

package/graph/shader-sections.js

@@ -36,7 +36,32 @@ 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 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: [],
     version: [],
@@ -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.0-beta.3",
+  "version": "3.0.0",
   "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.3.2",
     "@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

@@ -73,12 +73,13 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
 var _a, _b;
 import { PBRMaterial, Texture, Light, Vector2, Vector3, Vector4, Color3, Color4, } from 'babylonjs';
 import { EngineNodeType } from '../../engine';
-import { nodeName, doesLinkThruShader, prepopulatePropertyInputs, mangleMainFn, } from '../../graph/graph';
+import { doesLinkThruShader, prepopulatePropertyInputs, mangleMainFn, } from '../../graph/graph';
 import { NodeType } from '../../graph/graph-types';
 import importers from './importers';
 import { returnGlPositionHardCoded, returnGlPosition, returnGlPositionVec3Right, } from '../../util/ast';
 import { property, } from '../../graph/code-nodes';
 import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
+import indexById from '../../util/indexByid';
 // Setting these properties on the material have side effects, not just for the
 // GLSL, but for the material itself in JS memory apparently, maybe the bound
 // uniforms?. The material we create in babylengine must have the same initial
@@ -194,12 +195,7 @@ export var toonNode = function (id, name, position, uniforms, stage) {
 };
 var babylonMaterialProperties = function (scene, graph, node, sibling) {
     // Find inputs to this node that are dependent on a property of the material
-    var propertyInputs = node.inputs
-        .filter(function (i) { return i.property; })
-        .reduce(function (acc, input) {
-        var _a;
-        return (__assign(__assign({}, acc), (_a = {}, _a[input.id] = input, _a)));
-    }, {});
+    var propertyInputs = indexById(node.inputs.filter(function (i) { return i.property; }));
     // Then look for any edges into those inputs and set the material property
     var props = graph.edges
         .filter(function (edge) { return edge.to === node.id || edge.to === (sibling === null || sibling === void 0 ? void 0 : sibling.id); })
@@ -397,7 +393,7 @@ var onBeforeCompileMegaShader = function (engineContext, graph, node, sibling) {
 // TODO: NEED TO DO SAME THREE MANGLIGN STEP HERE
 var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
     var programAst = ast;
-    var mainName = 'main' || nodeName(node);
+    var mainName = 'main';
     if (node.stage === 'vertex') {
         if (doesLinkThruShader(graph, node)) {
             returnGlPositionHardCoded(mainName, programAst, 'vec3', 'transformed');
@@ -531,7 +527,6 @@ export var babylengine = {
         'normal',
         'uv',
         'world',
-        'time',
         'Light0',
         'Light1',
         'Light2',
@@ -555,12 +550,16 @@ 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] = {
             manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
                 var programAst = ast;
-                var mainName = 'main' || nodeName(node);
+                var mainName = 'main';
                 // This hinges on the vertex shader calling vec3(p)
                 if (node.stage === 'vertex') {
                     if (doesLinkThruShader(graph, node)) {

package/plugins/playcanvas/playengine.js

@@ -79,6 +79,7 @@ import importers from './importers';
 import { returnGlPositionHardCoded, returnGlPosition, returnGlPositionVec3Right, } from '../../util/ast';
 import { property, } from '../../graph/code-nodes';
 import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
+import indexById from '../../util/indexByid';
 var log = function () {
     var _a;
     var args = [];
@@ -126,12 +127,7 @@ export var defaultPropertySetting = function (app, property) {
 };
 var applyPlayMaterialProperties = function (engineContext, shaderMaterial, app, graph, node, sibling) {
     // Find inputs to this node that are dependent on a property of the material
-    var propertyInputs = node.inputs
-        .filter(function (i) { return i.property; })
-        .reduce(function (acc, input) {
-        var _a;
-        return (__assign(__assign({}, acc), (_a = {}, _a[input.id] = input, _a)));
-    }, {});
+    var propertyInputs = indexById(node.inputs.filter(function (i) { return i.property; }));
     // Then look for any edges into those inputs and set the material property
     var props = graph.edges
         .filter(function (edge) { return edge.to === node.id || edge.to === (sibling === null || sibling === void 0 ? void 0 : sibling.id); })
@@ -367,7 +363,7 @@ var onBeforeCompileMegaShader = function (engineContext, graph, node, sibling) {
         return [2 /*return*/, new Promise(function (resolve) {
                 var variants = shaderMaterial.variants;
                 if (variants.size === 1) {
-                    var _a = __read(variants.entries().next().value, 2), untypedVariant = _a[1];
+                    var _a = __read(variants.entries().next().value || [], 2), untypedVariant = _a[1];
                     var variant = untypedVariant;
                     var _b = variant.definition, fshader = _b.fshader, vshader = _b.vshader;
                     fragmentSource = fshader;
@@ -391,7 +387,7 @@ var onBeforeCompileMegaShader = function (engineContext, graph, node, sibling) {
 // TODO: NEED TO DO SAME THREE MANGLIGN STEP HERE
 var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
     var programAst = ast;
-    var mainName = 'main' || nodeName(node);
+    var mainName = nodeName(node);
     if (node.stage === 'vertex') {
         if (doesLinkThruShader(graph, node)) {
             returnGlPositionHardCoded(mainName, programAst, 'vec3', 'transformed');
@@ -472,7 +468,6 @@ export var playengine = {
         'matrix_normal',
         'matrix_view',
         'matrix_viewProjection',
-        'time',
         'vertex_color',
         'vertex_normal',
         'vertex_position',
@@ -483,12 +478,16 @@ 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] = {
             manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
                 var programAst = ast;
-                var mainName = 'main' || nodeName(node);
+                var mainName = nodeName(node);
                 // This hinges on the vertex shader calling vec3(p)
                 if (node.stage === 'vertex') {
                     if (doesLinkThruShader(graph, node)) {

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.d.ts

@@ -1,4 +1,4 @@
-import { RawShaderMaterial, Vector4, Color, Texture } from 'three';
+import { RawShaderMaterial, Vector4, Color, Texture, Scene, WebGLRenderer, PerspectiveCamera } from 'three';
 import { ShaderStage } from '../../graph/graph-types';
 import { Engine, EngineContext } from '../../engine';
 import { CompileResult } from '../../graph/graph';
@@ -9,11 +9,12 @@ export declare const phongNode: (id: string, name: string, position: NodePositio
 export declare const physicalNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
 export declare const defaultPropertySetting: (property: NodeProperty) => 0.5 | Texture | Color | Vector4 | undefined;
 export type ThreeRuntime = {
-    scene: any;
-    camera: any;
-    renderer: any;
+    scene: Scene;
+    camera: PerspectiveCamera;
+    renderer: WebGLRenderer;
     sceneData: any;
     engineMaterial: any;
+    loaded: boolean;
     index: number;
     cache: {
         data: {
@@ -29,6 +30,7 @@ export type ThreeRuntime = {
         };
     };
 };
+export declare const stringifyThreeValue: (input: any) => string;
 export declare const toonNode: (id: string, name: string, position: NodePosition, uniforms: UniformDataType[], stage: ShaderStage | undefined) => CodeNode;
 export declare const threngine: Engine;
 export declare const createMaterial: (compileResult: CompileResult, ctx: EngineContext) => RawShaderMaterial;