@shaderfrog/core 1.0.10 → 1.1.0

package/dist/plugins/three/threngine.js

@@ -71,7 +71,7 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     return to.concat(ar || Array.prototype.slice.call(from));
 };
 var _a, _b;
-import { ShaderLib, RawShaderMaterial, Vector2, Vector3, Vector4, Color, } from 'three';
+import { ShaderLib, RawShaderMaterial, Vector2, Vector3, Vector4, Color, GLSL3, Light, Texture, MeshPhongMaterial, MeshPhysicalMaterial, MeshToonMaterial, } from 'three';
 import { NodeType } from '../../graph/graph-types';
 import { prepopulatePropertyInputs, mangleMainFn } from '../../graph/graph';
 import importers from './importers';
@@ -88,12 +88,63 @@ var log = function () {
     }
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[35m(three)\x1b[0m'], __read(args), false));
 };
-export var physicalNode = function (id, name, groupId, position, uniforms, stage, nextStageNodeId) {
+export var phongNode = function (id, name, position, uniforms, stage) {
     return prepopulatePropertyInputs({
         id: id,
-        name: name,
-        groupId: groupId,
+        name: 'MeshPhongMaterial',
         position: position,
+        engine: true,
+        type: EngineNodeType.phong,
+        config: {
+            version: 3,
+            uniforms: uniforms,
+            preprocess: true,
+            mangle: false,
+            properties: [
+                property('Color', 'color', 'rgb', 'uniform_diffuse'),
+                property('Emissive', 'emissive', 'rgb', 'uniform_emissive'),
+                property('Emissive Map', 'emissiveMap', 'texture', 'filler_emissiveMap'),
+                property('Emissive Intensity', 'emissiveIntensity', 'number', 'uniform_emissive'),
+                property('Texture', 'map', 'texture', 'filler_map'),
+                property('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
+                property('Normal Scale', 'normalScale', 'vector2'),
+                property('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                property('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
+                property('Shininess', 'shininess', 'number'),
+                property('Reflectivity', 'reflectivity', 'number'),
+                property('Refraction Ratio', 'refractionRatio', 'number'),
+                property('Specular', 'specular', 'rgb', 'uniform_specular'),
+                property('Specular Map', 'specularMap', 'texture', 'filler_specularMap'),
+                property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
+                property('Displacement Scale', 'displacementScale', 'number'),
+                property('Env Map', 'envMap', 'samplerCube'),
+            ],
+            strategies: [
+                uniformStrategy(),
+                stage === 'fragment'
+                    ? texture2DStrategy()
+                    : namedAttributeStrategy('position'),
+            ],
+        },
+        inputs: [],
+        outputs: [
+            {
+                name: 'vector4',
+                dataType: 'vector4',
+                category: 'data',
+                id: '1',
+            },
+        ],
+        source: '',
+        stage: stage,
+    });
+};
+export var physicalNode = function (id, name, position, uniforms, stage) {
+    return prepopulatePropertyInputs({
+        id: id,
+        name: 'MeshPhysicalMaterial',
+        position: position,
+        engine: true,
         type: EngineNodeType.physical,
         config: {
             uniforms: uniforms,
@@ -103,12 +154,16 @@ export var physicalNode = function (id, name, groupId, position, uniforms, stage
             properties: [
                 property('Color', 'color', 'rgb', 'uniform_diffuse'),
                 property('Texture', 'map', 'texture', 'filler_map'),
+                property('Opacity', 'opacity', 'number'),
                 property('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
                 property('Normal Scale', 'normalScale', 'vector2'),
+                property('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                property('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
                 property('Metalness', 'metalness', 'number', 'uniform_metalness'),
                 property('Roughness', 'roughness', 'number', 'uniform_roughness'),
                 property('Roughness Map', 'roughnessMap', 'texture', 'filler_roughnessMap'),
-                property('Displacement Map', 'displacementMap', 'texture'),
+                property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
+                property('Displacement Scale', 'displacementScale', 'number'),
                 // MeshPhysicalMaterial gets envMap from the scene. MeshStandardMaterial
                 // gets it from the material
                 // property('Env Map', 'envMap', 'samplerCube'),
@@ -116,7 +171,9 @@ export var physicalNode = function (id, name, groupId, position, uniforms, stage
                 property('Transmission Map', 'transmissionMap', 'texture', 'filler_transmissionMap'),
                 property('Thickness', 'thickness', 'number'),
                 property('Index of Refraction', 'ior', 'number'),
-                property('Sheen', 'sheen', 'number'),
+                // Sheen only works with directional lights?
+                // https://discourse.threejs.org/t/meshphysicalmaterial-s-sheen/31901/6
+                // property('Sheen', 'sheen', 'number'),
                 property('Reflectivity', 'reflectivity', 'number'),
                 property('Clearcoat', 'clearcoat', 'number'),
                 property('Iridescence', 'iridescence', 'number'),
@@ -138,13 +195,13 @@ export var physicalNode = function (id, name, groupId, position, uniforms, stage
         outputs: [
             {
                 name: 'vector4',
+                dataType: 'vector4',
                 category: 'data',
                 id: '1',
             },
         ],
         source: '',
         stage: stage,
-        nextStageNodeId: nextStageNodeId,
     });
 };
 var cacher = function (engineContext, graph, node, sibling, newValue) {
@@ -161,8 +218,12 @@ var cacher = function (engineContext, graph, node, sibling, newValue) {
     // TODO: We mutate the nodes here, can we avoid that later?
     node.source =
         node.stage === 'fragment' ? materialData.fragment : materialData.vertex;
-    sibling.source =
-        sibling.stage === 'fragment' ? materialData.fragment : materialData.vertex;
+    if (sibling) {
+        sibling.source =
+            sibling.stage === 'fragment'
+                ? materialData.fragment
+                : materialData.vertex;
+    }
 };
 var onBeforeCompileMegaShader = function (engineContext, newMat) {
     log('compiling three megashader!');
@@ -199,7 +260,7 @@ var onBeforeCompileMegaShader = function (engineContext, newMat) {
         vertex: vertex,
     };
 };
-var megaShaderMainpulateAst = function (engineContext, engine, graph, node, ast, inputEdges) {
+var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
     var programAst = ast;
     var mainName = 'main' || nodeName(node);
     if (node.stage === 'vertex') {
@@ -212,7 +273,7 @@ var megaShaderMainpulateAst = function (engineContext, engine, graph, node, ast,
     }
     // We specify engine nodes are mangle: false, which is the graph step that
     // handles renaming the main fn, so we have to do it ourselves
-    mangleMainFn(programAst, node);
+    mangleMainFn(programAst, node, sibling);
     return programAst;
 };
 var nodeCacheKey = function (graph, node) {
@@ -234,14 +295,15 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
     // The megashader source is dependent on scene information, like the number
     // and type of lights in the scene. This kinda sucks - it's duplicating
     // three's material cache key, and is coupled to how three builds shaders
-    var _a = engineContext.runtime, three = _a.three, scene = _a.scene;
+    var scene = engineContext.runtime.scene;
     var lights = [];
     scene.traverse(function (obj) {
-        if (obj instanceof three.Light) {
+        if (obj instanceof Light) {
             lights.push(obj.type);
         }
     });
     return ([node, sibling]
+        .filter(function (n) { return !!n; })
         .sort(function (a, b) { return a.id.localeCompare(b.id); })
         .map(function (n) { return nodeCacheKey(graph, n); })
         .join('-') +
@@ -250,21 +312,21 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
         '|Envtex:' +
         scene.environmentTexture);
 };
-export var defaultPropertySetting = function (three, property) {
+export var defaultPropertySetting = function (property) {
     if (property.type === 'texture') {
-        return new three.Texture();
+        return new Texture();
     }
     else if (property.type === 'number') {
         return 0.5;
     }
     else if (property.type === 'rgb') {
-        return new three.Color(1, 1, 1);
+        return new Color(1, 1, 1);
     }
     else if (property.type === 'rgba') {
-        return new three.Color(1, 1, 1, 1);
+        return new Vector4(1, 1, 1, 1);
     }
 };
-var threeMaterialProperties = function (three, graph, node, sibling) {
+var threeMaterialProperties = function (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; })
@@ -282,7 +344,7 @@ var threeMaterialProperties = function (three, graph, node, sibling) {
             // Find the property itself
             var property_1 = (node.config.properties || []).find(function (p) { return p.property === propertyInput.property; });
             // Initialize the property on the material
-            acc[property_1.property] = defaultPropertySetting(three, property_1);
+            acc[property_1.property] = defaultPropertySetting(property_1);
         }
         return acc;
     }, {});
@@ -310,12 +372,12 @@ var evaluateNode = function (node) {
         return node.value;
     }
 };
-export var toonNode = function (id, name, groupId, position, uniforms, stage, nextStageNodeId) {
+export var toonNode = function (id, name, position, uniforms, stage) {
     return prepopulatePropertyInputs({
         id: id,
-        name: name,
-        groupId: groupId,
+        name: 'MeshToonMaterial',
         position: position,
+        engine: true,
         type: EngineNodeType.toon,
         config: {
             uniforms: uniforms,
@@ -328,7 +390,10 @@ export var toonNode = function (id, name, groupId, position, uniforms, stage, ne
                 property('Gradient Map', 'gradientMap', 'texture', 'filler_gradientMap'),
                 property('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
                 property('Normal Scale', 'normalScale', 'vector2'),
-                property('Displacement Map', 'displacementMap', 'texture'),
+                property('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                property('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
+                property('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
+                property('Displacement Scale', 'displacementScale', 'number'),
                 property('Env Map', 'envMap', 'samplerCube'),
             ],
             strategies: [
@@ -342,17 +407,18 @@ export var toonNode = function (id, name, groupId, position, uniforms, stage, ne
         outputs: [
             {
                 name: 'vector4',
+                dataType: 'vector4',
                 category: 'data',
                 id: '1',
             },
         ],
         source: '',
         stage: stage,
-        nextStageNodeId: nextStageNodeId,
     });
 };
 export var threngine = {
     name: 'three',
+    displayName: 'Three.js',
     importers: importers,
     mergeOptions: {
         includePrecisions: true,
@@ -360,6 +426,7 @@ export var threngine = {
     },
     evaluateNode: evaluateNode,
     constructors: (_a = {},
+        _a[EngineNodeType.phong] = phongNode,
         _a[EngineNodeType.physical] = physicalNode,
         _a[EngineNodeType.toon] = toonNode,
         _a),
@@ -376,6 +443,7 @@ export var threngine = {
         'normal',
         'uv',
         'uv2',
+        'tangent',
         // Varyings
         'vUv',
         'vUv2',
@@ -437,7 +505,7 @@ export var threngine = {
     ]),
     parsers: (_b = {},
         _b[NodeType.SOURCE] = {
-            manipulateAst: function (engineContext, engine, graph, node, ast, inputEdges) {
+            manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
                 var programAst = ast;
                 var mainName = 'main' || nodeName(node);
                 // This hinges on the vertex shader calling vec3(p)
@@ -454,11 +522,11 @@ export var threngine = {
         },
         _b[EngineNodeType.phong] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
-                var three;
                 return __generator(this, function (_a) {
-                    three = engineContext.runtime.three;
                     cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new three.MeshPhongMaterial(__assign({ isMeshPhongMaterial: true }, threeMaterialProperties(three, graph, node, sibling))));
+                        return onBeforeCompileMegaShader(engineContext, new MeshPhongMaterial(__assign({ 
+                            // @ts-ignore
+                            isMeshPhongMaterial: true }, threeMaterialProperties(graph, node, sibling))));
                     });
                     return [2 /*return*/];
                 });
@@ -467,11 +535,9 @@ export var threngine = {
         },
         _b[EngineNodeType.physical] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
-                var three;
                 return __generator(this, function (_a) {
-                    three = engineContext.runtime.three;
                     cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new three.MeshPhysicalMaterial(__assign(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(three, graph, node, sibling)), { iridescence: 1.0, iridescenceIOR: 2.0 })));
+                        return onBeforeCompileMegaShader(engineContext, new MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
                     });
                     return [2 /*return*/];
                 });
@@ -480,11 +546,11 @@ export var threngine = {
         },
         _b[EngineNodeType.toon] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
-                var three;
                 return __generator(this, function (_a) {
-                    three = engineContext.runtime.three;
                     cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new three.MeshToonMaterial(__assign({ gradientMap: new three.Texture(), isMeshToonMaterial: true }, threeMaterialProperties(three, graph, node, sibling))));
+                        return onBeforeCompileMegaShader(engineContext, new MeshToonMaterial(__assign({ gradientMap: new Texture(), 
+                            // @ts-ignore
+                            isMeshToonMaterial: true }, threeMaterialProperties(graph, node, sibling))));
                     });
                     return [2 /*return*/];
                 });
@@ -495,15 +561,14 @@ 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 } });
+    var finalUniforms = __assign(__assign(__assign(__assign({}, ShaderLib.phong.uniforms), ShaderLib.toon.uniforms), ShaderLib.physical.uniforms), { time: { value: 0 }, cameraPosition: { value: new Vector3(1.0) } });
+    // Also the ThreeComponent's sceneConfig properties modify the material
     var initialProperties = {
         name: 'ShaderFrog Material',
         lights: true,
         uniforms: __assign({}, finalUniforms),
-        transparent: true,
-        opacity: 1.0,
         // See https://github.com/mrdoob/three.js/pull/26809
-        glslVersion: '300 es',
+        glslVersion: GLSL3,
         vertexShader: compileResult === null || compileResult === void 0 ? void 0 : compileResult.vertexResult.replace('#version 300 es', ''),
         fragmentShader: compileResult === null || compileResult === void 0 ? void 0 : compileResult.fragmentResult.replace('#version 300 es', ''),
     };

package/dist/strategy/assignemntTo.js

@@ -7,14 +7,14 @@ export var assignemntToStrategy = function (assignTo) { return ({
     config: { assignTo: assignTo },
 }); };
 // Apply the strategy
-export var applyAssignmentToStrategy = function (node, ast, strategy) {
+export var applyAssignmentToStrategy = function (strategy, ast, graphNode, siblingNode) {
     var assignNode = findAssignmentTo(ast, strategy.config.assignTo);
     var name = strategy.config.assignTo;
     return assignNode
         ? [
             [
                 nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
-                new Set(['code', 'data']), false),
+                ['code', 'data'], false),
                 function (fillerAst) {
                     assignNode.expression.right =
                         fillerAst;

package/dist/strategy/declarationOf.js

@@ -5,14 +5,14 @@ export var declarationOfStrategy = function (declarationOf) { return ({
     type: StrategyType.DECLARATION_OF,
     config: { declarationOf: declarationOf },
 }); };
-export var constApplyDeclarationOf = function (node, ast, strategy) {
+export var constApplyDeclarationOf = function (strategy, ast, graphNode, siblingNode) {
     var declaration = findDeclarationOf(ast, strategy.config.declarationOf);
     var name = strategy.config.declarationOf;
     return declaration
         ? [
             [
                 nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
-                new Set(['code', 'data']), false),
+                ['code', 'data'], false),
                 function (fillerAst) {
                     declaration.initializer = fillerAst;
                     return ast;

package/dist/strategy/hardCode.js

@@ -3,7 +3,7 @@ export var hardCodeStrategy = function (inputs) { return ({
     type: StrategyType.HARD_CODE_INPUTS,
     config: { inputs: inputs },
 }); };
-export var applyHardCodeStrategy = function (graphNode, ast, strategy) {
+export var applyHardCodeStrategy = function (strategy, ast, graphNode, siblingNode) {
     return strategy.config.inputs.map(function (input) {
         // Broken out into two lines to enforce type checking on the array.
         var ci = [

package/dist/strategy/index.d.ts

@@ -1,6 +1,7 @@
 export * from './hardCode';
 export * from './uniform';
 export * from './assignemntTo';
+export * from './inject';
 export * from './declarationOf';
 export * from './texture2D';
 export * from './namedAttribute';

package/dist/strategy/index.js

@@ -1,6 +1,7 @@
 export * from './hardCode';
 export * from './uniform';
 export * from './assignemntTo';
+export * from './inject';
 export * from './declarationOf';
 export * from './texture2D';
 export * from './namedAttribute';

package/dist/strategy/inject.js

@@ -65,7 +65,7 @@ var transferWhitespace = function (to, from) {
             ]
             : [to, from];
 };
-export var applyInjectStrategy = function (graphNode, ast, strategy) {
+export var applyInjectStrategy = function (strategy, ast, graphNode, siblingNode) {
     var program = ast.program;
     var _a = strategy.config, find = _a.find, count = _a.count, insert = _a.insert;
     // Total hack for now. Search each function body for statements that when
@@ -91,7 +91,7 @@ export var applyInjectStrategy = function (graphNode, ast, strategy) {
     return [
         [
             nodeInput(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
-            new Set(['code', 'data']), false),
+            ['code', 'data'], false),
             function (fillerAst) {
                 var toInsert = Array.isArray(fillerAst)
                     ? fillerAst

package/dist/strategy/namedAttribute.js

@@ -21,13 +21,13 @@ export var namedAttributeStrategy = function (attributeName) { return ({
     type: StrategyType.NAMED_ATTRIBUTE,
     config: { attributeName: attributeName },
 }); };
-export var applyNamedAttributeStrategy = function (node, ast, strategy) {
+export var applyNamedAttributeStrategy = function (strategy, ast, graphNode, siblingNode) {
     var program = ast;
     var attributeName = strategy.config.attributeName;
     return [
         [
             nodeInput(attributeName, "filler_".concat(attributeName), 'filler', undefined, // Data type for what plugs into this filler
-            new Set(['code', 'data']), true),
+            ['code', 'data'], true),
             function (fillerAst) {
                 Object.entries(program.scopes[0].bindings).forEach(function (_a) {
                     var _b = __read(_a, 2), name = _b[0], binding = _b[1];

package/dist/strategy/strategy.d.ts

@@ -24,5 +24,5 @@ export interface BaseStrategy {
     config: Object;
 }
 export type Strategy = UniformStrategy | AssignemntToStrategy | Texture2DStrategy | NamedAttributeStrategy | VariableStrategy | HardCodeStrategy | InjectStrategy | DeclarationOfStrategy;
-export type ApplyStrategy<T> = (node: SourceNode, ast: AstNode | Program, strategy: T) => ComputedInput[];
-export declare const applyStrategy: (strategy: Strategy, node: SourceNode, ast: AstNode | Program) => ComputedInput[];
+export type ApplyStrategy<T> = (strategy: T, ast: AstNode | Program, node: SourceNode, sibling: SourceNode) => ComputedInput[];
+export declare const applyStrategy: (strategy: Strategy, ast: AstNode | Program, node: SourceNode, sibling: SourceNode) => ComputedInput[];

package/dist/strategy/strategy.js

@@ -28,4 +28,4 @@ var strategyRunners = (_a = {},
     _a[StrategyType.NAMED_ATTRIBUTE] = applyNamedAttributeStrategy,
     _a[StrategyType.VARIABLE] = applyVariableStrategy,
     _a);
-export var applyStrategy = function (strategy, node, ast) { return strategyRunners[strategy.type](node, ast, strategy); };
+export var applyStrategy = function (strategy, ast, node, sibling) { return strategyRunners[strategy.type](strategy, ast, node, sibling); };

package/dist/strategy/stratgies.test.js

@@ -39,7 +39,7 @@ it('named attribute strategy`', function () {
         config: {
             attributeName: 'replaceThisAtrribute',
         },
-    }, { source: source }, ast);
+    }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
     fillers[0][1]({
         type: 'literal',
@@ -60,7 +60,7 @@ it('inject strategy after', function () {
             insert: 'after',
             count: Infinity,
         },
-    }, { source: source }, ast);
+    }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
     fillers[0][1]({
         type: 'literal',
@@ -81,7 +81,7 @@ it('inject strategy before', function () {
             insert: 'before',
             count: Infinity,
         },
-    }, { source: source }, ast);
+    }, ast, { source: source }, {});
     expect(fillers.length).toBe(1);
     fillers[0][1]({
         type: 'literal',
@@ -95,7 +95,7 @@ it('inject strategy before', function () {
 it('correctly fills with uniform strategy', function () {
     var _a, _b, _c;
     var ast = parser.parse("\nlayout(std140,column_major) uniform;\nuniform sampler2D image;\nuniform vec4 input, output, other;\nuniform vec4 zenput;\nuniform Light0 { vec4 y; } x;\nvec3 topLevel = vec3(0.0);\nvoid other(in vec3 param) {}\nvoid main() {\n  vec4 computed = texture2D(image, uvPow * 1.0);\n  vec4 x = input;\n  vec4 y = output;\n  vec4 z = zenput;\n}", { quiet: true });
-    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, {}, ast);
+    var fillers = applyStrategy({ type: StrategyType.UNIFORM, config: {} }, ast, {}, {});
     // It should find uniforms with simple types, excluding sampler2D
     expect(fillers.map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
@@ -135,14 +135,14 @@ it('correctly fills with uniform strategy', function () {
 });
 it('uses name without suffix for single call', function () {
     var ast = parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n}", { quiet: true });
-    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, {}, ast).map(function (_a) {
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;
     })).toEqual(['noiseImage']);
 });
 it('finds multiple texture2D inputs for one uniform', function () {
     var ast = parser.parse("\nvoid main() {\n  vec4 computed = texture2D(noiseImage, uvPow * 1.0);\n  computed += texture2D(noiseImage, uvPow * 2.0);\n}", { quiet: true });
-    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, {}, ast).map(function (_a) {
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;
     })).toEqual(['noiseImage_0', 'noiseImage_1']);
@@ -157,7 +157,7 @@ it('Make sure texture2D finds preprocessed texture() call', function () {
         },
     });
     var ast = parser.parse(pp, { quiet: true });
-    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, {}, ast).map(function (_a) {
+    expect(applyStrategy({ type: StrategyType.TEXTURE_2D, config: {} }, ast, {}, {}).map(function (_a) {
         var _b = __read(_a, 1), name = _b[0].displayName;
         return name;
     })).toEqual(['normalMapx']);

package/dist/strategy/texture2D.js

@@ -31,7 +31,7 @@ export var texture2DStrategy = function () { return ({
     type: StrategyType.TEXTURE_2D,
     config: {},
 }); };
-export var applyTexture2DStrategy = function (node, ast, strategy) {
+export var applyTexture2DStrategy = function (strategy, ast, graphNode, siblingNode) {
     var texture2Dcalls = [];
     var seen = {};
     var visitors = {
@@ -70,7 +70,7 @@ export var applyTexture2DStrategy = function (node, ast, strategy) {
         var iName = names.has(name) ? "".concat(name, "_").concat(index) : name;
         return [
             nodeInput(iName, "filler_".concat(iName), 'filler', 'vector4', // Data type for what plugs into this filler
-            new Set(['code', 'data']), false),
+            ['code', 'data'], false),
             function (fillerAst) {
                 // @ts-ignore
                 parent[key] = fillerAst;

package/dist/strategy/uniform.js

@@ -128,7 +128,7 @@ var mapUniformType = function (type) {
     }
     // console.log(`Unknown uniform type, can't map to graph: ${type}`);
 };
-export var applyUniformStrategy = function (graphNode, ast, strategy) {
+export var applyUniformStrategy = function (strategy, ast, graphNode, siblingNode) {
     var program = ast;
     return (program.program || []).flatMap(function (node) {
         var _a, _b, _c, _d, _e, _f, _g;
@@ -153,9 +153,9 @@ export var applyUniformStrategy = function (graphNode, ast, strategy) {
             //    the name "x" but the ast now has the mangled name "x_1". So
             //    here, we look for the *mangled* name in the strategy runner
             return names.map(function (name) { return [
-                nodeInput(name, "uniform_".concat(name), 'uniform', graphDataType, new Set(['code', 'data']), true),
+                nodeInput(name, "uniform_".concat(name), 'uniform', graphDataType, ['code', 'data'], true),
                 function (filler) {
-                    var mangledName = mangleName(name, graphNode);
+                    var mangledName = mangleName(name, graphNode, siblingNode);
                     // Remove the declaration line, or the declared uniform
                     if (declarations_1.length === 1) {
                         program.program.splice(program.program.indexOf(node), 1);

package/dist/strategy/variable.js

@@ -41,7 +41,7 @@ export var variableStrategy = function () { return ({
     type: StrategyType.VARIABLE,
     config: {},
 }); };
-export var applyVariableStrategy = function (node, ast, strategy) {
+export var applyVariableStrategy = function (strategy, ast, graphNode, siblingNode) {
     var program = ast;
     return Object.values(program.scopes.reduce(function (acc, scope) { return (__assign(__assign({}, acc), scope.bindings)); }, {})).flatMap(function (binding) {
         return binding.references.reduce(function (acc, ref) {
@@ -71,7 +71,7 @@ export var applyVariableStrategy = function (node, ast, strategy) {
             return __spreadArray(__spreadArray([], __read(acc), false), [
                 [
                     nodeInput(identifier, "filler_".concat(identifier), 'filler', undefined, // Data type for what plugs into this filler
-                    new Set(['code', 'data']), false),
+                    ['code', 'data'], false),
                     replacer,
                 ],
             ], false);

package/dist/util/ast.js

@@ -239,7 +239,6 @@ export var returnGlPositionVec3Right = function (fnName, ast) {
             function_call: {
                 enter: function (path) {
                     var _a, _b, _c, _d, _e;
-                    log('returnGlPositionVec3Right', path.node);
                     var node = path.node;
                     if (((_b = (_a = node === null || node === void 0 ? void 0 : node.identifier) === null || _a === void 0 ? void 0 : _a.specifier) === null || _b === void 0 ? void 0 : _b.token) === 'vec4' &&
                         ((_e = (_d = (_c = node === null || node === void 0 ? void 0 : node.args) === null || _c === void 0 ? void 0 : _c[2]) === null || _d === void 0 ? void 0 : _d.token) === null || _e === void 0 ? void 0 : _e.includes('1.'))) {

package/dist/util/id.js

@@ -1,2 +1,2 @@
 var counter = 0;
-export var makeId = function () { return '' + counter++; };
+export var makeId = function () { return "".concat(Date.now(), "_").concat(counter++); };

package/package.json

@@ -1,10 +1,9 @@
 {
   "name": "@shaderfrog/core",
-  "version": "1.0.10",
+  "version": "1.1.0",
   "description": "Shaderfrog core",
-  "module": "./dist/index.js",
   "scripts": {
-    "prepare": "npm run build",
+    "prepare": "npm run build && ./prepublish.sh",
     "build": "./build.sh",
     "watch-test": "jest --watch",
     "test": "jest --colors"
@@ -28,7 +27,7 @@
     "@babel/preset-typescript": "^7.21.5",
     "@types/jest": "^29.5.1",
     "@types/lodash.groupby": "^4.6.7",
-    "@types/three": "^0.156.1",
+    "@types/three": "^0.156.0",
     "babel-jest": "^29.5.0",
     "babylonjs": "^6.2.0",
     "jest": "^29.5.0",
@@ -40,7 +39,7 @@
     "lodash.groupby": "^4.6.0"
   },
   "peerDependencies": {
-    "@shaderfrog/glsl-parser": "^2.0.0",
+    "@shaderfrog/glsl-parser": "^2.1.5",
     "babylonjs": ">=4",
     "playcanvas": "^1.65.3",
     "three": ">=0.50"