@shaderfrog/core 1.1.1 → 1.2.0

package/plugins/babylon/bablyengine.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,23 +71,28 @@ 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 { PBRMaterial, Texture, Light, Vector2, Vector3, Vector4, Color3, Color4, } from 'babylonjs';
-import { EngineNodeType } from '../../engine';
-import { nodeName, 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';
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.babylengine = exports.mIdx = exports.toonNode = exports.physicalNode = exports.physicalDefaultProperties = void 0;
+var babylonjs_1 = require("babylonjs");
+var engine_1 = require("../../engine");
+var graph_1 = require("../../graph/graph");
+var graph_types_1 = require("../../graph/graph-types");
+var importers_1 = __importDefault(require("./importers"));
+var ast_1 = require("../../util/ast");
+var code_nodes_1 = require("../../graph/code-nodes");
+var strategy_1 = require("../../strategy");
 // 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
 // properties as those in BabylonComponent or else there will be errors with
 // uniforms
-export var physicalDefaultProperties = {
+exports.physicalDefaultProperties = {
     forceIrradianceInFragment: true,
-    albedoColor: new Color3(1.0, 1.0, 1.0),
+    albedoColor: new babylonjs_1.Color3(1.0, 1.0, 1.0),
     metallic: 0.0,
     roughness: 1.0,
 };
@@ -99,43 +105,43 @@ var log = function () {
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[33m(babylengine)\x1b[0m'], __read(args), false));
 };
 var babylonHackCache = {};
-export var physicalNode = function (id, name, position, uniforms, stage) {
-    return prepopulatePropertyInputs({
+var physicalNode = function (id, name, position, uniforms, stage) {
+    return (0, graph_1.prepopulatePropertyInputs)({
         id: id,
         name: 'PBRMaterial',
         position: position,
         engine: true,
-        type: EngineNodeType.physical,
+        type: engine_1.EngineNodeType.physical,
         config: {
             uniforms: uniforms,
             version: 3,
             mangle: false,
             preprocess: true,
             properties: [
-                property('Base Color', 'baseColor', 'rgb', '?????'),
-                property('Color', 'albedoColor', 'rgb', 'uniform_vAlbedoColor'),
-                property('Texture', 'albedoTexture', 'texture', 'filler_albedoSampler'),
-                property('Bump Map', 'bumpTexture', 'texture', 'filler_bumpSampler'),
-                property('Metalness', 'metallic', 'number'),
-                property('Roughness', 'roughness', 'number'),
-                property('Env Map', 'environmentTexture', 'samplerCube'),
-                property('Reflection Texture', 'reflectionTexture', 'samplerCube'),
-                property('Refraction Texture', 'refractionTexture', 'samplerCube'),
-                property('Index Of Refraction', 'indexOfRefraction', 'number'),
-                property('Alpha', 'alpha', 'number'),
-                property('Direct Intensity', 'directIntensity', 'number'),
-                property('Environment Intensity', 'environmentIntensity', 'number'),
-                property('Camera Exposure', 'cameraExposure', 'number'),
-                property('Camera Contrast', 'cameraContrast', 'number'),
-                property('Micro Surface', 'microSurface', 'number'),
-                property('Reflectivity Color', 'reflectivityColor', 'rgb'),
+                (0, code_nodes_1.property)('Base Color', 'baseColor', 'rgb', '?????'),
+                (0, code_nodes_1.property)('Color', 'albedoColor', 'rgb', 'uniform_vAlbedoColor'),
+                (0, code_nodes_1.property)('Texture', 'albedoTexture', 'texture', 'filler_albedoSampler'),
+                (0, code_nodes_1.property)('Bump Map', 'bumpTexture', 'texture', 'filler_bumpSampler'),
+                (0, code_nodes_1.property)('Metalness', 'metallic', 'number'),
+                (0, code_nodes_1.property)('Roughness', 'roughness', 'number'),
+                (0, code_nodes_1.property)('Env Map', 'environmentTexture', 'samplerCube'),
+                (0, code_nodes_1.property)('Reflection Texture', 'reflectionTexture', 'samplerCube'),
+                (0, code_nodes_1.property)('Refraction Texture', 'refractionTexture', 'samplerCube'),
+                (0, code_nodes_1.property)('Index Of Refraction', 'indexOfRefraction', 'number'),
+                (0, code_nodes_1.property)('Alpha', 'alpha', 'number'),
+                (0, code_nodes_1.property)('Direct Intensity', 'directIntensity', 'number'),
+                (0, code_nodes_1.property)('Environment Intensity', 'environmentIntensity', 'number'),
+                (0, code_nodes_1.property)('Camera Exposure', 'cameraExposure', 'number'),
+                (0, code_nodes_1.property)('Camera Contrast', 'cameraContrast', 'number'),
+                (0, code_nodes_1.property)('Micro Surface', 'microSurface', 'number'),
+                (0, code_nodes_1.property)('Reflectivity Color', 'reflectivityColor', 'rgb'),
             ],
-            hardCodedProperties: physicalDefaultProperties,
+            hardCodedProperties: exports.physicalDefaultProperties,
             strategies: [
-                uniformStrategy(),
+                (0, strategy_1.uniformStrategy)(),
                 stage === 'fragment'
-                    ? texture2DStrategy()
-                    : namedAttributeStrategy('position'),
+                    ? (0, strategy_1.texture2DStrategy)()
+                    : (0, strategy_1.namedAttributeStrategy)('position'),
             ],
         },
         inputs: [],
@@ -151,32 +157,33 @@ export var physicalNode = function (id, name, position, uniforms, stage) {
         stage: stage,
     });
 };
-export var toonNode = function (id, name, position, uniforms, stage) {
-    return prepopulatePropertyInputs({
+exports.physicalNode = physicalNode;
+var toonNode = function (id, name, position, uniforms, stage) {
+    return (0, graph_1.prepopulatePropertyInputs)({
         id: id,
         name: name,
         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('Displacement Map', 'displacementMap', 'texture'),
-                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)('Displacement Map', 'displacementMap', 'texture'),
+                (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: [],
@@ -192,6 +199,7 @@ export var toonNode = function (id, name, position, uniforms, stage) {
         stage: stage,
     });
 };
+exports.toonNode = toonNode;
 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
@@ -211,24 +219,24 @@ var babylonMaterialProperties = function (scene, graph, node, sibling) {
             var property_1 = (node.config.properties || []).find(function (p) { return p.property === propertyInput.property; });
             // Initialize the property on the material
             if (property_1.type === 'texture') {
-                acc[property_1.property] = new Texture('', scene);
+                acc[property_1.property] = new babylonjs_1.Texture('', scene);
             }
             else if (property_1.type === 'number') {
                 acc[property_1.property] = 0.5;
             }
             else if (property_1.type === 'rgb') {
-                acc[property_1.property] = new Color3(1, 1, 1);
+                acc[property_1.property] = new babylonjs_1.Color3(1, 1, 1);
             }
             else if (property_1.type === 'rgba') {
-                acc[property_1.property] = new Color4(1, 1, 1, 1);
+                acc[property_1.property] = new babylonjs_1.Color4(1, 1, 1, 1);
             }
         }
         return acc;
     }, {});
     return props;
 };
-export var mIdx = 0;
-var id = function () { return mIdx++; };
+exports.mIdx = 0;
+var id = function () { return exports.mIdx++; };
 var nodeCacheKey = function (graph, node) {
     return ('[ID:' +
         node.id +
@@ -249,7 +257,7 @@ var programCacheKey = function (engineContext, graph, node, sibling) {
     // 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 scene = engineContext.runtime.scene;
-    var lights = scene.getNodes().filter(function (n) { return n instanceof Light; });
+    var lights = scene.getNodes().filter(function (n) { return n instanceof babylonjs_1.Light; });
     return ([node, sibling]
         .filter(function (n) { return !!n; })
         .sort(function (a, b) { return a.id.localeCompare(b.id); })
@@ -298,7 +306,7 @@ var onBeforeCompileMegaShader = function (engineContext, graph, node, sibling) {
     return __generator(this, function (_c) {
         _a = engineContext.runtime, scene = _a.scene, sceneData = _a.sceneData;
         pbrName = "engine_pbr".concat(id());
-        shaderMaterial = new PBRMaterial(pbrName, scene);
+        shaderMaterial = new babylonjs_1.PBRMaterial(pbrName, scene);
         shaderMaterial.linkRefractionWithTransparency = true;
         shaderMaterial.subSurface.isRefractionEnabled = true;
         newProperties = __assign(__assign({}, (node.config.hardCodedProperties ||
@@ -397,18 +405,18 @@ 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' || (0, graph_1.nodeName)(node);
     if (node.stage === 'vertex') {
-        if (doesLinkThruShader(graph, node)) {
-            returnGlPositionHardCoded(mainName, programAst, 'vec3', 'transformed');
+        if ((0, graph_1.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 evaluateNode = function (node) {
@@ -416,36 +424,36 @@ 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 babylonjs_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 babylonjs_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 babylonjs_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 Color3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
+        return new babylonjs_1.Color3(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]));
     }
     else if (node.type === 'rgba') {
-        return new Color4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
+        return new babylonjs_1.Color4(parseFloat(node.value[0]), parseFloat(node.value[1]), parseFloat(node.value[2]), parseFloat(node.value[3]));
     }
     else {
         return node.value;
     }
 };
-export var babylengine = {
+exports.babylengine = {
     name: 'babylon',
     displayName: 'Babylon.js',
-    importers: importers,
+    importers: importers_1.default,
     mergeOptions: {
         includePrecisions: true,
         includeVersion: false,
     },
     evaluateNode: evaluateNode,
     constructors: (_a = {},
-        _a[EngineNodeType.physical] = physicalNode,
-        _a[EngineNodeType.toon] = toonNode,
+        _a[engine_1.EngineNodeType.physical] = exports.physicalNode,
+        _a[engine_1.EngineNodeType.toon] = exports.toonNode,
         _a),
     // TODO: Get from uniform lib?
     preserve: new Set([
@@ -557,23 +565,23 @@ export var babylengine = {
         'reflectionSampler',
     ]),
     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_1.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_1.doesLinkThruShader)(graph, node)) {
+                        (0, ast_1.returnGlPositionVec3Right)(mainName, programAst);
                     }
                     else {
-                        returnGlPosition(mainName, programAst);
+                        (0, ast_1.returnGlPosition)(mainName, programAst);
                     }
                 }
                 return ast;
             },
         },
-        _b[EngineNodeType.physical] = {
+        _b[engine_1.EngineNodeType.physical] = {
             onBeforeCompile: function (graph, engineContext, node, sibling) {
                 return cacher(engineContext, graph, node, sibling, function () {
                     return onBeforeCompileMegaShader(engineContext, graph, node, sibling);
@@ -583,7 +591,7 @@ export var babylengine = {
         },
         _b),
 };
-babylengine.parsers[EngineNodeType.toon] =
-    babylengine.parsers[EngineNodeType.physical];
-babylengine.parsers[EngineNodeType.phong] =
-    babylengine.parsers[EngineNodeType.physical];
+exports.babylengine.parsers[engine_1.EngineNodeType.toon] =
+    exports.babylengine.parsers[engine_1.EngineNodeType.physical];
+exports.babylengine.parsers[engine_1.EngineNodeType.phong] =
+    exports.babylengine.parsers[engine_1.EngineNodeType.physical];

package/plugins/babylon/importers.js

@@ -1,6 +1,8 @@
+"use strict";
 var _a;
-import { renameBindings } from '@shaderfrog/glsl-parser/parser/utils';
-import { EngineNodeType } from '../../engine';
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@shaderfrog/glsl-parser/parser/utils");
+var engine_1 = require("../../engine");
 var nodeInputMap = {
     normalMap: 'bumpSampler',
     property_map: 'property_albedoTexture',
@@ -22,7 +24,7 @@ var importers = {
             // Babylon has no normalmatrix. They do have a normal attribute. So undo any
             // multiplication by normalMatrix?
             var seen = {};
-            renameBindings(ast.scopes[0], function (name) {
+            (0, utils_1.renameBindings)(ast.scopes[0], function (name) {
                 // console.log({ name }, 'seen:', seen[name]);
                 var renamed = name === 'vUv'
                     ? 'vMainUV1'
@@ -50,7 +52,7 @@ var importers = {
             });
         },
         nodeInputMap: (_a = {},
-            _a[EngineNodeType.physical] = nodeInputMap,
+            _a[engine_1.EngineNodeType.physical] = nodeInputMap,
             _a),
         edgeMap: {
             normalMap: 'bumpSampler',
@@ -61,4 +63,4 @@ var importers = {
         },
     },
 };
-export default importers;
+exports.default = importers;

package/plugins/babylon/index.js

@@ -1,2 +1,5 @@
-import { babylengine } from './bablyengine';
-export { babylengine as engine };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.engine = void 0;
+var bablyengine_1 = require("./bablyengine");
+Object.defineProperty(exports, "engine", { enumerable: true, get: function () { return bablyengine_1.babylengine; } });

package/plugins/playcanvas/importers.js

@@ -1,5 +1,7 @@
+"use strict";
 var _a;
-import { EngineNodeType } from '../../engine';
+Object.defineProperty(exports, "__esModule", { value: true });
+var engine_1 = require("../../engine");
 var nodeInputMap = {
     normalMap: 'bumpSampler',
     property_map: 'property_albedoTexture',
@@ -14,7 +16,7 @@ var importers = {
             throw new Error('Not implemented');
         },
         nodeInputMap: (_a = {},
-            _a[EngineNodeType.physical] = nodeInputMap,
+            _a[engine_1.EngineNodeType.physical] = nodeInputMap,
             _a),
         edgeMap: {
             normalMap: 'bumpSampler',
@@ -25,4 +27,4 @@ var importers = {
         },
     },
 };
-export default importers;
+exports.default = importers;

package/plugins/playcanvas/index.js

@@ -1,2 +1,5 @@
-import { playengine } from './playengine';
-export { playengine as engine };
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.engine = void 0;
+var playengine_1 = require("./playengine");
+Object.defineProperty(exports, "engine", { enumerable: true, get: function () { return playengine_1.playengine; } });