nightly (with the new modules!!!)

Tools/Gulp/package.json

@@ -12,4 +12,4 @@
         "install": "cd ../../ && npm install && cd Playground/ && npm install && cd ../Viewer && npm install && cd ../Tools/Gulp/",
         "build": "gulp --max-old-space-size=8192"
     }
-}
+}

dist/preview release/loaders/babylon.stlFileLoader.js

@@ -1,173 +1,420 @@
-/// <reference path="../../../dist/preview release/babylon.d.ts"/>
-var BABYLON;
-(function (BABYLON) {
-    var STLFileLoader = /** @class */ (function () {
-        function STLFileLoader() {
-            this.solidPattern = /solid (\S*)([\S\s]*)endsolid[ ]*(\S*)/g;
-            this.facetsPattern = /facet([\s\S]*?)endfacet/g;
-            this.normalPattern = /normal[\s]+([\-+]?[0-9]+\.?[0-9]*([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+/g;
-            this.vertexPattern = /vertex[\s]+([\-+]?[0-9]+\.?[0-9]*([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+/g;
-            this.name = "stl";
-            // force data to come in as an ArrayBuffer
-            // we'll convert to string if it looks like it's an ASCII .stl
-            this.extensions = {
-                ".stl": { isBinary: true },
-            };
-        }
-        STLFileLoader.prototype.importMesh = function (meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons) {
-            var matches;
-            if (typeof data !== "string") {
-                if (this.isBinary(data)) {
-                    // binary .stl
-                    var babylonMesh = new BABYLON.Mesh("stlmesh", scene);
-                    this.parseBinary(babylonMesh, data);
-                    if (meshes) {
-                        meshes.push(babylonMesh);
-                    }
-                    return true;
-                }
-                // ASCII .stl
-                // convert to string
-                var array_buffer = new Uint8Array(data);
-                var str = '';
-                for (var i = 0; i < data.byteLength; i++) {
-                    str += String.fromCharCode(array_buffer[i]); // implicitly assumes little-endian
-                }
-                data = str;
-            }
-            //if arrived here, data is a string, containing the STLA data.
-            while (matches = this.solidPattern.exec(data)) {
-                var meshName = matches[1];
-                var meshNameFromEnd = matches[3];
-                if (meshName != meshNameFromEnd) {
-                    BABYLON.Tools.Error("Error in STL, solid name != endsolid name");
-                    return false;
-                }
-                // check meshesNames
-                if (meshesNames && meshName) {
-                    if (meshesNames instanceof Array) {
-                        if (!meshesNames.indexOf(meshName)) {
-                            continue;
-                        }
-                    }
-                    else {
-                        if (meshName !== meshesNames) {
-                            continue;
-                        }
-                    }
-                }
-                // stl mesh name can be empty as well
-                meshName = meshName || "stlmesh";
-                var babylonMesh = new BABYLON.Mesh(meshName, scene);
-                this.parseASCII(babylonMesh, matches[2]);
-                if (meshes) {
-                    meshes.push(babylonMesh);
-                }
-            }
-            return true;
-        };
-        STLFileLoader.prototype.load = function (scene, data, rootUrl) {
-            var result = this.importMesh(null, scene, data, rootUrl, null, null, null);
-            if (result) {
-                scene.createDefaultCameraOrLight();
-            }
-            return result;
-        };
-        STLFileLoader.prototype.loadAssetContainer = function (scene, data, rootUrl, onError) {
-            var container = new BABYLON.AssetContainer(scene);
-            this.importMesh(null, scene, data, rootUrl, container.meshes, null, null);
-            container.removeAllFromScene();
-            return container;
-        };
-        STLFileLoader.prototype.isBinary = function (data) {
-            // check if file size is correct for binary stl
-            var faceSize, nFaces, reader;
-            reader = new DataView(data);
-            faceSize = (32 / 8 * 3) + ((32 / 8 * 3) * 3) + (16 / 8);
-            nFaces = reader.getUint32(80, true);
-            if (80 + (32 / 8) + (nFaces * faceSize) === reader.byteLength) {
-                return true;
-            }
-            // check characters higher than ASCII to confirm binary
-            var fileLength = reader.byteLength;
-            for (var index = 0; index < fileLength; index++) {
-                if (reader.getUint8(index) > 127) {
-                    return true;
-                }
-            }
-            return false;
-        };
-        STLFileLoader.prototype.parseBinary = function (mesh, data) {
-            var reader = new DataView(data);
-            var faces = reader.getUint32(80, true);
-            var dataOffset = 84;
-            var faceLength = 12 * 4 + 2;
-            var offset = 0;
-            var positions = new Float32Array(faces * 3 * 3);
-            var normals = new Float32Array(faces * 3 * 3);
-            var indices = new Uint32Array(faces * 3);
-            var indicesCount = 0;
-            for (var face = 0; face < faces; face++) {
-                var start = dataOffset + face * faceLength;
-                var normalX = reader.getFloat32(start, true);
-                var normalY = reader.getFloat32(start + 4, true);
-                var normalZ = reader.getFloat32(start + 8, true);
-                for (var i = 1; i <= 3; i++) {
-                    var vertexstart = start + i * 12;
-                    // ordering is intentional to match ascii import
-                    positions[offset] = reader.getFloat32(vertexstart, true);
-                    positions[offset + 2] = reader.getFloat32(vertexstart + 4, true);
-                    positions[offset + 1] = reader.getFloat32(vertexstart + 8, true);
-                    normals[offset] = normalX;
-                    normals[offset + 2] = normalY;
-                    normals[offset + 1] = normalZ;
-                    offset += 3;
-                }
-                indices[indicesCount] = indicesCount++;
-                indices[indicesCount] = indicesCount++;
-                indices[indicesCount] = indicesCount++;
-            }
-            mesh.setVerticesData(BABYLON.VertexBuffer.PositionKind, positions);
-            mesh.setVerticesData(BABYLON.VertexBuffer.NormalKind, normals);
-            mesh.setIndices(indices);
-            mesh.computeWorldMatrix(true);
-        };
-        STLFileLoader.prototype.parseASCII = function (mesh, solidData) {
-            var positions = [];
-            var normals = [];
-            var indices = [];
-            var indicesCount = 0;
-            //load facets, ignoring loop as the standard doesn't define it can contain more than vertices
-            var matches;
-            while (matches = this.facetsPattern.exec(solidData)) {
-                var facet = matches[1];
-                //one normal per face
-                var normalMatches = this.normalPattern.exec(facet);
-                this.normalPattern.lastIndex = 0;
-                if (!normalMatches) {
-                    continue;
-                }
-                var normal = [Number(normalMatches[1]), Number(normalMatches[5]), Number(normalMatches[3])];
-                var vertexMatch;
-                while (vertexMatch = this.vertexPattern.exec(facet)) {
-                    positions.push(Number(vertexMatch[1]), Number(vertexMatch[5]), Number(vertexMatch[3]));
-                    normals.push(normal[0], normal[1], normal[2]);
-                }
-                indices.push(indicesCount++, indicesCount++, indicesCount++);
-                this.vertexPattern.lastIndex = 0;
-            }
-            this.facetsPattern.lastIndex = 0;
-            mesh.setVerticesData(BABYLON.VertexBuffer.PositionKind, positions);
-            mesh.setVerticesData(BABYLON.VertexBuffer.NormalKind, normals);
-            mesh.setIndices(indices);
-            mesh.computeWorldMatrix(true);
-        };
-        return STLFileLoader;
-    }());
-    BABYLON.STLFileLoader = STLFileLoader;
-    if (BABYLON.SceneLoader) {
-        BABYLON.SceneLoader.RegisterPlugin(new STLFileLoader());
-    }
-})(BABYLON || (BABYLON = {}));
-
-//# sourceMappingURL=babylon.stlFileLoader.js.map
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("babylonjs"));
+	else if(typeof define === 'function' && define.amd)
+		define("babylonjs-loaders", ["babylonjs"], factory);
+	else if(typeof exports === 'object')
+		exports["babylonjs-loaders"] = factory(require("babylonjs"));
+	else
+		root["LOADERS"] = factory(root["BABYLON"]);
+})(window, function(__WEBPACK_EXTERNAL_MODULE_babylonjs_Misc_observable__) {
+return /******/ (function(modules) { // webpackBootstrap
+/******/ 	// The module cache
+/******/ 	var installedModules = {};
+/******/
+/******/ 	// The require function
+/******/ 	function __webpack_require__(moduleId) {
+/******/
+/******/ 		// Check if module is in cache
+/******/ 		if(installedModules[moduleId]) {
+/******/ 			return installedModules[moduleId].exports;
+/******/ 		}
+/******/ 		// Create a new module (and put it into the cache)
+/******/ 		var module = installedModules[moduleId] = {
+/******/ 			i: moduleId,
+/******/ 			l: false,
+/******/ 			exports: {}
+/******/ 		};
+/******/
+/******/ 		// Execute the module function
+/******/ 		modules[moduleId].call(module.exports, module, module.exports, __webpack_require__);
+/******/
+/******/ 		// Flag the module as loaded
+/******/ 		module.l = true;
+/******/
+/******/ 		// Return the exports of the module
+/******/ 		return module.exports;
+/******/ 	}
+/******/
+/******/
+/******/ 	// expose the modules object (__webpack_modules__)
+/******/ 	__webpack_require__.m = modules;
+/******/
+/******/ 	// expose the module cache
+/******/ 	__webpack_require__.c = installedModules;
+/******/
+/******/ 	// define getter function for harmony exports
+/******/ 	__webpack_require__.d = function(exports, name, getter) {
+/******/ 		if(!__webpack_require__.o(exports, name)) {
+/******/ 			Object.defineProperty(exports, name, { enumerable: true, get: getter });
+/******/ 		}
+/******/ 	};
+/******/
+/******/ 	// define __esModule on exports
+/******/ 	__webpack_require__.r = function(exports) {
+/******/ 		if(typeof Symbol !== 'undefined' && Symbol.toStringTag) {
+/******/ 			Object.defineProperty(exports, Symbol.toStringTag, { value: 'Module' });
+/******/ 		}
+/******/ 		Object.defineProperty(exports, '__esModule', { value: true });
+/******/ 	};
+/******/
+/******/ 	// create a fake namespace object
+/******/ 	// mode & 1: value is a module id, require it
+/******/ 	// mode & 2: merge all properties of value into the ns
+/******/ 	// mode & 4: return value when already ns object
+/******/ 	// mode & 8|1: behave like require
+/******/ 	__webpack_require__.t = function(value, mode) {
+/******/ 		if(mode & 1) value = __webpack_require__(value);
+/******/ 		if(mode & 8) return value;
+/******/ 		if((mode & 4) && typeof value === 'object' && value && value.__esModule) return value;
+/******/ 		var ns = Object.create(null);
+/******/ 		__webpack_require__.r(ns);
+/******/ 		Object.defineProperty(ns, 'default', { enumerable: true, value: value });
+/******/ 		if(mode & 2 && typeof value != 'string') for(var key in value) __webpack_require__.d(ns, key, function(key) { return value[key]; }.bind(null, key));
+/******/ 		return ns;
+/******/ 	};
+/******/
+/******/ 	// getDefaultExport function for compatibility with non-harmony modules
+/******/ 	__webpack_require__.n = function(module) {
+/******/ 		var getter = module && module.__esModule ?
+/******/ 			function getDefault() { return module['default']; } :
+/******/ 			function getModuleExports() { return module; };
+/******/ 		__webpack_require__.d(getter, 'a', getter);
+/******/ 		return getter;
+/******/ 	};
+/******/
+/******/ 	// Object.prototype.hasOwnProperty.call
+/******/ 	__webpack_require__.o = function(object, property) { return Object.prototype.hasOwnProperty.call(object, property); };
+/******/
+/******/ 	// __webpack_public_path__
+/******/ 	__webpack_require__.p = "";
+/******/
+/******/
+/******/ 	// Load entry module and return exports
+/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-stlFileLoader.ts");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "../../node_modules/webpack/buildin/global.js":
+/*!***********************************!*\
+  !*** (webpack)/buildin/global.js ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || new Function("return this")();
+} catch (e) {
+	// This works if the window reference is available
+	if (typeof window === "object") g = window;
+}
+
+// g can still be undefined, but nothing to do about it...
+// We return undefined, instead of nothing here, so it's
+// easier to handle this case. if(!global) { ...}
+
+module.exports = g;
+
+
+/***/ }),
+
+/***/ "./STL/index.ts":
+/*!**********************!*\
+  !*** ./STL/index.ts ***!
+  \**********************/
+/*! exports provided: STLFileLoader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _stlFileLoader__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./stlFileLoader */ "./STL/stlFileLoader.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "STLFileLoader", function() { return _stlFileLoader__WEBPACK_IMPORTED_MODULE_0__["STLFileLoader"]; });
+
+
+
+
+/***/ }),
+
+/***/ "./STL/stlFileLoader.ts":
+/*!******************************!*\
+  !*** ./STL/stlFileLoader.ts ***!
+  \******************************/
+/*! exports provided: STLFileLoader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "STLFileLoader", function() { return STLFileLoader; });
+/* harmony import */ var babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! babylonjs/Misc/tools */ "babylonjs/Misc/observable");
+/* harmony import */ var babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0___default = /*#__PURE__*/__webpack_require__.n(babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__);
+
+
+
+
+
+/**
+ * STL file type loader.
+ * This is a babylon scene loader plugin.
+ */
+var STLFileLoader = /** @class */ (function () {
+    function STLFileLoader() {
+        /** @hidden */
+        this.solidPattern = /solid (\S*)([\S\s]*)endsolid[ ]*(\S*)/g;
+        /** @hidden */
+        this.facetsPattern = /facet([\s\S]*?)endfacet/g;
+        /** @hidden */
+        this.normalPattern = /normal[\s]+([\-+]?[0-9]+\.?[0-9]*([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+/g;
+        /** @hidden */
+        this.vertexPattern = /vertex[\s]+([\-+]?[0-9]+\.?[0-9]*([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+[\s]+([\-+]?[0-9]*\.?[0-9]+([eE][\-+]?[0-9]+)?)+/g;
+        /**
+         * Defines the name of the plugin.
+         */
+        this.name = "stl";
+        /**
+         * Defines the extensions the stl loader is able to load.
+         * force data to come in as an ArrayBuffer
+         * we'll convert to string if it looks like it's an ASCII .stl
+         */
+        this.extensions = {
+            ".stl": { isBinary: true },
+        };
+    }
+    /**
+     * Import meshes into a scene.
+     * @param meshesNames An array of mesh names, a single mesh name, or empty string for all meshes that filter what meshes are imported
+     * @param scene The scene to import into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @param meshes The meshes array to import into
+     * @param particleSystems The particle systems array to import into
+     * @param skeletons The skeletons array to import into
+     * @param onError The callback when import fails
+     * @returns True if successful or false otherwise
+     */
+    STLFileLoader.prototype.importMesh = function (meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons) {
+        var matches;
+        if (typeof data !== "string") {
+            if (this._isBinary(data)) {
+                // binary .stl
+                var babylonMesh = new babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["Mesh"]("stlmesh", scene);
+                this._parseBinary(babylonMesh, data);
+                if (meshes) {
+                    meshes.push(babylonMesh);
+                }
+                return true;
+            }
+            // ASCII .stl
+            // convert to string
+            var array_buffer = new Uint8Array(data);
+            var str = '';
+            for (var i = 0; i < data.byteLength; i++) {
+                str += String.fromCharCode(array_buffer[i]); // implicitly assumes little-endian
+            }
+            data = str;
+        }
+        //if arrived here, data is a string, containing the STLA data.
+        while (matches = this.solidPattern.exec(data)) {
+            var meshName = matches[1];
+            var meshNameFromEnd = matches[3];
+            if (meshName != meshNameFromEnd) {
+                babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["Tools"].Error("Error in STL, solid name != endsolid name");
+                return false;
+            }
+            // check meshesNames
+            if (meshesNames && meshName) {
+                if (meshesNames instanceof Array) {
+                    if (!meshesNames.indexOf(meshName)) {
+                        continue;
+                    }
+                }
+                else {
+                    if (meshName !== meshesNames) {
+                        continue;
+                    }
+                }
+            }
+            // stl mesh name can be empty as well
+            meshName = meshName || "stlmesh";
+            var babylonMesh = new babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["Mesh"](meshName, scene);
+            this._parseASCII(babylonMesh, matches[2]);
+            if (meshes) {
+                meshes.push(babylonMesh);
+            }
+        }
+        return true;
+    };
+    /**
+     * Load into a scene.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @param onError The callback when import fails
+     * @returns true if successful or false otherwise
+     */
+    STLFileLoader.prototype.load = function (scene, data, rootUrl) {
+        var result = this.importMesh(null, scene, data, rootUrl, null, null, null);
+        if (result) {
+            scene.createDefaultLight();
+            scene.createDefaultCameraOrLight();
+        }
+        return result;
+    };
+    /**
+     * Load into an asset container.
+     * @param scene The scene to load into
+     * @param data The data to import
+     * @param rootUrl The root url for scene and resources
+     * @param onError The callback when import fails
+     * @returns The loaded asset container
+     */
+    STLFileLoader.prototype.loadAssetContainer = function (scene, data, rootUrl, onError) {
+        var container = new babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["AssetContainer"](scene);
+        this.importMesh(null, scene, data, rootUrl, container.meshes, null, null);
+        container.removeAllFromScene();
+        return container;
+    };
+    STLFileLoader.prototype._isBinary = function (data) {
+        // check if file size is correct for binary stl
+        var faceSize, nFaces, reader;
+        reader = new DataView(data);
+        faceSize = (32 / 8 * 3) + ((32 / 8 * 3) * 3) + (16 / 8);
+        nFaces = reader.getUint32(80, true);
+        if (80 + (32 / 8) + (nFaces * faceSize) === reader.byteLength) {
+            return true;
+        }
+        // check characters higher than ASCII to confirm binary
+        var fileLength = reader.byteLength;
+        for (var index = 0; index < fileLength; index++) {
+            if (reader.getUint8(index) > 127) {
+                return true;
+            }
+        }
+        return false;
+    };
+    STLFileLoader.prototype._parseBinary = function (mesh, data) {
+        var reader = new DataView(data);
+        var faces = reader.getUint32(80, true);
+        var dataOffset = 84;
+        var faceLength = 12 * 4 + 2;
+        var offset = 0;
+        var positions = new Float32Array(faces * 3 * 3);
+        var normals = new Float32Array(faces * 3 * 3);
+        var indices = new Uint32Array(faces * 3);
+        var indicesCount = 0;
+        for (var face = 0; face < faces; face++) {
+            var start = dataOffset + face * faceLength;
+            var normalX = reader.getFloat32(start, true);
+            var normalY = reader.getFloat32(start + 4, true);
+            var normalZ = reader.getFloat32(start + 8, true);
+            for (var i = 1; i <= 3; i++) {
+                var vertexstart = start + i * 12;
+                // ordering is intentional to match ascii import
+                positions[offset] = reader.getFloat32(vertexstart, true);
+                positions[offset + 2] = reader.getFloat32(vertexstart + 4, true);
+                positions[offset + 1] = reader.getFloat32(vertexstart + 8, true);
+                normals[offset] = normalX;
+                normals[offset + 2] = normalY;
+                normals[offset + 1] = normalZ;
+                offset += 3;
+            }
+            indices[indicesCount] = indicesCount++;
+            indices[indicesCount] = indicesCount++;
+            indices[indicesCount] = indicesCount++;
+        }
+        mesh.setVerticesData(babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["VertexBuffer"].PositionKind, positions);
+        mesh.setVerticesData(babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["VertexBuffer"].NormalKind, normals);
+        mesh.setIndices(indices);
+        mesh.computeWorldMatrix(true);
+    };
+    STLFileLoader.prototype._parseASCII = function (mesh, solidData) {
+        var positions = [];
+        var normals = [];
+        var indices = [];
+        var indicesCount = 0;
+        //load facets, ignoring loop as the standard doesn't define it can contain more than vertices
+        var matches;
+        while (matches = this.facetsPattern.exec(solidData)) {
+            var facet = matches[1];
+            //one normal per face
+            var normalMatches = this.normalPattern.exec(facet);
+            this.normalPattern.lastIndex = 0;
+            if (!normalMatches) {
+                continue;
+            }
+            var normal = [Number(normalMatches[1]), Number(normalMatches[5]), Number(normalMatches[3])];
+            var vertexMatch;
+            while (vertexMatch = this.vertexPattern.exec(facet)) {
+                positions.push(Number(vertexMatch[1]), Number(vertexMatch[5]), Number(vertexMatch[3]));
+                normals.push(normal[0], normal[1], normal[2]);
+            }
+            indices.push(indicesCount++, indicesCount++, indicesCount++);
+            this.vertexPattern.lastIndex = 0;
+        }
+        this.facetsPattern.lastIndex = 0;
+        mesh.setVerticesData(babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["VertexBuffer"].PositionKind, positions);
+        mesh.setVerticesData(babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["VertexBuffer"].NormalKind, normals);
+        mesh.setIndices(indices);
+        mesh.computeWorldMatrix(true);
+    };
+    return STLFileLoader;
+}());
+
+if (babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["SceneLoader"]) {
+    babylonjs_Misc_tools__WEBPACK_IMPORTED_MODULE_0__["SceneLoader"].RegisterPlugin(new STLFileLoader());
+}
+
+
+/***/ }),
+
+/***/ "./legacy/legacy-stlFileLoader.ts":
+/*!****************************************!*\
+  !*** ./legacy/legacy-stlFileLoader.ts ***!
+  \****************************************/
+/*! exports provided: STLFileLoader */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* WEBPACK VAR INJECTION */(function(global) {/* harmony import */ var _STL__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../STL */ "./STL/index.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "STLFileLoader", function() { return _STL__WEBPACK_IMPORTED_MODULE_0__["STLFileLoader"]; });
+
+
+/**
+ * This is the entry point for the UMD module.
+ * The entry point for a future ESM package should be index.ts
+ */
+var globalObject = (typeof global !== 'undefined') ? global : ((typeof window !== 'undefined') ? window : undefined);
+if (typeof globalObject !== "undefined") {
+    for (var key in _STL__WEBPACK_IMPORTED_MODULE_0__) {
+        globalObject.BABYLON[key] = _STL__WEBPACK_IMPORTED_MODULE_0__[key];
+    }
+}
+
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../node_modules/webpack/buildin/global.js */ "../../node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "babylonjs/Misc/observable":
+/*!****************************************************************************************************!*\
+  !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!
+  \****************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE_babylonjs_Misc_observable__;
+
+/***/ })
+
+/******/ });
+});
+//# sourceMappingURL=babylon.stlFileLoader.js.map

dist/preview release/materialsLibrary/babylon.customMaterial.js

@@ -6,8 +6,8 @@
 	else if(typeof exports === 'object')
 		exports["babylonjs-materials"] = factory(require("babylonjs"));
 	else
-		root["MATLIB"] = factory(root["BABYLON"]);
-})(window, function(__WEBPACK_EXTERNAL_MODULE_babylonjs__) {
+		root["MATERIALS"] = factory(root["BABYLON"]);
+})(window, function(__WEBPACK_EXTERNAL_MODULE_babylonjs_Misc_decorators__) {
 return /******/ (function(modules) { // webpackBootstrap
 /******/ 	// The module cache
 /******/ 	var installedModules = {};
@@ -96,10 +96,10 @@ return /******/ (function(modules) { // webpackBootstrap
 /************************************************************************/
 /******/ ({
 
-/***/ "../node_modules/webpack/buildin/global.js":
-/*!*************************************************!*\
-  !*** ../node_modules/webpack/buildin/global.js ***!
-  \*************************************************/
+/***/ "../../node_modules/webpack/buildin/global.js":
+/*!***********************************!*\
+  !*** (webpack)/buildin/global.js ***!
+  \***********************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -112,7 +112,7 @@ g = (function() {
 
 try {
 	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("this");
+	g = g || new Function("return this")();
 } catch (e) {
 	// This works if the window reference is available
 	if (typeof window === "object") g = window;
@@ -127,80 +127,263 @@ module.exports = g;
 
 /***/ }),
 
-/***/ "./legacy/legacy-custom.ts":
-/*!*********************************!*\
-  !*** ./legacy/legacy-custom.ts ***!
-  \*********************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/***/ "../node_modules/tslib/tslib.es6.js":
+/*!******************************************!*\
+  !*** ../node_modules/tslib/tslib.es6.js ***!
+  \******************************************/
+/*! exports provided: __extends, __assign, __rest, __decorate, __param, __metadata, __awaiter, __generator, __exportStar, __values, __read, __spread, __await, __asyncGenerator, __asyncDelegator, __asyncValues, __makeTemplateObject, __importStar, __importDefault */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-function __export(m) {
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__extends", function() { return __extends; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__assign", function() { return __assign; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__rest", function() { return __rest; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__decorate", function() { return __decorate; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__param", function() { return __param; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__metadata", function() { return __metadata; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__awaiter", function() { return __awaiter; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__generator", function() { return __generator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__exportStar", function() { return __exportStar; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__values", function() { return __values; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__read", function() { return __read; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__spread", function() { return __spread; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__await", function() { return __await; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncGenerator", function() { return __asyncGenerator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncDelegator", function() { return __asyncDelegator; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__asyncValues", function() { return __asyncValues; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__makeTemplateObject", function() { return __makeTemplateObject; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importStar", function() { return __importStar; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "__importDefault", function() { return __importDefault; });
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved.
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0
+
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE,
+MERCHANTABLITY OR NON-INFRINGEMENT.
+
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+/* global Reflect, Promise */
+
+var extendStatics = function(d, b) {
+    extendStatics = Object.setPrototypeOf ||
+        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
+        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
+    return extendStatics(d, b);
+};
+
+function __extends(d, b) {
+    extendStatics(d, b);
+    function __() { this.constructor = d; }
+    d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
+}
+
+var __assign = function() {
+    __assign = Object.assign || function __assign(t) {
+        for (var s, i = 1, n = arguments.length; i < n; i++) {
+            s = arguments[i];
+            for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
+        }
+        return t;
+    }
+    return __assign.apply(this, arguments);
+}
+
+function __rest(s, e) {
+    var t = {};
+    for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p) && e.indexOf(p) < 0)
+        t[p] = s[p];
+    if (s != null && typeof Object.getOwnPropertySymbols === "function")
+        for (var i = 0, p = Object.getOwnPropertySymbols(s); i < p.length; i++) if (e.indexOf(p[i]) < 0)
+            t[p[i]] = s[p[i]];
+    return t;
+}
+
+function __decorate(decorators, target, key, desc) {
+    var c = arguments.length, r = c < 3 ? target : desc === null ? desc = Object.getOwnPropertyDescriptor(target, key) : desc, d;
+    if (typeof Reflect === "object" && typeof Reflect.decorate === "function") r = Reflect.decorate(decorators, target, key, desc);
+    else for (var i = decorators.length - 1; i >= 0; i--) if (d = decorators[i]) r = (c < 3 ? d(r) : c > 3 ? d(target, key, r) : d(target, key)) || r;
+    return c > 3 && r && Object.defineProperty(target, key, r), r;
+}
+
+function __param(paramIndex, decorator) {
+    return function (target, key) { decorator(target, key, paramIndex); }
+}
+
+function __metadata(metadataKey, metadataValue) {
+    if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(metadataKey, metadataValue);
+}
+
+function __awaiter(thisArg, _arguments, P, generator) {
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : new P(function (resolve) { resolve(result.value); }).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+}
+
+function __generator(thisArg, body) {
+    var _ = { label: 0, sent: function() { if (t[0] & 1) throw t[1]; return t[1]; }, trys: [], ops: [] }, f, y, t, g;
+    return g = { next: verb(0), "throw": verb(1), "return": verb(2) }, typeof Symbol === "function" && (g[Symbol.iterator] = function() { return this; }), g;
+    function verb(n) { return function (v) { return step([n, v]); }; }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while (_) try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [op[0] & 2, t.value];
+            switch (op[0]) {
+                case 0: case 1: t = op; break;
+                case 4: _.label++; return { value: op[1], done: false };
+                case 5: _.label++; y = op[1]; op = [0]; continue;
+                case 7: op = _.ops.pop(); _.trys.pop(); continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) { _ = 0; continue; }
+                    if (op[0] === 3 && (!t || (op[1] > t[0] && op[1] < t[3]))) { _.label = op[1]; break; }
+                    if (op[0] === 6 && _.label < t[1]) { _.label = t[1]; t = op; break; }
+                    if (t && _.label < t[2]) { _.label = t[2]; _.ops.push(op); break; }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop(); continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) { op = [6, e]; y = 0; } finally { f = t = 0; }
+        if (op[0] & 5) throw op[1]; return { value: op[0] ? op[1] : void 0, done: true };
+    }
+}
+
+function __exportStar(m, exports) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
-Object.defineProperty(exports, "__esModule", { value: true });
-var MatLib = __webpack_require__(/*! ../src/custom/index */ "./src/custom/index.ts");
-/**
- * This is the entry point for the UMD module.
- * The entry point for a future ESM package should be index.ts
- */
-var globalObject = (typeof global !== 'undefined') ? global : ((typeof window !== 'undefined') ? window : undefined);
-if (typeof globalObject !== "undefined") {
-    for (var key in MatLib) {
-        globalObject.BABYLON[key] = MatLib[key];
+
+function __values(o) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator], i = 0;
+    if (m) return m.call(o);
+    return {
+        next: function () {
+            if (o && i >= o.length) o = void 0;
+            return { value: o && o[i++], done: !o };
+        }
+    };
+}
+
+function __read(o, n) {
+    var m = typeof Symbol === "function" && o[Symbol.iterator];
+    if (!m) return o;
+    var i = m.call(o), r, ar = [], e;
+    try {
+        while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
+    }
+    catch (error) { e = { error: error }; }
+    finally {
+        try {
+            if (r && !r.done && (m = i["return"])) m.call(i);
+        }
+        finally { if (e) throw e.error; }
     }
+    return ar;
+}
+
+function __spread() {
+    for (var ar = [], i = 0; i < arguments.length; i++)
+        ar = ar.concat(__read(arguments[i]));
+    return ar;
+}
+
+function __await(v) {
+    return this instanceof __await ? (this.v = v, this) : new __await(v);
+}
+
+function __asyncGenerator(thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function verb(n) { if (g[n]) i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+}
+
+function __asyncDelegator(o) {
+    var i, p;
+    return i = {}, verb("next"), verb("throw", function (e) { throw e; }), verb("return"), i[Symbol.iterator] = function () { return this; }, i;
+    function verb(n, f) { i[n] = o[n] ? function (v) { return (p = !p) ? { value: __await(o[n](v)), done: n === "return" } : f ? f(v) : v; } : f; }
+}
+
+function __asyncValues(o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+}
+
+function __makeTemplateObject(cooked, raw) {
+    if (Object.defineProperty) { Object.defineProperty(cooked, "raw", { value: raw }); } else { cooked.raw = raw; }
+    return cooked;
+};
+
+function __importStar(mod) {
+    if (mod && mod.__esModule) return mod;
+    var result = {};
+    if (mod != null) for (var k in mod) if (Object.hasOwnProperty.call(mod, k)) result[k] = mod[k];
+    result.default = mod;
+    return result;
+}
+
+function __importDefault(mod) {
+    return (mod && mod.__esModule) ? mod : { default: mod };
 }
-__export(__webpack_require__(/*! ../src/custom/index */ "./src/custom/index.ts"));
 
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node_modules/webpack/buildin/global.js */ "../node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "./src/custom/customMaterial.ts":
-/*!**************************************!*\
-  !*** ./src/custom/customMaterial.ts ***!
-  \**************************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/***/ "./custom/customMaterial.ts":
+/*!**********************************!*\
+  !*** ./custom/customMaterial.ts ***!
+  \**********************************/
+/*! exports provided: CustomShaderStructure, ShaderSpecialParts, CustomMaterial */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CustomShaderStructure", function() { return CustomShaderStructure; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "ShaderSpecialParts", function() { return ShaderSpecialParts; });
+/* harmony export (binding) */ __webpack_require__.d(__webpack_exports__, "CustomMaterial", function() { return CustomMaterial; });
+/* harmony import */ var tslib__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! tslib */ "../node_modules/tslib/tslib.es6.js");
+/* harmony import */ var babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1__ = __webpack_require__(/*! babylonjs/Materials/effect */ "babylonjs/Misc/decorators");
+/* harmony import */ var babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1___default = /*#__PURE__*/__webpack_require__.n(babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1__);
+
+
+
 
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = function (d, b) {
-        extendStatics = Object.setPrototypeOf ||
-            ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-            function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-        return extendStatics(d, b);
-    }
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-Object.defineProperty(exports, "__esModule", { value: true });
-var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
 var CustomShaderStructure = /** @class */ (function () {
     function CustomShaderStructure() {
     }
     return CustomShaderStructure;
 }());
-exports.CustomShaderStructure = CustomShaderStructure;
+
 var ShaderSpecialParts = /** @class */ (function () {
     function ShaderSpecialParts() {
     }
     return ShaderSpecialParts;
 }());
-exports.ShaderSpecialParts = ShaderSpecialParts;
+
 var CustomMaterial = /** @class */ (function (_super) {
-    __extends(CustomMaterial, _super);
+    tslib__WEBPACK_IMPORTED_MODULE_0__["__extends"](CustomMaterial, _super);
     function CustomMaterial(name, scene) {
         var _this = _super.call(this, name, scene) || this;
         _this.CustomParts = new ShaderSpecialParts();
         _this.customShaderNameResolve = _this.Builder;
-        _this.FragmentShader = BABYLON.Effect.ShadersStore["defaultPixelShader"];
-        _this.VertexShader = BABYLON.Effect.ShadersStore["defaultVertexShader"];
+        _this.FragmentShader = babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore["defaultPixelShader"];
+        _this.VertexShader = babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore["defaultVertexShader"];
         return _this;
     }
     CustomMaterial.prototype.AttachAfterBind = function (mesh, effect) {
@@ -267,14 +450,14 @@ var CustomMaterial = /** @class */ (function (_super) {
             }
             catch (e) { }
         };
-        BABYLON.Effect.ShadersStore[name + "VertexShader"] = this.VertexShader
+        babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore[name + "VertexShader"] = this.VertexShader
             .replace('#define CUSTOM_VERTEX_BEGIN', (this.CustomParts.Vertex_Begin ? this.CustomParts.Vertex_Begin : ""))
             .replace('#define CUSTOM_VERTEX_DEFINITIONS', (this._customUniform ? this._customUniform.join("\n") : "") + (this.CustomParts.Vertex_Definitions ? this.CustomParts.Vertex_Definitions : ""))
             .replace('#define CUSTOM_VERTEX_MAIN_BEGIN', (this.CustomParts.Vertex_MainBegin ? this.CustomParts.Vertex_MainBegin : ""))
             .replace('#define CUSTOM_VERTEX_UPDATE_POSITION', (this.CustomParts.Vertex_Before_PositionUpdated ? this.CustomParts.Vertex_Before_PositionUpdated : ""))
             .replace('#define CUSTOM_VERTEX_UPDATE_NORMAL', (this.CustomParts.Vertex_Before_NormalUpdated ? this.CustomParts.Vertex_Before_NormalUpdated : ""));
         // #define CUSTOM_VERTEX_MAIN_END
-        BABYLON.Effect.ShadersStore[name + "PixelShader"] = this.FragmentShader
+        babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1__["Effect"].ShadersStore[name + "PixelShader"] = this.FragmentShader
             .replace('#define CUSTOM_FRAGMENT_BEGIN', (this.CustomParts.Fragment_Begin ? this.CustomParts.Fragment_Begin : ""))
             .replace('#define CUSTOM_FRAGMENT_MAIN_BEGIN', (this.CustomParts.Fragment_MainBegin ? this.CustomParts.Fragment_MainBegin : ""))
             .replace('#define CUSTOM_FRAGMENT_DEFINITIONS', (this._customUniform ? this._customUniform.join("\n") : "") + (this.CustomParts.Fragment_Definitions ? this.CustomParts.Fragment_Definitions : ""))
@@ -352,38 +535,75 @@ var CustomMaterial = /** @class */ (function (_super) {
     };
     CustomMaterial.ShaderIndexer = 1;
     return CustomMaterial;
-}(babylonjs_1.StandardMaterial));
-exports.CustomMaterial = CustomMaterial;
+}(babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1__["StandardMaterial"]));
+
+babylonjs_Materials_effect__WEBPACK_IMPORTED_MODULE_1__["_TypeStore"].RegisteredTypes["BABYLON.CustomMaterial"] = CustomMaterial;
 
 
 /***/ }),
 
-/***/ "./src/custom/index.ts":
-/*!*****************************!*\
-  !*** ./src/custom/index.ts ***!
-  \*****************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
+/***/ "./custom/index.ts":
+/*!*************************!*\
+  !*** ./custom/index.ts ***!
+  \*************************/
+/*! exports provided: CustomShaderStructure, ShaderSpecialParts, CustomMaterial */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
+
+"use strict";
+__webpack_require__.r(__webpack_exports__);
+/* harmony import */ var _customMaterial__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ./customMaterial */ "./custom/customMaterial.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CustomShaderStructure", function() { return _customMaterial__WEBPACK_IMPORTED_MODULE_0__["CustomShaderStructure"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ShaderSpecialParts", function() { return _customMaterial__WEBPACK_IMPORTED_MODULE_0__["ShaderSpecialParts"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CustomMaterial", function() { return _customMaterial__WEBPACK_IMPORTED_MODULE_0__["CustomMaterial"]; });
+
+
+
+
+/***/ }),
+
+/***/ "./legacy/legacy-custom.ts":
+/*!*********************************!*\
+  !*** ./legacy/legacy-custom.ts ***!
+  \*********************************/
+/*! exports provided: CustomShaderStructure, ShaderSpecialParts, CustomMaterial */
+/***/ (function(module, __webpack_exports__, __webpack_require__) {
 
 "use strict";
+__webpack_require__.r(__webpack_exports__);
+/* WEBPACK VAR INJECTION */(function(global) {/* harmony import */ var _custom_index__WEBPACK_IMPORTED_MODULE_0__ = __webpack_require__(/*! ../custom/index */ "./custom/index.ts");
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CustomShaderStructure", function() { return _custom_index__WEBPACK_IMPORTED_MODULE_0__["CustomShaderStructure"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "ShaderSpecialParts", function() { return _custom_index__WEBPACK_IMPORTED_MODULE_0__["ShaderSpecialParts"]; });
+
+/* harmony reexport (safe) */ __webpack_require__.d(__webpack_exports__, "CustomMaterial", function() { return _custom_index__WEBPACK_IMPORTED_MODULE_0__["CustomMaterial"]; });
+
 
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+/**
+ * This is the entry point for the UMD module.
+ * The entry point for a future ESM package should be index.ts
+ */
+var globalObject = (typeof global !== 'undefined') ? global : ((typeof window !== 'undefined') ? window : undefined);
+if (typeof globalObject !== "undefined") {
+    for (var key in _custom_index__WEBPACK_IMPORTED_MODULE_0__) {
+        globalObject.BABYLON[key] = _custom_index__WEBPACK_IMPORTED_MODULE_0__[key];
+    }
 }
-Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./customMaterial */ "./src/custom/customMaterial.ts"));
+
 
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../../node_modules/webpack/buildin/global.js */ "../../node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "babylonjs":
+/***/ "babylonjs/Misc/decorators":
 /*!****************************************************************************************************!*\
   !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!
   \****************************************************************************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
-module.exports = __WEBPACK_EXTERNAL_MODULE_babylonjs__;
+module.exports = __WEBPACK_EXTERNAL_MODULE_babylonjs_Misc_decorators__;
 
 /***/ })
 

dist/preview release/postProcessesLibrary/babylonjs.postProcess.d.ts

@@ -1,163 +1,212 @@
-/*BabylonJS Postprocess library*/
-// Dependencies for this module:
-//   ../../../../Tools/Gulp/babylonjs
+declare module BABYLON {
+    /** @hidden */
+    export var asciiartPixelShader: {
+        name: string;
+        shader: string;
+    };
+}
 declare module BABYLON {
     /**
-        * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
-        *
-        * It basically takes care rendering the font front the given font size to a texture.
-        * This is used later on in the postprocess.
-        */
+     * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
+     *
+     * It basically takes care rendering the font front the given font size to a texture.
+     * This is used later on in the postprocess.
+     */
     export class AsciiArtFontTexture extends BABYLON.BaseTexture {
-            /**
-                * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-                */
-            readonly charSize: number;
-            /**
-                * Create a new instance of the Ascii Art FontTexture class
-                * @param name the name of the texture
-                * @param font the font to use, use the W3C CSS notation
-                * @param text the caracter set to use in the rendering.
-                * @param scene the scene that owns the texture
-                */
-            constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
-            /**
-                * Clones the current AsciiArtTexture.
-                * @return the clone of the texture.
-                */
-            clone(): AsciiArtFontTexture;
-            /**
-                * Parses a json object representing the texture and returns an instance of it.
-                * @param source the source JSON representation
-                * @param scene the scene to create the texture for
-                * @return the parsed texture
-                */
-            static Parse(source: any, scene: BABYLON.Scene): AsciiArtFontTexture;
+        private _font;
+        private _text;
+        private _charSize;
+        /**
+         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+         */
+        readonly charSize: number;
+        /**
+         * Create a new instance of the Ascii Art FontTexture class
+         * @param name the name of the texture
+         * @param font the font to use, use the W3C CSS notation
+         * @param text the caracter set to use in the rendering.
+         * @param scene the scene that owns the texture
+         */
+        constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
+        /**
+         * Gets the max char width of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char width
+         */
+        private getFontWidth;
+        /**
+         * Gets the max char height of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char height
+         */
+        private getFontHeight;
+        /**
+         * Clones the current AsciiArtTexture.
+         * @return the clone of the texture.
+         */
+        clone(): AsciiArtFontTexture;
+        /**
+         * Parses a json object representing the texture and returns an instance of it.
+         * @param source the source JSON representation
+         * @param scene the scene to create the texture for
+         * @return the parsed texture
+         */
+        static Parse(source: any, scene: BABYLON.Scene): AsciiArtFontTexture;
     }
     /**
-        * Option available in the Ascii Art Post Process.
-        */
+     * Option available in the Ascii Art Post Process.
+     */
     export interface IAsciiArtPostProcessOptions {
-            /**
-                * The font to use following the w3c font definition.
-                */
-            font?: string;
-            /**
-                * The character set to use in the postprocess.
-                */
-            characterSet?: string;
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile?: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal?: number;
+        /**
+         * The font to use following the w3c font definition.
+         */
+        font?: string;
+        /**
+         * The character set to use in the postprocess.
+         */
+        characterSet?: string;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile?: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal?: number;
     }
     /**
-        * AsciiArtPostProcess helps rendering everithing in Ascii Art.
-        *
-        * Simmply add it to your scene and let the nerd that lives in you have fun.
-        * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
-        */
+     * AsciiArtPostProcess helps rendering everithing in Ascii Art.
+     *
+     * Simmply add it to your scene and let the nerd that lives in you have fun.
+     * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
+     */
     export class AsciiArtPostProcess extends BABYLON.PostProcess {
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal: number;
-            /**
-                * Instantiates a new Ascii Art Post Process.
-                * @param name the name to give to the postprocess
-                * @camera the camera to apply the post process to.
-                * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
-                */
-            constructor(name: string, camera: BABYLON.Camera, options?: string | IAsciiArtPostProcessOptions);
+        /**
+         * The font texture used to render the char in the post process.
+         */
+        private _asciiArtFontTexture;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal: number;
+        /**
+         * Instantiates a new Ascii Art Post Process.
+         * @param name the name to give to the postprocess
+         * @camera the camera to apply the post process to.
+         * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
+         */
+        constructor(name: string, camera: BABYLON.Camera, options?: string | IAsciiArtPostProcessOptions);
     }
 }
 declare module BABYLON {
+    /** @hidden */
+    export var digitalrainPixelShader: {
+        name: string;
+        shader: string;
+    };
+}
+declare module BABYLON {
     /**
-        * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
-        *
-        * It basically takes care rendering the font front the given font size to a texture.
-        * This is used later on in the postprocess.
-        */
+     * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
+     *
+     * It basically takes care rendering the font front the given font size to a texture.
+     * This is used later on in the postprocess.
+     */
     export class DigitalRainFontTexture extends BABYLON.BaseTexture {
-            /**
-                * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-                */
-            readonly charSize: number;
-            /**
-                * Create a new instance of the Digital Rain FontTexture class
-                * @param name the name of the texture
-                * @param font the font to use, use the W3C CSS notation
-                * @param text the caracter set to use in the rendering.
-                * @param scene the scene that owns the texture
-                */
-            constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
-            /**
-                * Clones the current DigitalRainFontTexture.
-                * @return the clone of the texture.
-                */
-            clone(): DigitalRainFontTexture;
-            /**
-                * Parses a json object representing the texture and returns an instance of it.
-                * @param source the source JSON representation
-                * @param scene the scene to create the texture for
-                * @return the parsed texture
-                */
-            static Parse(source: any, scene: BABYLON.Scene): DigitalRainFontTexture;
+        private _font;
+        private _text;
+        private _charSize;
+        /**
+         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+         */
+        readonly charSize: number;
+        /**
+         * Create a new instance of the Digital Rain FontTexture class
+         * @param name the name of the texture
+         * @param font the font to use, use the W3C CSS notation
+         * @param text the caracter set to use in the rendering.
+         * @param scene the scene that owns the texture
+         */
+        constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
+        /**
+         * Gets the max char width of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char width
+         */
+        private getFontWidth;
+        /**
+         * Gets the max char height of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char height
+         */
+        private getFontHeight;
+        /**
+         * Clones the current DigitalRainFontTexture.
+         * @return the clone of the texture.
+         */
+        clone(): DigitalRainFontTexture;
+        /**
+         * Parses a json object representing the texture and returns an instance of it.
+         * @param source the source JSON representation
+         * @param scene the scene to create the texture for
+         * @return the parsed texture
+         */
+        static Parse(source: any, scene: BABYLON.Scene): DigitalRainFontTexture;
     }
     /**
-        * Option available in the Digital Rain Post Process.
-        */
+     * Option available in the Digital Rain Post Process.
+     */
     export interface IDigitalRainPostProcessOptions {
-            /**
-                * The font to use following the w3c font definition.
-                */
-            font?: string;
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile?: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal?: number;
+        /**
+         * The font to use following the w3c font definition.
+         */
+        font?: string;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile?: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal?: number;
     }
     /**
-        * DigitalRainPostProcess helps rendering everithing in digital rain.
-        *
-        * Simmply add it to your scene and let the nerd that lives in you have fun.
-        * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
-        */
+     * DigitalRainPostProcess helps rendering everithing in digital rain.
+     *
+     * Simmply add it to your scene and let the nerd that lives in you have fun.
+     * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
+     */
     export class DigitalRainPostProcess extends BABYLON.PostProcess {
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal: number;
-            /**
-                * Instantiates a new Digital Rain Post Process.
-                * @param name the name to give to the postprocess
-                * @camera the camera to apply the post process to.
-                * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
-                */
-            constructor(name: string, camera: BABYLON.Camera, options?: string | IDigitalRainPostProcessOptions);
+        /**
+         * The font texture used to render the char in the post process.
+         */
+        private _digitalRainFontTexture;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal: number;
+        /**
+         * Instantiates a new Digital Rain Post Process.
+         * @param name the name to give to the postprocess
+         * @camera the camera to apply the post process to.
+         * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
+         */
+        constructor(name: string, camera: BABYLON.Camera, options?: string | IDigitalRainPostProcessOptions);
     }
 }

dist/preview release/postProcessesLibrary/babylonjs.postProcess.module.d.ts

@@ -1,347 +1,458 @@
-/*BabylonJS Postprocess library*/
-// Dependencies for this module:
-//   ../../../../Tools/Gulp/babylonjs
-
-declare module 'babylonjs-postProcessLibrary' {
-    export * from "babylonjs-postProcessLibrary/src/asciiArt";
-    export * from "babylonjs-postProcessLibrary/src/digitalRain";
+declare module "babylonjs-post-process/asciiArt/asciiart.fragment" {
+    /** @hidden */
+    export var asciiartPixelShader: {
+        name: string;
+        shader: string;
+    };
 }
-
-declare module 'babylonjs-postProcessLibrary/src/asciiArt' {
-    export * from "babylonjs-postProcessLibrary/src/asciiArt/asciiArtPostProcess";
-}
-
-declare module 'babylonjs-postProcessLibrary/src/digitalRain' {
-    export * from "babylonjs-postProcessLibrary/src/digitalRain/digitalRainPostProcess";
-}
-
-declare module 'babylonjs-postProcessLibrary/src/asciiArt/asciiArtPostProcess' {
-    import { BaseTexture, Nullable, Scene, PostProcess, Camera } from "babylonjs";
-    import "./asciiart.fragment";
+declare module "babylonjs-post-process/asciiArt/asciiArtPostProcess" {
+    import { Nullable } from "babylonjs/types";
+    import { Camera } from "babylonjs/Cameras/camera";
+    import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+    import { PostProcess } from "babylonjs/PostProcesses/postProcess";
+    import { Scene } from "babylonjs/scene";
+    import "babylonjs-post-process/asciiArt/asciiart.fragment";
     /**
-        * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
-        *
-        * It basically takes care rendering the font front the given font size to a texture.
-        * This is used later on in the postprocess.
-        */
+     * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
+     *
+     * It basically takes care rendering the font front the given font size to a texture.
+     * This is used later on in the postprocess.
+     */
     export class AsciiArtFontTexture extends BaseTexture {
-            /**
-                * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-                */
-            readonly charSize: number;
-            /**
-                * Create a new instance of the Ascii Art FontTexture class
-                * @param name the name of the texture
-                * @param font the font to use, use the W3C CSS notation
-                * @param text the caracter set to use in the rendering.
-                * @param scene the scene that owns the texture
-                */
-            constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
-            /**
-                * Clones the current AsciiArtTexture.
-                * @return the clone of the texture.
-                */
-            clone(): AsciiArtFontTexture;
-            /**
-                * Parses a json object representing the texture and returns an instance of it.
-                * @param source the source JSON representation
-                * @param scene the scene to create the texture for
-                * @return the parsed texture
-                */
-            static Parse(source: any, scene: Scene): AsciiArtFontTexture;
+        private _font;
+        private _text;
+        private _charSize;
+        /**
+         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+         */
+        readonly charSize: number;
+        /**
+         * Create a new instance of the Ascii Art FontTexture class
+         * @param name the name of the texture
+         * @param font the font to use, use the W3C CSS notation
+         * @param text the caracter set to use in the rendering.
+         * @param scene the scene that owns the texture
+         */
+        constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
+        /**
+         * Gets the max char width of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char width
+         */
+        private getFontWidth;
+        /**
+         * Gets the max char height of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char height
+         */
+        private getFontHeight;
+        /**
+         * Clones the current AsciiArtTexture.
+         * @return the clone of the texture.
+         */
+        clone(): AsciiArtFontTexture;
+        /**
+         * Parses a json object representing the texture and returns an instance of it.
+         * @param source the source JSON representation
+         * @param scene the scene to create the texture for
+         * @return the parsed texture
+         */
+        static Parse(source: any, scene: Scene): AsciiArtFontTexture;
     }
     /**
-        * Option available in the Ascii Art Post Process.
-        */
+     * Option available in the Ascii Art Post Process.
+     */
     export interface IAsciiArtPostProcessOptions {
-            /**
-                * The font to use following the w3c font definition.
-                */
-            font?: string;
-            /**
-                * The character set to use in the postprocess.
-                */
-            characterSet?: string;
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile?: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal?: number;
+        /**
+         * The font to use following the w3c font definition.
+         */
+        font?: string;
+        /**
+         * The character set to use in the postprocess.
+         */
+        characterSet?: string;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile?: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal?: number;
     }
     /**
-        * AsciiArtPostProcess helps rendering everithing in Ascii Art.
-        *
-        * Simmply add it to your scene and let the nerd that lives in you have fun.
-        * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
-        */
+     * AsciiArtPostProcess helps rendering everithing in Ascii Art.
+     *
+     * Simmply add it to your scene and let the nerd that lives in you have fun.
+     * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
+     */
     export class AsciiArtPostProcess extends PostProcess {
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal: number;
-            /**
-                * Instantiates a new Ascii Art Post Process.
-                * @param name the name to give to the postprocess
-                * @camera the camera to apply the post process to.
-                * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
-                */
-            constructor(name: string, camera: Camera, options?: string | IAsciiArtPostProcessOptions);
+        /**
+         * The font texture used to render the char in the post process.
+         */
+        private _asciiArtFontTexture;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal: number;
+        /**
+         * Instantiates a new Ascii Art Post Process.
+         * @param name the name to give to the postprocess
+         * @camera the camera to apply the post process to.
+         * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
+         */
+        constructor(name: string, camera: Camera, options?: string | IAsciiArtPostProcessOptions);
     }
 }
-
-declare module 'babylonjs-postProcessLibrary/src/digitalRain/digitalRainPostProcess' {
-    import { BaseTexture, Nullable, Scene, PostProcess, Camera } from "babylonjs";
-    import "./digitalrain.fragment";
+declare module "babylonjs-post-process/asciiArt/index" {
+    export * from "babylonjs-post-process/asciiArt/asciiArtPostProcess";
+}
+declare module "babylonjs-post-process/digitalRain/digitalrain.fragment" {
+    /** @hidden */
+    export var digitalrainPixelShader: {
+        name: string;
+        shader: string;
+    };
+}
+declare module "babylonjs-post-process/digitalRain/digitalRainPostProcess" {
+    import { Nullable } from "babylonjs/types";
+    import { Camera } from "babylonjs/Cameras/camera";
+    import { BaseTexture } from "babylonjs/Materials/Textures/baseTexture";
+    import { PostProcess } from "babylonjs/PostProcesses/postProcess";
+    import { Scene } from "babylonjs/scene";
+    import "babylonjs-post-process/digitalRain/digitalrain.fragment";
     /**
-        * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
-        *
-        * It basically takes care rendering the font front the given font size to a texture.
-        * This is used later on in the postprocess.
-        */
+     * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
+     *
+     * It basically takes care rendering the font front the given font size to a texture.
+     * This is used later on in the postprocess.
+     */
     export class DigitalRainFontTexture extends BaseTexture {
-            /**
-                * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-                */
-            readonly charSize: number;
-            /**
-                * Create a new instance of the Digital Rain FontTexture class
-                * @param name the name of the texture
-                * @param font the font to use, use the W3C CSS notation
-                * @param text the caracter set to use in the rendering.
-                * @param scene the scene that owns the texture
-                */
-            constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
-            /**
-                * Clones the current DigitalRainFontTexture.
-                * @return the clone of the texture.
-                */
-            clone(): DigitalRainFontTexture;
-            /**
-                * Parses a json object representing the texture and returns an instance of it.
-                * @param source the source JSON representation
-                * @param scene the scene to create the texture for
-                * @return the parsed texture
-                */
-            static Parse(source: any, scene: Scene): DigitalRainFontTexture;
+        private _font;
+        private _text;
+        private _charSize;
+        /**
+         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+         */
+        readonly charSize: number;
+        /**
+         * Create a new instance of the Digital Rain FontTexture class
+         * @param name the name of the texture
+         * @param font the font to use, use the W3C CSS notation
+         * @param text the caracter set to use in the rendering.
+         * @param scene the scene that owns the texture
+         */
+        constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
+        /**
+         * Gets the max char width of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char width
+         */
+        private getFontWidth;
+        /**
+         * Gets the max char height of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char height
+         */
+        private getFontHeight;
+        /**
+         * Clones the current DigitalRainFontTexture.
+         * @return the clone of the texture.
+         */
+        clone(): DigitalRainFontTexture;
+        /**
+         * Parses a json object representing the texture and returns an instance of it.
+         * @param source the source JSON representation
+         * @param scene the scene to create the texture for
+         * @return the parsed texture
+         */
+        static Parse(source: any, scene: Scene): DigitalRainFontTexture;
     }
     /**
-        * Option available in the Digital Rain Post Process.
-        */
+     * Option available in the Digital Rain Post Process.
+     */
     export interface IDigitalRainPostProcessOptions {
-            /**
-                * The font to use following the w3c font definition.
-                */
-            font?: string;
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile?: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal?: number;
+        /**
+         * The font to use following the w3c font definition.
+         */
+        font?: string;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile?: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal?: number;
     }
     /**
-        * DigitalRainPostProcess helps rendering everithing in digital rain.
-        *
-        * Simmply add it to your scene and let the nerd that lives in you have fun.
-        * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
-        */
+     * DigitalRainPostProcess helps rendering everithing in digital rain.
+     *
+     * Simmply add it to your scene and let the nerd that lives in you have fun.
+     * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
+     */
     export class DigitalRainPostProcess extends PostProcess {
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal: number;
-            /**
-                * Instantiates a new Digital Rain Post Process.
-                * @param name the name to give to the postprocess
-                * @camera the camera to apply the post process to.
-                * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
-                */
-            constructor(name: string, camera: Camera, options?: string | IDigitalRainPostProcessOptions);
+        /**
+         * The font texture used to render the char in the post process.
+         */
+        private _digitalRainFontTexture;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal: number;
+        /**
+         * Instantiates a new Digital Rain Post Process.
+         * @param name the name to give to the postprocess
+         * @camera the camera to apply the post process to.
+         * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
+         */
+        constructor(name: string, camera: Camera, options?: string | IDigitalRainPostProcessOptions);
     }
 }
-
-
-/*BabylonJS Postprocess library*/
-// Dependencies for this module:
-//   ../../../../Tools/Gulp/babylonjs
+declare module "babylonjs-post-process/digitalRain/index" {
+    export * from "babylonjs-post-process/digitalRain/digitalRainPostProcess";
+}
+declare module "babylonjs-post-process/index" {
+    export * from "babylonjs-post-process/asciiArt/index";
+    export * from "babylonjs-post-process/digitalRain/index";
+}
+declare module "babylonjs-post-process/legacy/legacy-asciiArt" {
+    export * from "babylonjs-post-process/asciiArt/index";
+}
+declare module "babylonjs-post-process/legacy/legacy-digitalRain" {
+    export * from "babylonjs-post-process/digitalRain/index";
+}
+declare module "babylonjs-post-process/legacy/legacy" {
+    export * from "babylonjs-post-process/index";
+}
+declare module "babylonjs-post-process" {
+    export * from "babylonjs-post-process/legacy/legacy";
+}
+declare module BABYLON {
+    /** @hidden */
+    export var asciiartPixelShader: {
+        name: string;
+        shader: string;
+    };
+}
 declare module BABYLON {
     /**
-        * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
-        *
-        * It basically takes care rendering the font front the given font size to a texture.
-        * This is used later on in the postprocess.
-        */
+     * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
+     *
+     * It basically takes care rendering the font front the given font size to a texture.
+     * This is used later on in the postprocess.
+     */
     export class AsciiArtFontTexture extends BABYLON.BaseTexture {
-            /**
-                * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-                */
-            readonly charSize: number;
-            /**
-                * Create a new instance of the Ascii Art FontTexture class
-                * @param name the name of the texture
-                * @param font the font to use, use the W3C CSS notation
-                * @param text the caracter set to use in the rendering.
-                * @param scene the scene that owns the texture
-                */
-            constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
-            /**
-                * Clones the current AsciiArtTexture.
-                * @return the clone of the texture.
-                */
-            clone(): AsciiArtFontTexture;
-            /**
-                * Parses a json object representing the texture and returns an instance of it.
-                * @param source the source JSON representation
-                * @param scene the scene to create the texture for
-                * @return the parsed texture
-                */
-            static Parse(source: any, scene: BABYLON.Scene): AsciiArtFontTexture;
+        private _font;
+        private _text;
+        private _charSize;
+        /**
+         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+         */
+        readonly charSize: number;
+        /**
+         * Create a new instance of the Ascii Art FontTexture class
+         * @param name the name of the texture
+         * @param font the font to use, use the W3C CSS notation
+         * @param text the caracter set to use in the rendering.
+         * @param scene the scene that owns the texture
+         */
+        constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
+        /**
+         * Gets the max char width of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char width
+         */
+        private getFontWidth;
+        /**
+         * Gets the max char height of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char height
+         */
+        private getFontHeight;
+        /**
+         * Clones the current AsciiArtTexture.
+         * @return the clone of the texture.
+         */
+        clone(): AsciiArtFontTexture;
+        /**
+         * Parses a json object representing the texture and returns an instance of it.
+         * @param source the source JSON representation
+         * @param scene the scene to create the texture for
+         * @return the parsed texture
+         */
+        static Parse(source: any, scene: BABYLON.Scene): AsciiArtFontTexture;
     }
     /**
-        * Option available in the Ascii Art Post Process.
-        */
+     * Option available in the Ascii Art Post Process.
+     */
     export interface IAsciiArtPostProcessOptions {
-            /**
-                * The font to use following the w3c font definition.
-                */
-            font?: string;
-            /**
-                * The character set to use in the postprocess.
-                */
-            characterSet?: string;
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile?: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal?: number;
+        /**
+         * The font to use following the w3c font definition.
+         */
+        font?: string;
+        /**
+         * The character set to use in the postprocess.
+         */
+        characterSet?: string;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile?: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal?: number;
     }
     /**
-        * AsciiArtPostProcess helps rendering everithing in Ascii Art.
-        *
-        * Simmply add it to your scene and let the nerd that lives in you have fun.
-        * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
-        */
+     * AsciiArtPostProcess helps rendering everithing in Ascii Art.
+     *
+     * Simmply add it to your scene and let the nerd that lives in you have fun.
+     * Example usage: var pp = new AsciiArtPostProcess("myAscii", "20px Monospace", camera);
+     */
     export class AsciiArtPostProcess extends BABYLON.PostProcess {
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the ascii art.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal: number;
-            /**
-                * Instantiates a new Ascii Art Post Process.
-                * @param name the name to give to the postprocess
-                * @camera the camera to apply the post process to.
-                * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
-                */
-            constructor(name: string, camera: BABYLON.Camera, options?: string | IAsciiArtPostProcessOptions);
+        /**
+         * The font texture used to render the char in the post process.
+         */
+        private _asciiArtFontTexture;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the ascii art.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal: number;
+        /**
+         * Instantiates a new Ascii Art Post Process.
+         * @param name the name to give to the postprocess
+         * @camera the camera to apply the post process to.
+         * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
+         */
+        constructor(name: string, camera: BABYLON.Camera, options?: string | IAsciiArtPostProcessOptions);
     }
 }
 declare module BABYLON {
+    /** @hidden */
+    export var digitalrainPixelShader: {
+        name: string;
+        shader: string;
+    };
+}
+declare module BABYLON {
     /**
-        * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
-        *
-        * It basically takes care rendering the font front the given font size to a texture.
-        * This is used later on in the postprocess.
-        */
+     * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
+     *
+     * It basically takes care rendering the font front the given font size to a texture.
+     * This is used later on in the postprocess.
+     */
     export class DigitalRainFontTexture extends BABYLON.BaseTexture {
-            /**
-                * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-                */
-            readonly charSize: number;
-            /**
-                * Create a new instance of the Digital Rain FontTexture class
-                * @param name the name of the texture
-                * @param font the font to use, use the W3C CSS notation
-                * @param text the caracter set to use in the rendering.
-                * @param scene the scene that owns the texture
-                */
-            constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
-            /**
-                * Clones the current DigitalRainFontTexture.
-                * @return the clone of the texture.
-                */
-            clone(): DigitalRainFontTexture;
-            /**
-                * Parses a json object representing the texture and returns an instance of it.
-                * @param source the source JSON representation
-                * @param scene the scene to create the texture for
-                * @return the parsed texture
-                */
-            static Parse(source: any, scene: BABYLON.Scene): DigitalRainFontTexture;
+        private _font;
+        private _text;
+        private _charSize;
+        /**
+         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
+         */
+        readonly charSize: number;
+        /**
+         * Create a new instance of the Digital Rain FontTexture class
+         * @param name the name of the texture
+         * @param font the font to use, use the W3C CSS notation
+         * @param text the caracter set to use in the rendering.
+         * @param scene the scene that owns the texture
+         */
+        constructor(name: string, font: string, text: string, scene?: BABYLON.Nullable<BABYLON.Scene>);
+        /**
+         * Gets the max char width of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char width
+         */
+        private getFontWidth;
+        /**
+         * Gets the max char height of a font.
+         * @param font the font to use, use the W3C CSS notation
+         * @return the max char height
+         */
+        private getFontHeight;
+        /**
+         * Clones the current DigitalRainFontTexture.
+         * @return the clone of the texture.
+         */
+        clone(): DigitalRainFontTexture;
+        /**
+         * Parses a json object representing the texture and returns an instance of it.
+         * @param source the source JSON representation
+         * @param scene the scene to create the texture for
+         * @return the parsed texture
+         */
+        static Parse(source: any, scene: BABYLON.Scene): DigitalRainFontTexture;
     }
     /**
-        * Option available in the Digital Rain Post Process.
-        */
+     * Option available in the Digital Rain Post Process.
+     */
     export interface IDigitalRainPostProcessOptions {
-            /**
-                * The font to use following the w3c font definition.
-                */
-            font?: string;
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile?: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal?: number;
+        /**
+         * The font to use following the w3c font definition.
+         */
+        font?: string;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile?: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal?: number;
     }
     /**
-        * DigitalRainPostProcess helps rendering everithing in digital rain.
-        *
-        * Simmply add it to your scene and let the nerd that lives in you have fun.
-        * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
-        */
+     * DigitalRainPostProcess helps rendering everithing in digital rain.
+     *
+     * Simmply add it to your scene and let the nerd that lives in you have fun.
+     * Example usage: var pp = new DigitalRainPostProcess("digitalRain", "20px Monospace", camera);
+     */
     export class DigitalRainPostProcess extends BABYLON.PostProcess {
-            /**
-                * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToTile: number;
-            /**
-                * This defines the amount you want to mix the normal rendering pass in the digital rain.
-                * This number is defined between 0 and 1;
-                */
-            mixToNormal: number;
-            /**
-                * Instantiates a new Digital Rain Post Process.
-                * @param name the name to give to the postprocess
-                * @camera the camera to apply the post process to.
-                * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
-                */
-            constructor(name: string, camera: BABYLON.Camera, options?: string | IDigitalRainPostProcessOptions);
+        /**
+         * The font texture used to render the char in the post process.
+         */
+        private _digitalRainFontTexture;
+        /**
+         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToTile: number;
+        /**
+         * This defines the amount you want to mix the normal rendering pass in the digital rain.
+         * This number is defined between 0 and 1;
+         */
+        mixToNormal: number;
+        /**
+         * Instantiates a new Digital Rain Post Process.
+         * @param name the name to give to the postprocess
+         * @camera the camera to apply the post process to.
+         * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
+         */
+        constructor(name: string, camera: BABYLON.Camera, options?: string | IDigitalRainPostProcessOptions);
     }
 }