@shaderfrog/core 1.1.1 → 1.2.0

package/plugins/playcanvas/playengine.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++) {
@@ -9,6 +10,29 @@ var __assign = (this && this.__assign) || function () {
     };
     return __assign.apply(this, arguments);
 };
+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 __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || function (mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (k !== "default" && Object.prototype.hasOwnProperty.call(mod, k)) __createBinding(result, mod, k);
+    __setModuleDefault(result, mod);
+    return result;
+};
 var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
     function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
     return new (P || (P = Promise))(function (resolve, reject) {
@@ -70,15 +94,20 @@ 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 * as pc from 'playcanvas';
-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.playengine = exports.mIdx = exports.toonNode = exports.physicalNode = exports.defaultPropertySetting = exports.physicalDefaultProperties = void 0;
+var pc = __importStar(require("playcanvas"));
+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");
 var log = function () {
     var _a;
     var args = [];
@@ -87,7 +116,7 @@ var log = function () {
     }
     return (_a = console.log).call.apply(_a, __spreadArray([console, '\x1b[33m(playengine)\x1b[0m'], __read(args), false));
 };
-export var physicalDefaultProperties = {
+exports.physicalDefaultProperties = {
     // Required for objects with opacity
     blendType: pc.BLEND_NORMAL,
     // Hack (for now?). Playcanvas optimizes their materials to not calculate in
@@ -110,7 +139,7 @@ export var physicalDefaultProperties = {
  * generation where if you set diffuse to white (1,1,1) then it doesn't
  * add the diffuse uniform, because that's the default state.
  */
-export var defaultPropertySetting = function (app, property) {
+var defaultPropertySetting = function (app, property) {
     if (property.type === 'texture') {
         return new pc.Texture(app.graphicsDevice);
     }
@@ -124,6 +153,7 @@ export var defaultPropertySetting = function (app, property) {
         return new pc.Color(0.5, 0.5, 0.5, 0.5);
     }
 };
+exports.defaultPropertySetting = defaultPropertySetting;
 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
@@ -152,7 +182,7 @@ var applyPlayMaterialProperties = function (engineContext, shaderMaterial, app,
              * This code will probably error on some properties because I don't know
              * if all "rgb" properties have to be set in this painful way.
              */
-            acc[property_1.property] = defaultPropertySetting(app, property_1);
+            acc[property_1.property] = (0, exports.defaultPropertySetting)(app, property_1);
             // @ts-ignore
             shaderMaterial[property_1.property] = acc[property_1.property];
         }
@@ -160,35 +190,35 @@ var applyPlayMaterialProperties = function (engineContext, shaderMaterial, app,
     }, {});
     return props;
 };
-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: 'StandardMaterial',
         position: position,
         engine: true,
-        type: EngineNodeType.physical,
+        type: engine_1.EngineNodeType.physical,
         config: {
             uniforms: uniforms,
             version: 3,
             mangle: false,
             preprocess: true,
             properties: [
-                property('Color', 'diffuse', 'rgb'),
+                (0, code_nodes_1.property)('Color', 'diffuse', 'rgb'),
                 // Object is black while using these
                 // property('Emissive', 'emissive', 'rgb'),
                 // property('Emissive Intensity', 'emissiveIntensity', 'number'),
                 // property('Emissive Map', 'emissiveMap', 'texture'),
-                property('Diffuse Map', 'diffuseMap', 'texture', 'filler_texture_diffuseMap'),
-                property('Normal Map', 'normalMap', 'texture', 'filler_texture_normalMap'),
-                property('Bumpiness', 'bumpiness', 'number'),
-                property('Specular', 'specular', 'rgb'),
-                property('Glossiness', 'gloss', 'number'),
-                property('Opacity', 'opacity', 'number'),
-                property('Opacity Map', 'opacityMap', 'texture'),
-                property('Metalness', 'metalness', 'number'),
-                property('Reflectivity', 'reflectivity', 'number'),
-                property('Refraction', 'refraction', 'number'),
-                property('Refraction Index', 'refractionIndex', 'number'),
+                (0, code_nodes_1.property)('Diffuse Map', 'diffuseMap', 'texture', 'filler_texture_diffuseMap'),
+                (0, code_nodes_1.property)('Normal Map', 'normalMap', 'texture', 'filler_texture_normalMap'),
+                (0, code_nodes_1.property)('Bumpiness', 'bumpiness', 'number'),
+                (0, code_nodes_1.property)('Specular', 'specular', 'rgb'),
+                (0, code_nodes_1.property)('Glossiness', 'gloss', 'number'),
+                (0, code_nodes_1.property)('Opacity', 'opacity', 'number'),
+                (0, code_nodes_1.property)('Opacity Map', 'opacityMap', 'texture'),
+                (0, code_nodes_1.property)('Metalness', 'metalness', 'number'),
+                (0, code_nodes_1.property)('Reflectivity', 'reflectivity', 'number'),
+                (0, code_nodes_1.property)('Refraction', 'refraction', 'number'),
+                (0, code_nodes_1.property)('Refraction Index', 'refractionIndex', 'number'),
                 // property('Bump Map', 'bumpTexture', 'texture', 'filler_bumpSampler'),
                 // property('Metalness', 'metallic', 'number'),
                 // property('Roughness', 'roughness', 'number'),
@@ -204,12 +234,12 @@ export var physicalNode = function (id, name, position, uniforms, stage) {
                 // property('Micro Surface', 'microSurface', 'number'),
                 // property('Reflectivity Color', 'reflectivityColor', 'rgb'),
             ],
-            hardCodedProperties: physicalDefaultProperties,
+            hardCodedProperties: exports.physicalDefaultProperties,
             strategies: [
-                uniformStrategy(),
+                (0, strategy_1.uniformStrategy)(),
                 stage === 'fragment'
-                    ? texture2DStrategy()
-                    : namedAttributeStrategy('vertex_position'),
+                    ? (0, strategy_1.texture2DStrategy)()
+                    : (0, strategy_1.namedAttributeStrategy)('vertex_position'),
             ],
         },
         inputs: [],
@@ -225,32 +255,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: [],
@@ -266,8 +297,9 @@ export var toonNode = function (id, name, position, uniforms, stage) {
         stage: stage,
     });
 };
-export var mIdx = 0;
-var id = function () { return mIdx++; };
+exports.toonNode = toonNode;
+exports.mIdx = 0;
+var id = function () { return exports.mIdx++; };
 var nodeCacheKey = function (graph, node) {
     return ('[ID:' +
         node.id +
@@ -391,18 +423,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) {
@@ -453,18 +485,18 @@ var evaluateNode = function (node) {
         return node.value;
     }
 };
-export var playengine = {
+exports.playengine = {
     name: 'playcanvas',
     displayName: 'PlayCanvas',
-    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: Move into core based on engine shader scrape
     preserve: new Set([
@@ -485,23 +517,23 @@ export var playengine = {
         'vUv0',
     ]),
     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);
@@ -511,7 +543,7 @@ export var playengine = {
         },
         _b),
 };
-playengine.parsers[EngineNodeType.toon] =
-    playengine.parsers[EngineNodeType.physical];
-playengine.parsers[EngineNodeType.phong] =
-    playengine.parsers[EngineNodeType.physical];
+exports.playengine.parsers[engine_1.EngineNodeType.toon] =
+    exports.playengine.parsers[engine_1.EngineNodeType.physical];
+exports.playengine.parsers[engine_1.EngineNodeType.phong] =
+    exports.playengine.parsers[engine_1.EngineNodeType.physical];

package/plugins/three/importers.js

@@ -1,8 +1,10 @@
-import { renameBindings } from '@shaderfrog/glsl-parser/parser/utils';
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+var utils_1 = require("@shaderfrog/glsl-parser/parser/utils");
 var importers = {
     babylon: {
         convertAst: function (ast, type) {
-            renameBindings(ast.scopes[0], function (name) {
+            (0, utils_1.renameBindings)(ast.scopes[0], function (name) {
                 return name === 'vMainUV1' ? 'vUv' : name === 'vNormalW' ? 'vNormal' : name;
             });
         },
@@ -12,4 +14,4 @@ var importers = {
         },
     },
 };
-export default importers;
+exports.default = importers;

package/plugins/three/index.js

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