@shaderfrog/core 1.1.1 → 1.2.0

package/plugins/three/threngine.js

@@ -1,3 +1,4 @@
+"use strict";
 var __assign = (this && this.__assign) || function () {
     __assign = Object.assign || function(t) {
         for (var s, i = 1, n = arguments.length; i < n; i++) {
@@ -70,16 +71,21 @@ var __spreadArray = (this && this.__spreadArray) || function (to, from, pack) {
     }
     return to.concat(ar || Array.prototype.slice.call(from));
 };
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
 var _a, _b;
-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';
-import { EngineNodeType } from '../../engine';
-import { doesLinkThruShader, nodeName } from '../../graph/graph';
-import { returnGlPosition, returnGlPositionHardCoded, returnGlPositionVec3Right, } from '../../util/ast';
-import { property, } from '../../graph/code-nodes';
-import { namedAttributeStrategy, texture2DStrategy, uniformStrategy, } from '../../strategy';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.createMaterial = exports.threngine = exports.toonNode = exports.defaultPropertySetting = exports.physicalNode = exports.phongNode = void 0;
+var three_1 = require("three");
+var graph_types_1 = require("../../graph/graph-types");
+var graph_1 = require("../../graph/graph");
+var importers_1 = __importDefault(require("./importers"));
+var engine_1 = require("../../engine");
+var graph_2 = require("../../graph/graph");
+var ast_1 = require("../../util/ast");
+var code_nodes_1 = require("../../graph/code-nodes");
+var strategy_1 = require("../../strategy");
 var log = function () {
     var _a;
     var args = [];
@@ -88,42 +94,42 @@ var log = function () {
     }
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[35m(three)\x1b[0m'], __read(args), false));
 };
-export var phongNode = function (id, name, position, uniforms, stage) {
-    return prepopulatePropertyInputs({
+var phongNode = function (id, name, position, uniforms, stage) {
+    return (0, graph_1.prepopulatePropertyInputs)({
         id: id,
         name: 'MeshPhongMaterial',
         position: position,
         engine: true,
-        type: EngineNodeType.phong,
+        type: engine_1.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'),
+                (0, code_nodes_1.property)('Color', 'color', 'rgb', 'uniform_diffuse'),
+                (0, code_nodes_1.property)('Emissive', 'emissive', 'rgb', 'uniform_emissive'),
+                (0, code_nodes_1.property)('Emissive Map', 'emissiveMap', 'texture', 'filler_emissiveMap'),
+                (0, code_nodes_1.property)('Emissive Intensity', 'emissiveIntensity', 'number', 'uniform_emissive'),
+                (0, code_nodes_1.property)('Texture', 'map', 'texture', 'filler_map'),
+                (0, code_nodes_1.property)('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
+                (0, code_nodes_1.property)('Normal Scale', 'normalScale', 'vector2'),
+                (0, code_nodes_1.property)('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                (0, code_nodes_1.property)('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
+                (0, code_nodes_1.property)('Shininess', 'shininess', 'number'),
+                (0, code_nodes_1.property)('Reflectivity', 'reflectivity', 'number'),
+                (0, code_nodes_1.property)('Refraction Ratio', 'refractionRatio', 'number'),
+                (0, code_nodes_1.property)('Specular', 'specular', 'rgb', 'uniform_specular'),
+                (0, code_nodes_1.property)('Specular Map', 'specularMap', 'texture', 'filler_specularMap'),
+                (0, code_nodes_1.property)('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
+                (0, code_nodes_1.property)('Displacement Scale', 'displacementScale', 'number'),
+                (0, code_nodes_1.property)('Env Map', 'envMap', 'samplerCube'),
             ],
             strategies: [
-                uniformStrategy(),
+                (0, strategy_1.uniformStrategy)(),
                 stage === 'fragment'
-                    ? texture2DStrategy()
-                    : namedAttributeStrategy('position'),
+                    ? (0, strategy_1.texture2DStrategy)()
+                    : (0, strategy_1.namedAttributeStrategy)('position'),
             ],
         },
         inputs: [],
@@ -139,56 +145,57 @@ export var phongNode = function (id, name, position, uniforms, stage) {
         stage: stage,
     });
 };
-export var physicalNode = function (id, name, position, uniforms, stage) {
-    return prepopulatePropertyInputs({
+exports.phongNode = phongNode;
+var physicalNode = function (id, name, position, uniforms, stage) {
+    return (0, graph_1.prepopulatePropertyInputs)({
         id: id,
         name: 'MeshPhysicalMaterial',
         position: position,
         engine: true,
-        type: EngineNodeType.physical,
+        type: engine_1.EngineNodeType.physical,
         config: {
             uniforms: uniforms,
             version: 3,
             mangle: false,
             preprocess: true,
             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', 'filler_displacementMap'),
-                property('Displacement Scale', 'displacementScale', 'number'),
+                (0, code_nodes_1.property)('Color', 'color', 'rgb', 'uniform_diffuse'),
+                (0, code_nodes_1.property)('Texture', 'map', 'texture', 'filler_map'),
+                (0, code_nodes_1.property)('Opacity', 'opacity', 'number'),
+                (0, code_nodes_1.property)('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
+                (0, code_nodes_1.property)('Normal Scale', 'normalScale', 'vector2'),
+                (0, code_nodes_1.property)('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                (0, code_nodes_1.property)('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
+                (0, code_nodes_1.property)('Metalness', 'metalness', 'number', 'uniform_metalness'),
+                (0, code_nodes_1.property)('Roughness', 'roughness', 'number', 'uniform_roughness'),
+                (0, code_nodes_1.property)('Roughness Map', 'roughnessMap', 'texture', 'filler_roughnessMap'),
+                (0, code_nodes_1.property)('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
+                (0, code_nodes_1.property)('Displacement Scale', 'displacementScale', 'number'),
                 // MeshPhysicalMaterial gets envMap from the scene. MeshStandardMaterial
                 // gets it from the material
                 // property('Env Map', 'envMap', 'samplerCube'),
-                property('Transmission', 'transmission', 'number'),
-                property('Transmission Map', 'transmissionMap', 'texture', 'filler_transmissionMap'),
-                property('Thickness', 'thickness', 'number'),
-                property('Index of Refraction', 'ior', 'number'),
+                (0, code_nodes_1.property)('Transmission', 'transmission', 'number'),
+                (0, code_nodes_1.property)('Transmission Map', 'transmissionMap', 'texture', 'filler_transmissionMap'),
+                (0, code_nodes_1.property)('Thickness', 'thickness', 'number'),
+                (0, code_nodes_1.property)('Index of Refraction', 'ior', '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'),
-                property('Iridescence IOR', 'iridescenceIOR', 'number'),
-                property('Iridescence Thickness Range', 'iridescenceThicknessRange', 'array', undefined, ['100', '400']),
+                (0, code_nodes_1.property)('Reflectivity', 'reflectivity', 'number'),
+                (0, code_nodes_1.property)('Clearcoat', 'clearcoat', 'number'),
+                (0, code_nodes_1.property)('Iridescence', 'iridescence', 'number'),
+                (0, code_nodes_1.property)('Iridescence IOR', 'iridescenceIOR', 'number'),
+                (0, code_nodes_1.property)('Iridescence Thickness Range', 'iridescenceThicknessRange', 'array', undefined, ['100', '400']),
             ],
             hardCodedProperties: {
                 isMeshPhysicalMaterial: true,
                 isMeshStandardMaterial: true,
             },
             strategies: [
-                uniformStrategy(),
+                (0, strategy_1.uniformStrategy)(),
                 stage === 'fragment'
-                    ? texture2DStrategy()
-                    : namedAttributeStrategy('position'),
+                    ? (0, strategy_1.texture2DStrategy)()
+                    : (0, strategy_1.namedAttributeStrategy)('position'),
             ],
         },
         inputs: [],
@@ -204,6 +211,7 @@ export var physicalNode = function (id, name, position, uniforms, stage) {
         stage: stage,
     });
 };
+exports.physicalNode = physicalNode;
 var cacher = function (engineContext, graph, node, sibling, newValue) {
     var cacheKey = programCacheKey(engineContext, graph, node, sibling);
     if (engineContext.runtime.cache.data[cacheKey]) {
@@ -262,18 +270,18 @@ var onBeforeCompileMegaShader = function (engineContext, newMat) {
 };
 var megaShaderMainpulateAst = function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
     var programAst = ast;
-    var mainName = 'main' || nodeName(node);
+    var mainName = 'main' || (0, graph_2.nodeName)(node);
     if (node.stage === 'vertex') {
-        if (doesLinkThruShader(graph, node)) {
-            returnGlPositionHardCoded(mainName, programAst, 'vec3', 'transformed');
+        if ((0, graph_2.doesLinkThruShader)(graph, node)) {
+            (0, ast_1.returnGlPositionHardCoded)(mainName, programAst, 'vec3', 'transformed');
         }
         else {
-            returnGlPosition(mainName, programAst);
+            (0, ast_1.returnGlPosition)(mainName, programAst);
         }
     }
     // 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, sibling);
+    (0, graph_1.mangleMainFn)(programAst, node, sibling);
     return programAst;
 };
 var nodeCacheKey = function (graph, node) {
@@ -298,7 +306,7 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
     var scene = engineContext.runtime.scene;
     var lights = [];
     scene.traverse(function (obj) {
-        if (obj instanceof Light) {
+        if (obj instanceof three_1.Light) {
             lights.push(obj.type);
         }
     });
@@ -312,20 +320,21 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
         '|Envtex:' +
         scene.environmentTexture);
 };
-export var defaultPropertySetting = function (property) {
+var defaultPropertySetting = function (property) {
     if (property.type === 'texture') {
-        return new Texture();
+        return new three_1.Texture();
     }
     else if (property.type === 'number') {
         return 0.5;
     }
     else if (property.type === 'rgb') {
-        return new Color(1, 1, 1);
+        return new three_1.Color(1, 1, 1);
     }
     else if (property.type === 'rgba') {
-        return new Vector4(1, 1, 1, 1);
+        return new three_1.Vector4(1, 1, 1, 1);
     }
 };
+exports.defaultPropertySetting = defaultPropertySetting;
 var threeMaterialProperties = function (graph, node, sibling) {
     // Find inputs to this node that are dependent on a property of the material
     var propertyInputs = node.inputs
@@ -344,7 +353,7 @@ var threeMaterialProperties = function (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(property_1);
+            acc[property_1.property] = (0, exports.defaultPropertySetting)(property_1);
         }
         return acc;
     }, {});
@@ -354,53 +363,53 @@ var evaluateNode = function (node) {
         return parseFloat(node.value);
     }
     if (node.type === 'vector2') {
-        return new Vector2(parseFloat(node.value[0]), parseFloat(node.value[1]));
+        return new three_1.Vector2(parseFloat(node.value[0]), parseFloat(node.value[1]));
     }
     else if (node.type === 'vector3') {
-        return new Vector3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
+        return new three_1.Vector3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
     }
     else if (node.type === 'vector4') {
-        return new Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
+        return new three_1.Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
     }
     else if (node.type === 'rgb') {
-        return new Color(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
+        return new three_1.Color(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
     }
     else if (node.type === 'rgba') {
-        return new Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
+        return new three_1.Vector4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
     }
     else {
         return node.value;
     }
 };
-export var toonNode = function (id, name, position, uniforms, stage) {
-    return prepopulatePropertyInputs({
+var toonNode = function (id, name, position, uniforms, stage) {
+    return (0, graph_1.prepopulatePropertyInputs)({
         id: id,
         name: 'MeshToonMaterial',
         position: position,
         engine: true,
-        type: EngineNodeType.toon,
+        type: engine_1.EngineNodeType.toon,
         config: {
             uniforms: uniforms,
             version: 3,
             preprocess: true,
             mangle: false,
             properties: [
-                property('Color', 'color', 'rgb', 'uniform_diffuse'),
-                property('Texture', 'map', 'texture', 'filler_map'),
-                property('Gradient Map', 'gradientMap', 'texture', 'filler_gradientMap'),
-                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('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
-                property('Displacement Scale', 'displacementScale', 'number'),
-                property('Env Map', 'envMap', 'samplerCube'),
+                (0, code_nodes_1.property)('Color', 'color', 'rgb', 'uniform_diffuse'),
+                (0, code_nodes_1.property)('Texture', 'map', 'texture', 'filler_map'),
+                (0, code_nodes_1.property)('Gradient Map', 'gradientMap', 'texture', 'filler_gradientMap'),
+                (0, code_nodes_1.property)('Normal Map', 'normalMap', 'texture', 'filler_normalMap'),
+                (0, code_nodes_1.property)('Normal Scale', 'normalScale', 'vector2'),
+                (0, code_nodes_1.property)('AO Map', 'aoMap', 'texture', 'filler_aoMap'),
+                (0, code_nodes_1.property)('AO Intensity', 'aoMapIntensity', 'number', 'filler_aoMapIntensity'),
+                (0, code_nodes_1.property)('Displacement Map', 'displacementMap', 'texture', 'filler_displacementMap'),
+                (0, code_nodes_1.property)('Displacement Scale', 'displacementScale', 'number'),
+                (0, code_nodes_1.property)('Env Map', 'envMap', 'samplerCube'),
             ],
             strategies: [
-                uniformStrategy(),
+                (0, strategy_1.uniformStrategy)(),
                 stage === 'fragment'
-                    ? texture2DStrategy()
-                    : namedAttributeStrategy('position'),
+                    ? (0, strategy_1.texture2DStrategy)()
+                    : (0, strategy_1.namedAttributeStrategy)('position'),
             ],
         },
         inputs: [],
@@ -416,19 +425,20 @@ export var toonNode = function (id, name, position, uniforms, stage) {
         stage: stage,
     });
 };
-export var threngine = {
+exports.toonNode = toonNode;
+exports.threngine = {
     name: 'three',
     displayName: 'Three.js',
-    importers: importers,
+    importers: importers_1.default,
     mergeOptions: {
         includePrecisions: true,
         includeVersion: true,
     },
     evaluateNode: evaluateNode,
     constructors: (_a = {},
-        _a[EngineNodeType.phong] = phongNode,
-        _a[EngineNodeType.physical] = physicalNode,
-        _a[EngineNodeType.toon] = toonNode,
+        _a[engine_1.EngineNodeType.phong] = exports.phongNode,
+        _a[engine_1.EngineNodeType.physical] = exports.physicalNode,
+        _a[engine_1.EngineNodeType.toon] = exports.toonNode,
         _a),
     // TODO: Get from uniform lib?
     preserve: new Set([
@@ -504,27 +514,27 @@ export var threngine = {
         'displacementBias',
     ]),
     parsers: (_b = {},
-        _b[NodeType.SOURCE] = {
+        _b[graph_types_1.NodeType.SOURCE] = {
             manipulateAst: function (engineContext, engine, graph, ast, inputEdges, node, sibling) {
                 var programAst = ast;
-                var mainName = 'main' || nodeName(node);
+                var mainName = 'main' || (0, graph_2.nodeName)(node);
                 // This hinges on the vertex shader calling vec3(p)
                 if (node.stage === 'vertex') {
-                    if (doesLinkThruShader(graph, node)) {
-                        returnGlPositionVec3Right(mainName, programAst);
+                    if ((0, graph_2.doesLinkThruShader)(graph, node)) {
+                        (0, ast_1.returnGlPositionVec3Right)(mainName, programAst);
                     }
                     else {
-                        returnGlPosition(mainName, programAst);
+                        (0, ast_1.returnGlPosition)(mainName, programAst);
                     }
                 }
                 return ast;
             },
         },
-        _b[EngineNodeType.phong] = {
+        _b[engine_1.EngineNodeType.phong] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshPhongMaterial(__assign({ 
+                        return onBeforeCompileMegaShader(engineContext, new three_1.MeshPhongMaterial(__assign({ 
                             // @ts-ignore
                             isMeshPhongMaterial: true }, threeMaterialProperties(graph, node, sibling))));
                     });
@@ -533,22 +543,22 @@ export var threngine = {
             }); },
             manipulateAst: megaShaderMainpulateAst,
         },
-        _b[EngineNodeType.physical] = {
+        _b[engine_1.EngineNodeType.physical] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
+                        return onBeforeCompileMegaShader(engineContext, new three_1.MeshPhysicalMaterial(__assign(__assign({}, node.config.hardCodedProperties), threeMaterialProperties(graph, node, sibling))));
                     });
                     return [2 /*return*/];
                 });
             }); },
             manipulateAst: megaShaderMainpulateAst,
         },
-        _b[EngineNodeType.toon] = {
+        _b[engine_1.EngineNodeType.toon] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) { return __awaiter(void 0, void 0, void 0, function () {
                 return __generator(this, function (_a) {
                     cacher(engineContext, graph, node, sibling, function () {
-                        return onBeforeCompileMegaShader(engineContext, new MeshToonMaterial(__assign({ gradientMap: new Texture(), 
+                        return onBeforeCompileMegaShader(engineContext, new three_1.MeshToonMaterial(__assign({ gradientMap: new three_1.Texture(), 
                             // @ts-ignore
                             isMeshToonMaterial: true }, threeMaterialProperties(graph, node, sibling))));
                     });
@@ -559,16 +569,16 @@ export var threngine = {
         },
         _b),
 };
-export var createMaterial = function (compileResult, ctx) {
+var createMaterial = function (compileResult, ctx) {
     var engineMaterial = ctx.runtime.engineMaterial;
-    var finalUniforms = __assign(__assign(__assign(__assign({}, ShaderLib.phong.uniforms), ShaderLib.toon.uniforms), ShaderLib.physical.uniforms), { time: { value: 0 }, cameraPosition: { value: new Vector3(1.0) } });
+    var finalUniforms = __assign(__assign(__assign(__assign({}, three_1.ShaderLib.phong.uniforms), three_1.ShaderLib.toon.uniforms), three_1.ShaderLib.physical.uniforms), { time: { value: 0 }, cameraPosition: { value: new three_1.Vector3(1.0) } });
     // Also the ThreeComponent's sceneConfig properties modify the material
     var initialProperties = {
         name: 'ShaderFrog Material',
         lights: true,
         uniforms: __assign({}, finalUniforms),
         // See https://github.com/mrdoob/three.js/pull/26809
-        glslVersion: GLSL3,
+        glslVersion: three_1.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', ''),
     };
@@ -596,7 +606,7 @@ export var createMaterial = function (compileResult, ctx) {
         var _c = __read(_a, 2), key = _c[0], value = _c[1];
         return (__assign(__assign({}, acc), (_b = {}, _b[key] = value, _b)));
     }, {});
-    var material = new RawShaderMaterial(initialProperties);
+    var material = new three_1.RawShaderMaterial(initialProperties);
     // This prevents a deluge of warnings from three on the constructor saying
     // that each of these properties is not a property of the material
     Object.entries(additionalProperties).forEach(function (_a) {
@@ -606,3 +616,4 @@ export var createMaterial = function (compileResult, ctx) {
     });
     return material;
 };
+exports.createMaterial = createMaterial;

package/strategy/assignemntTo.js

@@ -1,19 +1,23 @@
-import { findAssignmentTo } from '../util/ast';
-import { nodeInput } from '../graph/base-node';
-import { StrategyType } from '.';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyAssignmentToStrategy = exports.assignemntToStrategy = void 0;
+var ast_1 = require("../util/ast");
+var base_node_1 = require("../graph/base-node");
+var _1 = require(".");
 // Constructor
-export var assignemntToStrategy = function (assignTo) { return ({
-    type: StrategyType.ASSIGNMENT_TO,
+var assignemntToStrategy = function (assignTo) { return ({
+    type: _1.StrategyType.ASSIGNMENT_TO,
     config: { assignTo: assignTo },
 }); };
+exports.assignemntToStrategy = assignemntToStrategy;
 // Apply the strategy
-export var applyAssignmentToStrategy = function (strategy, ast, graphNode, siblingNode) {
-    var assignNode = findAssignmentTo(ast, strategy.config.assignTo);
+var applyAssignmentToStrategy = function (strategy, ast, graphNode, siblingNode) {
+    var assignNode = (0, ast_1.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
+                (0, base_node_1.nodeInput)(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
                 ['code', 'data'], false),
                 function (fillerAst) {
                     assignNode.expression.right =
@@ -24,3 +28,4 @@ export var applyAssignmentToStrategy = function (strategy, ast, graphNode, sibli
         ]
         : [];
 };
+exports.applyAssignmentToStrategy = applyAssignmentToStrategy;

package/strategy/declarationOf.js

@@ -1,17 +1,21 @@
-import { findDeclarationOf } from '../util/ast';
-import { nodeInput } from '../graph/base-node';
-import { StrategyType } from '.';
-export var declarationOfStrategy = function (declarationOf) { return ({
-    type: StrategyType.DECLARATION_OF,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.constApplyDeclarationOf = exports.declarationOfStrategy = void 0;
+var ast_1 = require("../util/ast");
+var base_node_1 = require("../graph/base-node");
+var _1 = require(".");
+var declarationOfStrategy = function (declarationOf) { return ({
+    type: _1.StrategyType.DECLARATION_OF,
     config: { declarationOf: declarationOf },
 }); };
-export var constApplyDeclarationOf = function (strategy, ast, graphNode, siblingNode) {
-    var declaration = findDeclarationOf(ast, strategy.config.declarationOf);
+exports.declarationOfStrategy = declarationOfStrategy;
+var constApplyDeclarationOf = function (strategy, ast, graphNode, siblingNode) {
+    var declaration = (0, ast_1.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
+                (0, base_node_1.nodeInput)(name, "filler_".concat(name), 'filler', undefined, // Data type for what plugs into this filler
                 ['code', 'data'], false),
                 function (fillerAst) {
                     declaration.initializer = fillerAst;
@@ -21,3 +25,4 @@ export var constApplyDeclarationOf = function (strategy, ast, graphNode, sibling
         ]
         : [];
 };
+exports.constApplyDeclarationOf = constApplyDeclarationOf;

package/strategy/hardCode.js

@@ -1,9 +1,13 @@
-import { StrategyType } from '.';
-export var hardCodeStrategy = function (inputs) { return ({
-    type: StrategyType.HARD_CODE_INPUTS,
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.applyHardCodeStrategy = exports.hardCodeStrategy = void 0;
+var _1 = require(".");
+var hardCodeStrategy = function (inputs) { return ({
+    type: _1.StrategyType.HARD_CODE_INPUTS,
     config: { inputs: inputs },
 }); };
-export var applyHardCodeStrategy = function (strategy, ast, graphNode, siblingNode) {
+exports.hardCodeStrategy = hardCodeStrategy;
+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 = [
@@ -21,3 +25,4 @@ export var applyHardCodeStrategy = function (strategy, ast, graphNode, siblingNo
         return ci;
     });
 };
+exports.applyHardCodeStrategy = applyHardCodeStrategy;

package/strategy/index.js

@@ -1,9 +1,25 @@
-export * from './hardCode';
-export * from './uniform';
-export * from './assignemntTo';
-export * from './inject';
-export * from './declarationOf';
-export * from './texture2D';
-export * from './namedAttribute';
-export * from './variable';
-export * from './strategy';
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __exportStar = (this && this.__exportStar) || function(m, exports) {
+    for (var p in m) if (p !== "default" && !Object.prototype.hasOwnProperty.call(exports, p)) __createBinding(exports, m, p);
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+__exportStar(require("./hardCode"), exports);
+__exportStar(require("./uniform"), exports);
+__exportStar(require("./assignemntTo"), exports);
+__exportStar(require("./inject"), exports);
+__exportStar(require("./declarationOf"), exports);
+__exportStar(require("./texture2D"), exports);
+__exportStar(require("./namedAttribute"), exports);
+__exportStar(require("./variable"), exports);
+__exportStar(require("./strategy"), exports);