Move Lib to AwesomeTypeScript

Tools/Gulp/config.json

@@ -1476,8 +1476,9 @@
             {
                 "files": [],
                 "noBundleInName": true,
-                "output": "babylon.materials.min.js",
+                "output": "babylonjs.materials.min.js",
                 "webpack": "../../materialsLibrary/webpack.config.js",
+                "entry": "./src/legacy.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true,
@@ -1488,6 +1489,7 @@
                 "noBundleInName": true,
                 "output": "babylon.cellMaterial.min.js",
                 "webpack": "../../materialsLibrary/legacy/webpack.cell.config.js",
+                "entry": "./legacy/legacy-cell.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
@@ -1496,6 +1498,7 @@
                 "noBundleInName": true,
                 "output": "babylon.customMaterial.min.js",
                 "webpack": "../../materialsLibrary/legacy/webpack.custom.config.js",
+                "entry": "./legacy/legacy-custom.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
@@ -1504,6 +1507,7 @@
                 "noBundleInName": true,
                 "output": "babylon.fireMaterial.min.js",
                 "webpack": "../../materialsLibrary/legacy/webpack.fire.config.js",
+                "entry": "./legacy/legacy-fire.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
@@ -1512,6 +1516,7 @@
                 "noBundleInName": true,
                 "output": "babylon.gradientMaterial.min.js",
                 "webpack": "../../materialsLibrary/legacy/webpack.gradient.config.js",
+                "entry": "./legacy/legacy-gradient.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
@@ -1520,6 +1525,7 @@
                 "noBundleInName": true,
                 "output": "babylon.lavaMaterial.min.js",
                 "webpack": "../../materialsLibrary/legacy/webpack.lava.config.js",
+                "entry": "./legacy/legacy-lava.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
@@ -1528,6 +1534,7 @@
                 "noBundleInName": true,
                 "output": "babylon.mixMaterial.min.js",
                 "webpack": "../../materialsLibrary/legacy/webpack.mix.config.js",
+                "entry": "./legacy/legacy-mix.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
@@ -1536,6 +1543,7 @@
                 "noBundleInName": true,
                 "output": "babylon.normalMaterial.min.js",
                 "webpack": "../../materialsLibrary/legacy/webpack.normal.config.js",
+                "entry": "./legacy/legacy-normal.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
@@ -1544,23 +1552,25 @@
                 "noBundleInName": true,
                 "output": "babylon.shadowOnlyMaterial.min.js",
                 "webpack": "../../materialsLibrary/legacy/webpack.shadowOnly.config.js",
+                "entry": "./legacy/legacy-shadowOnly.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
             }
         ],
         "build": {
+            "webpack": "../../materialsLibrary/webpack.config.js",
             "srcOutputDirectory": "../../materialsLibrary/src/",
             "distOutputDirectory": "/materialsLibrary/",
             "dtsBundle": {
                 "name": "babylonjs-materials",
-                "main": "../../dist/preview release/materialsLibrary/build/src/index.d.ts",
-                "out": "../babylon.materials.module.d.ts",
+                "main": "../../materialsLibrary/build/src/index.d.ts",
+                "out": "../babylonjs.materials.module.d.ts",
                 "baseDir": "../../dist/preview release/materialsLibrary/build/",
                 "headerText": "BabylonJS Materials"
             },
             "processDeclaration": {
-                "filename": "babylon.materials.module.d.ts",
+                "filename": "babylonjs.materials.module.d.ts",
                 "packageName": "babylonjs-materials",
                 "moduleName": "BABYLON",
                 "importsToRemove": [],
@@ -1577,8 +1587,9 @@
             {
                 "files": [],
                 "noBundleInName": true,
-                "output": "babylon.postProcesses.min.js",
+                "output": "babylonjs.postProcess.min.js",
                 "webpack": "../../postProcessLibrary/webpack.config.js",
+                "entry": "./src/legacy.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true,
@@ -1590,6 +1601,7 @@
                 "noBundleInName": true,
                 "output": "babylon.asciiArtPostProcess.min.js",
                 "webpack": "../../postProcessLibrary/legacy/webpack.asciiArt.config.js",
+                "entry": "./legacy/legacy-asciiArt.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
@@ -1599,23 +1611,25 @@
                 "noBundleInName": true,
                 "output": "babylon.digitalRainPostProcess.min.js",
                 "webpack": "../../postProcessLibrary/legacy/webpack.digitalRain.config.js",
+                "entry": "./legacy/legacy-digitalRain.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true
             }
         ],
         "build": {
+            "webpack": "../../postProcessLibrary/webpack.config.js",
             "srcOutputDirectory": "../../postProcessLibrary/src/",
             "distOutputDirectory": "/postProcessesLibrary/",
             "dtsBundle": {
                 "name": "babylonjs-postProcessLibrary",
-                "main": "../../dist/preview release/postProcessesLibrary/build/src/index.d.ts",
-                "out": "../babylon.postProcesses.module.d.ts",
+                "main": "../../postProcessLibrary/build/src/index.d.ts",
+                "out": "../babylonjs.postProcess.module.d.ts",
                 "baseDir": "../../dist/preview release/postProcessesLibrary/build/",
                 "headerText": "BabylonJS Postprocess library"
             },
             "processDeclaration": {
-                "filename": "babylon.postProcesses.module.d.ts",
+                "filename": "babylonjs.postProcess.module.d.ts",
                 "packageName": "babylonjs-postProcessLibrary",
                 "moduleName": "BABYLON",
                 "importsToRemove": [],
@@ -1632,26 +1646,129 @@
             {
                 "files": [],
                 "noBundleInName": true,
-                "output": "babylon.proceduralTextures.min.js",
+                "output": "babylonjs.proceduralTextures.min.js",
                 "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./src/legacy.ts",
                 "bundle": "true",
                 "babylonIncluded": false,
                 "useOutputForDebugging": true,
+                "preventLoadLibrary": true,
                 "isMain": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.brickProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-brick.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.cloudProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-cloud.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.fireProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-fire.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.grassProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-grass.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.marbleProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-marble.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.normalMapProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-normalMap.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.perlinNoiseProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-perlinNoise.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.roadProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-road.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.starfieldProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-starfield.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
+            },
+            {
+                "files": [],
+                "noBundleInName": true,
+                "output": "babylon.woodProceduralTexture.min.js",
+                "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
+                "entry": "./legacy/legacy-wood.ts",
+                "bundle": "true",
+                "babylonIncluded": false,
+                "useOutputForDebugging": true
             }
         ],
         "build": {
+            "webpack": "../../proceduralTexturesLibrary/webpack.config.js",
             "srcOutputDirectory": "../../proceduralTexturesLibrary/src/",
             "distOutputDirectory": "/proceduralTexturesLibrary/",
             "dtsBundle": {
                 "name": "babylonjs-procedural-textures",
-                "main": "../../dist/preview release/proceduralTexturesLibrary/build/index.d.ts",
-                "out": "../babylon.proceduralTextures.module.d.ts",
+                "main": "../../proceduralTexturesLibrary/build/src/index.d.ts",
+                "out": "../babylonjs.proceduralTextures.module.d.ts",
                 "baseDir": "../../dist/preview release/proceduralTexturesLibrary/build/",
                 "headerText": "BabylonJS Procedural Textures"
             },
             "processDeclaration": {
-                "filename": "babylon.proceduralTextures.module.d.ts",
+                "filename": "babylonjs.proceduralTextures.module.d.ts",
                 "packageName": "babylonjs-procedural-textures",
                 "moduleName": "BABYLON.PROCEDURALTEXTURES",
                 "importsToRemove": [],

Tools/Gulp/gulpfile.js

@@ -671,7 +671,18 @@ var buildExternalLibrary = function(library, settings, watch) {
                 });
             } else {
                 console.log(library.output)
-                var wpConfig = require(library.webpack);
+
+                var wpConfig;
+                if (library.entry) {
+                    wpConfig = require(settings.build.webpack);
+                    wpConfig.entry = {
+                        'main': path.resolve(wpConfig.context, library.entry),
+                    };
+                    wpConfig.output.filename = library.output;
+                }
+                else {
+                    wpConfig = require(library.webpack);
+                }
 
                 let wpBuild = webpackStream(wpConfig, webpack);
 
@@ -730,14 +741,38 @@ gulp.task("mainBuild", gulp.series("buildWorker", "build"));
 gulp.task("typescript", gulp.series("typescript-compile", "mainBuild"));
 
 /**
+ * Dynamic module creation In Serie for WebPack leaks.
+ */
+function buildExternalLibrariesInSeries(settings) {
+    var tasks = settings.libraries.map(function(library) {
+        var build = function(cb) {
+            return buildExternalLibrary(library, settings, false);
+        }
+        return build;
+    });
+
+    return gulp.series.apply(this, tasks);
+}
+
+/**
  * Dynamic module creation.
  */
 config.modules.map(function(module) {
-    gulp.task(module, function() {
-        return buildExternalLibraries(config[module]);
-    });
+    // New Way
+    if (!config[module].buildAsModule) {
+        gulp.task(module, buildExternalLibrariesInSeries(config[module]));
+    }
+    // Soon To Be Gone
+    else {
+        gulp.task(module, function() {
+            return buildExternalLibraries(config[module]);
+        });
+    }
 });
 
+/**
+ * Build all libs.
+ */
 gulp.task("typescript-libraries", gulp.series(config.modules));
 
 /**

Tools/Gulp/package.json

@@ -10,6 +10,7 @@
     "license": "(Apache-2.0)",
     "devDependencies": {
         "@types/node": "^8.10.22",
+        "awesome-typescript-loader": "^5.2.1",
         "chai": "^4.1.2",
         "color-support": "^1.1.3",
         "del": "3.0.0",
@@ -42,11 +43,11 @@
         "phantomjs-prebuilt": "^2.1.16",
         "sinon": "^6.1.4",
         "through2": "~2.0.3",
-        "ts-loader": "^4.4.2",
+        "ts-loader": "^5.2.1",
         "tslint": "^5.11.0",
         "typedoc": "^0.12.0",
         "typescript": "~3.0.1",
-        "webpack": "^4.16.3",
+        "webpack": "^4.20.2",
         "webpack-stream": "5.0.0"
     },
     "scripts": {

dist/preview release/gui/babylon.gui.js

@@ -103,26 +103,26 @@ return /******/ (function(modules) { // webpackBootstrap
 /*! 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 || Function("return this")() || (1, eval)("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;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
 
 /***/ }),

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

@@ -91,46 +91,76 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy-cell.ts");
+/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-cell.ts");
 /******/ })
 /************************************************************************/
 /******/ ({
 
-/***/ "../../Tools/Gulp/node_modules/webpack/buildin/global.js":
-/*!***********************************!*\
-  !*** (webpack)/buildin/global.js ***!
-  \***********************************/
+/***/ "../Tools/Gulp/node_modules/webpack/buildin/global.js":
+/*!************************************************************!*\
+  !*** ../Tools/Gulp/node_modules/webpack/buildin/global.js ***!
+  \************************************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
-var g;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
-// This works in non-strict mode
-g = (function() {
-	return this;
-})();
 
-try {
-	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("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) { ...}
+/***/ "./legacy/legacy-cell.ts":
+/*!*******************************!*\
+  !*** ./legacy/legacy-cell.ts ***!
+  \*******************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
 
-module.exports = g;
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var MatLib = __webpack_require__(/*! ../src/cell/index */ "./src/cell/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];
+    }
+}
+__export(__webpack_require__(/*! ../src/cell/index */ "./src/cell/index.ts"));
 
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "../src/cell/cell.fragment.fx":
-/*!************************************!*\
-  !*** ../src/cell/cell.fragment.fx ***!
-  \************************************/
+/***/ "./src/cell/cell.fragment.fx":
+/*!***********************************!*\
+  !*** ./src/cell/cell.fragment.fx ***!
+  \***********************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -138,10 +168,10 @@ module.exports = "precision highp float;\n\nuniform vec3 vEyePosition;\nuniform
 
 /***/ }),
 
-/***/ "../src/cell/cell.vertex.fx":
-/*!**********************************!*\
-  !*** ../src/cell/cell.vertex.fx ***!
-  \**********************************/
+/***/ "./src/cell/cell.vertex.fx":
+/*!*********************************!*\
+  !*** ./src/cell/cell.vertex.fx ***!
+  \*********************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -149,10 +179,10 @@ module.exports = "precision highp float;\n\nattribute vec3 position;\n#ifdef NOR
 
 /***/ }),
 
-/***/ "../src/cell/cellMaterial.ts":
-/*!***********************************!*\
-  !*** ../src/cell/cellMaterial.ts ***!
-  \***********************************/
+/***/ "./src/cell/cellMaterial.ts":
+/*!**********************************!*\
+  !*** ./src/cell/cellMaterial.ts ***!
+  \**********************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -179,8 +209,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
-babylonjs_1.Effect.ShadersStore["cellPixelShader"] = __webpack_require__(/*! ./cell.fragment.fx */ "../src/cell/cell.fragment.fx");
-babylonjs_1.Effect.ShadersStore["cellVertexShader"] = __webpack_require__(/*! ./cell.vertex.fx */ "../src/cell/cell.vertex.fx");
+babylonjs_1.Effect.ShadersStore["cellPixelShader"] = __webpack_require__(/*! ./cell.fragment.fx */ "./src/cell/cell.fragment.fx");
+babylonjs_1.Effect.ShadersStore["cellVertexShader"] = __webpack_require__(/*! ./cell.vertex.fx */ "./src/cell/cell.vertex.fx");
 var CellMaterialDefines = /** @class */ (function (_super) {
     __extends(CellMaterialDefines, _super);
     function CellMaterialDefines() {
@@ -377,7 +407,6 @@ var CellMaterial = /** @class */ (function (_super) {
         if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== babylonjs_1.Scene.FOGMODE_NONE) {
             this._activeEffect.setMatrix("view", scene.getViewMatrix());
         }
-        console.log("TOTO");
         // Fog
         babylonjs_1.MaterialHelper.BindFogParameters(scene, mesh, this._activeEffect);
         this._afterBind(mesh, this._activeEffect);
@@ -458,10 +487,10 @@ exports.CellMaterial = CellMaterial;
 
 /***/ }),
 
-/***/ "../src/cell/index.ts":
-/*!****************************!*\
-  !*** ../src/cell/index.ts ***!
-  \****************************/
+/***/ "./src/cell/index.ts":
+/*!***************************!*\
+  !*** ./src/cell/index.ts ***!
+  \***************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -471,38 +500,8 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./cellMaterial */ "../src/cell/cellMaterial.ts"));
-
-
-/***/ }),
-
-/***/ "./legacy-cell.ts":
-/*!************************!*\
-  !*** ./legacy-cell.ts ***!
-  \************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-var MatLib = __webpack_require__(/*! ../src/cell/index */ "../src/cell/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];
-    }
-}
-__export(__webpack_require__(/*! ../src/cell/index */ "../src/cell/index.ts"));
+__export(__webpack_require__(/*! ./cellMaterial */ "./src/cell/cellMaterial.ts"));
 
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 

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

@@ -91,46 +91,76 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy-custom.ts");
+/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-custom.ts");
 /******/ })
 /************************************************************************/
 /******/ ({
 
-/***/ "../../Tools/Gulp/node_modules/webpack/buildin/global.js":
-/*!***********************************!*\
-  !*** (webpack)/buildin/global.js ***!
-  \***********************************/
+/***/ "../Tools/Gulp/node_modules/webpack/buildin/global.js":
+/*!************************************************************!*\
+  !*** ../Tools/Gulp/node_modules/webpack/buildin/global.js ***!
+  \************************************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
-var g;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
-// This works in non-strict mode
-g = (function() {
-	return this;
-})();
 
-try {
-	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("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) { ...}
+/***/ "./legacy/legacy-custom.ts":
+/*!*********************************!*\
+  !*** ./legacy/legacy-custom.ts ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
 
-module.exports = g;
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+function __export(m) {
+    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];
+    }
+}
+__export(__webpack_require__(/*! ../src/custom/index */ "./src/custom/index.ts"));
 
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "../src/custom/customMaterial.ts":
-/*!***************************************!*\
-  !*** ../src/custom/customMaterial.ts ***!
-  \***************************************/
+/***/ "./src/custom/customMaterial.ts":
+/*!**************************************!*\
+  !*** ./src/custom/customMaterial.ts ***!
+  \**************************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -328,10 +358,10 @@ exports.CustomMaterial = CustomMaterial;
 
 /***/ }),
 
-/***/ "../src/custom/index.ts":
-/*!******************************!*\
-  !*** ../src/custom/index.ts ***!
-  \******************************/
+/***/ "./src/custom/index.ts":
+/*!*****************************!*\
+  !*** ./src/custom/index.ts ***!
+  \*****************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -341,38 +371,8 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./customMaterial */ "../src/custom/customMaterial.ts"));
-
-
-/***/ }),
-
-/***/ "./legacy-custom.ts":
-/*!**************************!*\
-  !*** ./legacy-custom.ts ***!
-  \**************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-function __export(m) {
-    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];
-    }
-}
-__export(__webpack_require__(/*! ../src/custom/index */ "../src/custom/index.ts"));
+__export(__webpack_require__(/*! ./customMaterial */ "./src/custom/customMaterial.ts"));
 
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 

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

@@ -0,0 +1,392 @@
+(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-materials", ["babylonjs"], factory);
+	else if(typeof exports === 'object')
+		exports["babylonjs-materials"] = factory(require("babylonjs"));
+	else
+		root["MATLIB"] = factory(root["BABYLON"]);
+})(window, function(__WEBPACK_EXTERNAL_MODULE_babylonjs__) {
+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-custom.ts");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "../Tools/Gulp/node_modules/webpack/buildin/global.js":
+/*!************************************************************!*\
+  !*** ../Tools/Gulp/node_modules/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 || Function("return this")() || (1, eval)("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;
+
+
+/***/ }),
+
+/***/ "./legacy/legacy-custom.ts":
+/*!*********************************!*\
+  !*** ./legacy/legacy-custom.ts ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+function __export(m) {
+    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];
+    }
+}
+__export(__webpack_require__(/*! ../src/custom/index */ "./src/custom/index.ts"));
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../Tools/Gulp/node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "./src/custom/customMaterial.ts":
+/*!**************************************!*\
+  !*** ./src/custom/customMaterial.ts ***!
+  \**************************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+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);
+    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"];
+        return _this;
+    }
+    CustomMaterial.prototype.AttachAfterBind = function (mesh, effect) {
+        for (var el in this._newUniformInstances) {
+            var ea = el.toString().split('-');
+            if (ea[0] == 'vec2') {
+                effect.setVector2(ea[1], this._newUniformInstances[el]);
+            }
+            else if (ea[0] == 'vec3') {
+                effect.setVector3(ea[1], this._newUniformInstances[el]);
+            }
+            else if (ea[0] == 'vec4') {
+                effect.setVector4(ea[1], this._newUniformInstances[el]);
+            }
+            else if (ea[0] == 'mat4') {
+                effect.setMatrix(ea[1], this._newUniformInstances[el]);
+            }
+            else if (ea[0] == 'float') {
+                effect.setFloat(ea[1], this._newUniformInstances[el]);
+            }
+        }
+        for (var el in this._newSamplerInstances) {
+            var ea = el.toString().split('-');
+            if (ea[0] == 'sampler2D' && this._newSamplerInstances[el].isReady && this._newSamplerInstances[el].isReady()) {
+                effect.setTexture(ea[1], this._newSamplerInstances[el]);
+            }
+        }
+    };
+    CustomMaterial.prototype.ReviewUniform = function (name, arr) {
+        if (name == "uniform") {
+            for (var ind in this._newUniforms) {
+                if (this._customUniform[ind].indexOf('sampler') == -1) {
+                    arr.push(this._newUniforms[ind]);
+                }
+            }
+        }
+        if (name == "sampler") {
+            for (var ind in this._newUniforms) {
+                if (this._customUniform[ind].indexOf('sampler') != -1) {
+                    arr.push(this._newUniforms[ind]);
+                }
+            }
+        }
+        return arr;
+    };
+    CustomMaterial.prototype.Builder = function (shaderName, uniforms, uniformBuffers, samplers, defines) {
+        var _this = this;
+        if (this._isCreatedShader) {
+            return this._createdShaderName;
+        }
+        this._isCreatedShader = false;
+        CustomMaterial.ShaderIndexer++;
+        var name = "custom_" + CustomMaterial.ShaderIndexer;
+        this.ReviewUniform("uniform", uniforms);
+        this.ReviewUniform("sampler", samplers);
+        var fn_afterBind = this._afterBind.bind(this);
+        this._afterBind = function (m, e) {
+            if (!e) {
+                return;
+            }
+            _this.AttachAfterBind(m, e);
+            try {
+                fn_afterBind(m, e);
+            }
+            catch (e) { }
+        };
+        BABYLON.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
+            .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 : ""))
+            .replace('#define CUSTOM_FRAGMENT_UPDATE_DIFFUSE', (this.CustomParts.Fragment_Custom_Diffuse ? this.CustomParts.Fragment_Custom_Diffuse : ""))
+            .replace('#define CUSTOM_FRAGMENT_UPDATE_ALPHA', (this.CustomParts.Fragment_Custom_Alpha ? this.CustomParts.Fragment_Custom_Alpha : ""))
+            .replace('#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR', (this.CustomParts.Fragment_Before_FragColor ? this.CustomParts.Fragment_Before_FragColor : ""));
+        // #define CUSTOM_FRAGMENT_BEFORE_LIGHTS
+        // #define CUSTOM_FRAGMENT_BEFORE_FOG
+        this._isCreatedShader = true;
+        this._createdShaderName = name;
+        return name;
+    };
+    CustomMaterial.prototype.AddUniform = function (name, kind, param) {
+        if (!this._customUniform) {
+            this._customUniform = new Array();
+            this._newUniforms = new Array();
+            this._newSamplerInstances = new Array();
+            this._newUniformInstances = new Array();
+        }
+        if (param) {
+            if (kind.indexOf("sampler") == -1) {
+                this._newUniformInstances[kind + "-" + name] = param;
+            }
+            else {
+                this._newUniformInstances[kind + "-" + name] = param;
+            }
+        }
+        this._customUniform.push("uniform " + kind + " " + name + ";");
+        this._newUniforms.push(name);
+        return this;
+    };
+    CustomMaterial.prototype.Fragment_Begin = function (shaderPart) {
+        this.CustomParts.Fragment_Begin = shaderPart;
+        return this;
+    };
+    CustomMaterial.prototype.Fragment_Definitions = function (shaderPart) {
+        this.CustomParts.Fragment_Definitions = shaderPart;
+        return this;
+    };
+    CustomMaterial.prototype.Fragment_MainBegin = function (shaderPart) {
+        this.CustomParts.Fragment_MainBegin = shaderPart;
+        return this;
+    };
+    CustomMaterial.prototype.Fragment_Custom_Diffuse = function (shaderPart) {
+        this.CustomParts.Fragment_Custom_Diffuse = shaderPart.replace("result", "diffuseColor");
+        return this;
+    };
+    CustomMaterial.prototype.Fragment_Custom_Alpha = function (shaderPart) {
+        this.CustomParts.Fragment_Custom_Alpha = shaderPart.replace("result", "alpha");
+        return this;
+    };
+    CustomMaterial.prototype.Fragment_Before_FragColor = function (shaderPart) {
+        this.CustomParts.Fragment_Before_FragColor = shaderPart.replace("result", "color");
+        return this;
+    };
+    CustomMaterial.prototype.Vertex_Begin = function (shaderPart) {
+        this.CustomParts.Vertex_Begin = shaderPart;
+        return this;
+    };
+    CustomMaterial.prototype.Vertex_Definitions = function (shaderPart) {
+        this.CustomParts.Vertex_Definitions = shaderPart;
+        return this;
+    };
+    CustomMaterial.prototype.Vertex_MainBegin = function (shaderPart) {
+        this.CustomParts.Vertex_MainBegin = shaderPart;
+        return this;
+    };
+    CustomMaterial.prototype.Vertex_Before_PositionUpdated = function (shaderPart) {
+        this.CustomParts.Vertex_Before_PositionUpdated = shaderPart.replace("result", "positionUpdated");
+        return this;
+    };
+    CustomMaterial.prototype.Vertex_Before_NormalUpdated = function (shaderPart) {
+        this.CustomParts.Vertex_Before_NormalUpdated = shaderPart.replace("result", "normalUpdated");
+        return this;
+    };
+    CustomMaterial.ShaderIndexer = 1;
+    return CustomMaterial;
+}(babylonjs_1.StandardMaterial));
+exports.CustomMaterial = CustomMaterial;
+
+
+/***/ }),
+
+/***/ "./src/custom/index.ts":
+/*!*****************************!*\
+  !*** ./src/custom/index.ts ***!
+  \*****************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+__export(__webpack_require__(/*! ./customMaterial */ "./src/custom/customMaterial.ts"));
+
+
+/***/ }),
+
+/***/ "babylonjs":
+/*!****************************************************************************************************!*\
+  !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!
+  \****************************************************************************************************/
+/*! no static exports found */
+/***/ (function(module, exports) {
+
+module.exports = __WEBPACK_EXTERNAL_MODULE_babylonjs__;
+
+/***/ })
+
+/******/ });
+});
+//# sourceMappingURL=babylon.customMaterial.min.js.map

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

@@ -91,46 +91,76 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy-fire.ts");
+/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-fire.ts");
 /******/ })
 /************************************************************************/
 /******/ ({
 
-/***/ "../../Tools/Gulp/node_modules/webpack/buildin/global.js":
-/*!***********************************!*\
-  !*** (webpack)/buildin/global.js ***!
-  \***********************************/
+/***/ "../Tools/Gulp/node_modules/webpack/buildin/global.js":
+/*!************************************************************!*\
+  !*** ../Tools/Gulp/node_modules/webpack/buildin/global.js ***!
+  \************************************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
-var g;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
-// This works in non-strict mode
-g = (function() {
-	return this;
-})();
 
-try {
-	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("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) { ...}
+/***/ "./legacy/legacy-fire.ts":
+/*!*******************************!*\
+  !*** ./legacy/legacy-fire.ts ***!
+  \*******************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
 
-module.exports = g;
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var MatLib = __webpack_require__(/*! ../src/fire/index */ "./src/fire/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];
+    }
+}
+__export(__webpack_require__(/*! ../src/fire/index */ "./src/fire/index.ts"));
 
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "../src/fire/fire.fragment.fx":
-/*!************************************!*\
-  !*** ../src/fire/fire.fragment.fx ***!
-  \************************************/
+/***/ "./src/fire/fire.fragment.fx":
+/*!***********************************!*\
+  !*** ./src/fire/fire.fragment.fx ***!
+  \***********************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -138,10 +168,10 @@ module.exports = "precision highp float;\n\nuniform vec3 vEyePosition;\n\nvaryin
 
 /***/ }),
 
-/***/ "../src/fire/fire.vertex.fx":
-/*!**********************************!*\
-  !*** ../src/fire/fire.vertex.fx ***!
-  \**********************************/
+/***/ "./src/fire/fire.vertex.fx":
+/*!*********************************!*\
+  !*** ./src/fire/fire.vertex.fx ***!
+  \*********************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -149,10 +179,10 @@ module.exports = "precision highp float;\n\nattribute vec3 position;\n#ifdef UV1
 
 /***/ }),
 
-/***/ "../src/fire/fireMaterial.ts":
-/*!***********************************!*\
-  !*** ../src/fire/fireMaterial.ts ***!
-  \***********************************/
+/***/ "./src/fire/fireMaterial.ts":
+/*!**********************************!*\
+  !*** ./src/fire/fireMaterial.ts ***!
+  \**********************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -179,8 +209,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
-babylonjs_1.Effect.ShadersStore["firePixelShader"] = __webpack_require__(/*! ./fire.fragment.fx */ "../src/fire/fire.fragment.fx");
-babylonjs_1.Effect.ShadersStore["fireVertexShader"] = __webpack_require__(/*! ./fire.vertex.fx */ "../src/fire/fire.vertex.fx");
+babylonjs_1.Effect.ShadersStore["firePixelShader"] = __webpack_require__(/*! ./fire.fragment.fx */ "./src/fire/fire.fragment.fx");
+babylonjs_1.Effect.ShadersStore["fireVertexShader"] = __webpack_require__(/*! ./fire.vertex.fx */ "./src/fire/fire.vertex.fx");
 var FireMaterialDefines = /** @class */ (function (_super) {
     __extends(FireMaterialDefines, _super);
     function FireMaterialDefines() {
@@ -495,10 +525,10 @@ exports.FireMaterial = FireMaterial;
 
 /***/ }),
 
-/***/ "../src/fire/index.ts":
-/*!****************************!*\
-  !*** ../src/fire/index.ts ***!
-  \****************************/
+/***/ "./src/fire/index.ts":
+/*!***************************!*\
+  !*** ./src/fire/index.ts ***!
+  \***************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -508,38 +538,8 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./fireMaterial */ "../src/fire/fireMaterial.ts"));
-
-
-/***/ }),
-
-/***/ "./legacy-fire.ts":
-/*!************************!*\
-  !*** ./legacy-fire.ts ***!
-  \************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-var MatLib = __webpack_require__(/*! ../src/fire/index */ "../src/fire/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];
-    }
-}
-__export(__webpack_require__(/*! ../src/fire/index */ "../src/fire/index.ts"));
+__export(__webpack_require__(/*! ./fireMaterial */ "./src/fire/fireMaterial.ts"));
 
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 

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

@@ -91,46 +91,76 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy-gradient.ts");
+/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-gradient.ts");
 /******/ })
 /************************************************************************/
 /******/ ({
 
-/***/ "../../Tools/Gulp/node_modules/webpack/buildin/global.js":
-/*!***********************************!*\
-  !*** (webpack)/buildin/global.js ***!
-  \***********************************/
+/***/ "../Tools/Gulp/node_modules/webpack/buildin/global.js":
+/*!************************************************************!*\
+  !*** ../Tools/Gulp/node_modules/webpack/buildin/global.js ***!
+  \************************************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
-var g;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
-// This works in non-strict mode
-g = (function() {
-	return this;
-})();
 
-try {
-	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("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) { ...}
+/***/ "./legacy/legacy-gradient.ts":
+/*!***********************************!*\
+  !*** ./legacy/legacy-gradient.ts ***!
+  \***********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
 
-module.exports = g;
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var MatLib = __webpack_require__(/*! ../src/gradient/index */ "./src/gradient/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];
+    }
+}
+__export(__webpack_require__(/*! ../src/gradient/index */ "./src/gradient/index.ts"));
 
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "../src/gradient/gradient.fragment.fx":
-/*!********************************************!*\
-  !*** ../src/gradient/gradient.fragment.fx ***!
-  \********************************************/
+/***/ "./src/gradient/gradient.fragment.fx":
+/*!*******************************************!*\
+  !*** ./src/gradient/gradient.fragment.fx ***!
+  \*******************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -138,10 +168,10 @@ module.exports = "precision highp float;\n\nuniform vec3 vEyePosition;\nuniform
 
 /***/ }),
 
-/***/ "../src/gradient/gradient.vertex.fx":
-/*!******************************************!*\
-  !*** ../src/gradient/gradient.vertex.fx ***!
-  \******************************************/
+/***/ "./src/gradient/gradient.vertex.fx":
+/*!*****************************************!*\
+  !*** ./src/gradient/gradient.vertex.fx ***!
+  \*****************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -149,10 +179,10 @@ module.exports = "precision highp float;\n\nattribute vec3 position;\n#ifdef NOR
 
 /***/ }),
 
-/***/ "../src/gradient/gradientMaterial.ts":
-/*!*******************************************!*\
-  !*** ../src/gradient/gradientMaterial.ts ***!
-  \*******************************************/
+/***/ "./src/gradient/gradientMaterial.ts":
+/*!******************************************!*\
+  !*** ./src/gradient/gradientMaterial.ts ***!
+  \******************************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -179,8 +209,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
-babylonjs_1.Effect.ShadersStore["gradientPixelShader"] = __webpack_require__(/*! ./gradient.fragment.fx */ "../src/gradient/gradient.fragment.fx");
-babylonjs_1.Effect.ShadersStore["gradientVertexShader"] = __webpack_require__(/*! ./gradient.vertex.fx */ "../src/gradient/gradient.vertex.fx");
+babylonjs_1.Effect.ShadersStore["gradientPixelShader"] = __webpack_require__(/*! ./gradient.fragment.fx */ "./src/gradient/gradient.fragment.fx");
+babylonjs_1.Effect.ShadersStore["gradientVertexShader"] = __webpack_require__(/*! ./gradient.vertex.fx */ "./src/gradient/gradient.vertex.fx");
 var GradientMaterialDefines = /** @class */ (function (_super) {
     __extends(GradientMaterialDefines, _super);
     function GradientMaterialDefines() {
@@ -467,10 +497,10 @@ exports.GradientMaterial = GradientMaterial;
 
 /***/ }),
 
-/***/ "../src/gradient/index.ts":
-/*!********************************!*\
-  !*** ../src/gradient/index.ts ***!
-  \********************************/
+/***/ "./src/gradient/index.ts":
+/*!*******************************!*\
+  !*** ./src/gradient/index.ts ***!
+  \*******************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -480,38 +510,8 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./gradientMaterial */ "../src/gradient/gradientMaterial.ts"));
-
-
-/***/ }),
-
-/***/ "./legacy-gradient.ts":
-/*!****************************!*\
-  !*** ./legacy-gradient.ts ***!
-  \****************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-var MatLib = __webpack_require__(/*! ../src/gradient/index */ "../src/gradient/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];
-    }
-}
-__export(__webpack_require__(/*! ../src/gradient/index */ "../src/gradient/index.ts"));
+__export(__webpack_require__(/*! ./gradientMaterial */ "./src/gradient/gradientMaterial.ts"));
 
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 

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

@@ -91,46 +91,76 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy-lava.ts");
+/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-lava.ts");
 /******/ })
 /************************************************************************/
 /******/ ({
 
-/***/ "../../Tools/Gulp/node_modules/webpack/buildin/global.js":
-/*!***********************************!*\
-  !*** (webpack)/buildin/global.js ***!
-  \***********************************/
+/***/ "../Tools/Gulp/node_modules/webpack/buildin/global.js":
+/*!************************************************************!*\
+  !*** ../Tools/Gulp/node_modules/webpack/buildin/global.js ***!
+  \************************************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
-var g;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
-// This works in non-strict mode
-g = (function() {
-	return this;
-})();
 
-try {
-	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("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) { ...}
+/***/ "./legacy/legacy-lava.ts":
+/*!*******************************!*\
+  !*** ./legacy/legacy-lava.ts ***!
+  \*******************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
 
-module.exports = g;
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var MatLib = __webpack_require__(/*! ../src/lava/index */ "./src/lava/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];
+    }
+}
+__export(__webpack_require__(/*! ../src/lava/index */ "./src/lava/index.ts"));
 
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "../src/lava/index.ts":
-/*!****************************!*\
-  !*** ../src/lava/index.ts ***!
-  \****************************/
+/***/ "./src/lava/index.ts":
+/*!***************************!*\
+  !*** ./src/lava/index.ts ***!
+  \***************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -140,15 +170,15 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./lavaMaterial */ "../src/lava/lavaMaterial.ts"));
+__export(__webpack_require__(/*! ./lavaMaterial */ "./src/lava/lavaMaterial.ts"));
 
 
 /***/ }),
 
-/***/ "../src/lava/lava.fragment.fx":
-/*!************************************!*\
-  !*** ../src/lava/lava.fragment.fx ***!
-  \************************************/
+/***/ "./src/lava/lava.fragment.fx":
+/*!***********************************!*\
+  !*** ./src/lava/lava.fragment.fx ***!
+  \***********************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -156,10 +186,10 @@ module.exports = "precision highp float;\n\nuniform vec3 vEyePosition;\nuniform
 
 /***/ }),
 
-/***/ "../src/lava/lava.vertex.fx":
-/*!**********************************!*\
-  !*** ../src/lava/lava.vertex.fx ***!
-  \**********************************/
+/***/ "./src/lava/lava.vertex.fx":
+/*!*********************************!*\
+  !*** ./src/lava/lava.vertex.fx ***!
+  \*********************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -167,10 +197,10 @@ module.exports = "precision highp float;\n\nuniform float time;\nuniform float l
 
 /***/ }),
 
-/***/ "../src/lava/lavaMaterial.ts":
-/*!***********************************!*\
-  !*** ../src/lava/lavaMaterial.ts ***!
-  \***********************************/
+/***/ "./src/lava/lavaMaterial.ts":
+/*!**********************************!*\
+  !*** ./src/lava/lavaMaterial.ts ***!
+  \**********************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -197,8 +227,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
-babylonjs_1.Effect.ShadersStore["lavaPixelShader"] = __webpack_require__(/*! ./lava.fragment.fx */ "../src/lava/lava.fragment.fx");
-babylonjs_1.Effect.ShadersStore["lavaVertexShader"] = __webpack_require__(/*! ./lava.vertex.fx */ "../src/lava/lava.vertex.fx");
+babylonjs_1.Effect.ShadersStore["lavaPixelShader"] = __webpack_require__(/*! ./lava.fragment.fx */ "./src/lava/lava.fragment.fx");
+babylonjs_1.Effect.ShadersStore["lavaVertexShader"] = __webpack_require__(/*! ./lava.vertex.fx */ "./src/lava/lava.vertex.fx");
 var LavaMaterialDefines = /** @class */ (function (_super) {
     __extends(LavaMaterialDefines, _super);
     function LavaMaterialDefines() {
@@ -563,36 +593,6 @@ exports.LavaMaterial = LavaMaterial;
 
 /***/ }),
 
-/***/ "./legacy-lava.ts":
-/*!************************!*\
-  !*** ./legacy-lava.ts ***!
-  \************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-var MatLib = __webpack_require__(/*! ../src/lava/index */ "../src/lava/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];
-    }
-}
-__export(__webpack_require__(/*! ../src/lava/index */ "../src/lava/index.ts"));
-
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../../Tools/Gulp/node_modules/webpack/buildin/global.js")))
-
-/***/ }),
-
 /***/ "babylonjs":
 /*!****************************************************************************************************!*\
   !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!

dist/preview release/materialsLibrary/babylon.materials.d.ts

@@ -1,549 +0,0 @@
-/*BabylonJS Materials*/
-// Dependencies for this module:
-//   ../../../../Tools/Gulp/babylonjs
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-    export class CellMaterial extends BABYLON.PushMaterial {
-        diffuseTexture: BABYLON.BaseTexture;
-        diffuseColor: BABYLON.Color3;
-        _computeHighLevel: boolean;
-        computeHighLevel: boolean;
-        disableLighting: boolean;
-        maxSimultaneousLights: number;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        getActiveTextures(): BABYLON.BaseTexture[];
-        hasTexture(texture: BABYLON.BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        getClassName(): string;
-        clone(name: string): CellMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): CellMaterial;
-    }
-}
-declare module BABYLON {
-    export class CustomShaderStructure {
-        FragmentStore: string;
-        VertexStore: string;
-        constructor();
-    }
-    export class ShaderSpecialParts {
-        constructor();
-        Fragment_Begin: string;
-        Fragment_Definitions: string;
-        Fragment_MainBegin: string;
-        Fragment_Custom_Diffuse: string;
-        Fragment_Custom_Alpha: string;
-        Fragment_Before_FragColor: string;
-        Vertex_Begin: string;
-        Vertex_Definitions: string;
-        Vertex_MainBegin: string;
-        Vertex_Before_PositionUpdated: string;
-        Vertex_Before_NormalUpdated: string;
-    }
-    export class CustomMaterial extends BABYLON.StandardMaterial {
-        static ShaderIndexer: number;
-        CustomParts: ShaderSpecialParts;
-        _isCreatedShader: boolean;
-        _createdShaderName: string;
-        _customUniform: string[];
-        _newUniforms: string[];
-        _newUniformInstances: any[];
-        _newSamplerInstances: BABYLON.Texture[];
-        FragmentShader: string;
-        VertexShader: string;
-        AttachAfterBind(mesh: BABYLON.Mesh, effect: BABYLON.Effect): void;
-        ReviewUniform(name: string, arr: string[]): string[];
-        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: BABYLON.StandardMaterialDefines): string;
-        constructor(name: string, scene: BABYLON.Scene);
-        AddUniform(name: string, kind: string, param: any): CustomMaterial;
-        Fragment_Begin(shaderPart: string): CustomMaterial;
-        Fragment_Definitions(shaderPart: string): CustomMaterial;
-        Fragment_MainBegin(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
-        Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
-        Vertex_Begin(shaderPart: string): CustomMaterial;
-        Vertex_Definitions(shaderPart: string): CustomMaterial;
-        Vertex_MainBegin(shaderPart: string): CustomMaterial;
-        Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
-        Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
-    }
-}
-declare module BABYLON {
-    export class FireMaterial extends BABYLON.PushMaterial {
-        diffuseTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
-        distortionTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
-        opacityTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
-        diffuseColor: BABYLON.Color3;
-        speed: number;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        getActiveTextures(): BABYLON.BaseTexture[];
-        hasTexture(texture: BABYLON.BaseTexture): boolean;
-        getClassName(): string;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): FireMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FireMaterial;
-    }
-}
-declare module BABYLON {
-    export class FurMaterial extends BABYLON.PushMaterial {
-        diffuseTexture: BABYLON.BaseTexture;
-        heightTexture: BABYLON.BaseTexture;
-        diffuseColor: BABYLON.Color3;
-        furLength: number;
-        furAngle: number;
-        furColor: BABYLON.Color3;
-        furOffset: number;
-        furSpacing: number;
-        furGravity: BABYLON.Vector3;
-        furSpeed: number;
-        furDensity: number;
-        furOcclusion: number;
-        furTexture: BABYLON.DynamicTexture;
-        disableLighting: boolean;
-        maxSimultaneousLights: number;
-        highLevelFur: boolean;
-        _meshes: BABYLON.AbstractMesh[];
-        constructor(name: string, scene: BABYLON.Scene);
-        furTime: number;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        updateFur(): void;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        getActiveTextures(): BABYLON.BaseTexture[];
-        hasTexture(texture: BABYLON.BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): FurMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FurMaterial;
-        static GenerateTexture(name: string, scene: BABYLON.Scene): BABYLON.DynamicTexture;
-        static FurifyMesh(sourceMesh: BABYLON.Mesh, quality: number): BABYLON.Mesh[];
-    }
-}
-declare module BABYLON {
-    export class GradientMaterial extends BABYLON.PushMaterial {
-        maxSimultaneousLights: number;
-        topColor: BABYLON.Color3;
-        topColorAlpha: number;
-        bottomColor: BABYLON.Color3;
-        bottomColorAlpha: number;
-        offset: number;
-        scale: number;
-        smoothness: number;
-        disableLighting: boolean;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GradientMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): GradientMaterial;
-    }
-}
-declare module BABYLON {
-    /**
-        * The grid materials allows you to wrap any shape with a grid.
-        * Colors are customizable.
-        */
-    export class GridMaterial extends BABYLON.PushMaterial {
-            /**
-                * Main color of the grid (e.g. between lines)
-                */
-            mainColor: BABYLON.Color3;
-            /**
-                * Color of the grid lines.
-                */
-            lineColor: BABYLON.Color3;
-            /**
-                * The scale of the grid compared to unit.
-                */
-            gridRatio: number;
-            /**
-                * Allows setting an offset for the grid lines.
-                */
-            gridOffset: BABYLON.Vector3;
-            /**
-                * The frequency of thicker lines.
-                */
-            majorUnitFrequency: number;
-            /**
-                * The visibility of minor units in the grid.
-                */
-            minorUnitVisibility: number;
-            /**
-                * The grid opacity outside of the lines.
-                */
-            opacity: number;
-            /**
-                * Determine RBG output is premultiplied by alpha value.
-                */
-            preMultiplyAlpha: boolean;
-            /**
-                * constructor
-                * @param name The name given to the material in order to identify it afterwards.
-                * @param scene The scene the material is used in.
-                */
-            constructor(name: string, scene: BABYLON.Scene);
-            /**
-                * Returns wehter or not the grid requires alpha blending.
-                */
-            needAlphaBlending(): boolean;
-            needAlphaBlendingForMesh(mesh: BABYLON.AbstractMesh): boolean;
-            isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-            bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-            dispose(forceDisposeEffect?: boolean): void;
-            clone(name: string): GridMaterial;
-            serialize(): any;
-            getClassName(): string;
-            static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): GridMaterial;
-    }
-}
-declare module BABYLON {
-    export class LavaMaterial extends BABYLON.PushMaterial {
-        diffuseTexture: BABYLON.BaseTexture;
-        noiseTexture: BABYLON.BaseTexture;
-        fogColor: BABYLON.Color3;
-        speed: number;
-        movingSpeed: number;
-        lowFrequencySpeed: number;
-        fogDensity: number;
-        diffuseColor: BABYLON.Color3;
-        disableLighting: boolean;
-        unlit: boolean;
-        maxSimultaneousLights: number;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        getActiveTextures(): BABYLON.BaseTexture[];
-        hasTexture(texture: BABYLON.BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): LavaMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): LavaMaterial;
-    }
-}
-declare module BABYLON {
-    export class MixMaterial extends BABYLON.PushMaterial {
-            mixTexture1: BABYLON.BaseTexture;
-            mixTexture2: BABYLON.BaseTexture;
-            diffuseTexture1: BABYLON.Texture;
-            diffuseTexture2: BABYLON.Texture;
-            diffuseTexture3: BABYLON.Texture;
-            diffuseTexture4: BABYLON.Texture;
-            diffuseTexture5: BABYLON.Texture;
-            diffuseTexture6: BABYLON.Texture;
-            diffuseTexture7: BABYLON.Texture;
-            diffuseTexture8: BABYLON.Texture;
-            /**
-                * Uniforms
-                */
-            diffuseColor: BABYLON.Color3;
-            specularColor: BABYLON.Color3;
-            specularPower: number;
-            disableLighting: boolean;
-            maxSimultaneousLights: number;
-            constructor(name: string, scene: BABYLON.Scene);
-            needAlphaBlending(): boolean;
-            needAlphaTesting(): boolean;
-            getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-            isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-            bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-            getAnimatables(): BABYLON.IAnimatable[];
-            getActiveTextures(): BABYLON.BaseTexture[];
-            hasTexture(texture: BABYLON.BaseTexture): boolean;
-            dispose(forceDisposeEffect?: boolean): void;
-            clone(name: string): MixMaterial;
-            serialize(): any;
-            getClassName(): string;
-            static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MixMaterial;
-    }
-}
-declare module BABYLON {
-    export class NormalMaterial extends BABYLON.PushMaterial {
-        diffuseTexture: BABYLON.BaseTexture;
-        diffuseColor: BABYLON.Color3;
-        disableLighting: boolean;
-        maxSimultaneousLights: number;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        getActiveTextures(): BABYLON.BaseTexture[];
-        hasTexture(texture: BABYLON.BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): NormalMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): NormalMaterial;
-    }
-}
-declare module BABYLON {
-    export class ShadowOnlyMaterial extends BABYLON.PushMaterial {
-        constructor(name: string, scene: BABYLON.Scene);
-        shadowColor: BABYLON.Color3;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        activeLight: BABYLON.IShadowLight;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        clone(name: string): ShadowOnlyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): ShadowOnlyMaterial;
-    }
-}
-declare module BABYLON {
-    export class SimpleMaterial extends BABYLON.PushMaterial {
-        diffuseTexture: BABYLON.BaseTexture;
-        diffuseColor: BABYLON.Color3;
-        disableLighting: boolean;
-        maxSimultaneousLights: number;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        getActiveTextures(): BABYLON.BaseTexture[];
-        hasTexture(texture: BABYLON.BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): SimpleMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): SimpleMaterial;
-    }
-}
-declare module BABYLON {
-    export class SkyMaterial extends BABYLON.PushMaterial {
-        luminance: number;
-        turbidity: number;
-        rayleigh: number;
-        mieCoefficient: number;
-        mieDirectionalG: number;
-        distance: number;
-        inclination: number;
-        azimuth: number;
-        sunPosition: BABYLON.Vector3;
-        useSunPosition: boolean;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): SkyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): SkyMaterial;
-    }
-}
-declare module BABYLON {
-    export class TerrainMaterial extends BABYLON.PushMaterial {
-        mixTexture: BABYLON.BaseTexture;
-        diffuseTexture1: BABYLON.Texture;
-        diffuseTexture2: BABYLON.Texture;
-        diffuseTexture3: BABYLON.Texture;
-        bumpTexture1: BABYLON.Texture;
-        bumpTexture2: BABYLON.Texture;
-        bumpTexture3: BABYLON.Texture;
-        diffuseColor: BABYLON.Color3;
-        specularColor: BABYLON.Color3;
-        specularPower: number;
-        disableLighting: boolean;
-        maxSimultaneousLights: number;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        getActiveTextures(): BABYLON.BaseTexture[];
-        hasTexture(texture: BABYLON.BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): TerrainMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): TerrainMaterial;
-    }
-}
-declare module BABYLON {
-    export class TriPlanarMaterial extends BABYLON.PushMaterial {
-        mixTexture: BABYLON.BaseTexture;
-        diffuseTextureX: BABYLON.BaseTexture;
-        diffuseTextureY: BABYLON.BaseTexture;
-        diffuseTextureZ: BABYLON.BaseTexture;
-        normalTextureX: BABYLON.BaseTexture;
-        normalTextureY: BABYLON.BaseTexture;
-        normalTextureZ: BABYLON.BaseTexture;
-        tileSize: number;
-        diffuseColor: BABYLON.Color3;
-        specularColor: BABYLON.Color3;
-        specularPower: number;
-        disableLighting: boolean;
-        maxSimultaneousLights: number;
-        constructor(name: string, scene: BABYLON.Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-        getAnimatables(): BABYLON.IAnimatable[];
-        getActiveTextures(): BABYLON.BaseTexture[];
-        hasTexture(texture: BABYLON.BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): TriPlanarMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): TriPlanarMaterial;
-    }
-}
-declare module BABYLON {
-    export class WaterMaterial extends BABYLON.PushMaterial {
-            renderTargetSize: BABYLON.Vector2;
-            bumpTexture: BABYLON.BaseTexture;
-            diffuseColor: BABYLON.Color3;
-            specularColor: BABYLON.Color3;
-            specularPower: number;
-            disableLighting: boolean;
-            maxSimultaneousLights: number;
-            /**
-             * @param {number}: Represents the wind force
-             */
-            windForce: number;
-            /**
-             * @param {Vector2}: The direction of the wind in the plane (X, Z)
-             */
-            windDirection: BABYLON.Vector2;
-            /**
-             * @param {number}: Wave height, represents the height of the waves
-             */
-            waveHeight: number;
-            /**
-             * @param {number}: Bump height, represents the bump height related to the bump map
-             */
-            bumpHeight: number;
-            bumpSuperimpose: boolean;
-            fresnelSeparate: boolean;
-            bumpAffectsReflection: boolean;
-            /**
-             * @param {number}: The water color blended with the refraction (near)
-             */
-            waterColor: BABYLON.Color3;
-            /**
-             * @param {number}: The blend factor related to the water color
-             */
-            colorBlendFactor: number;
-            /**
-                * @param {number}: The water color blended with the reflection (far)
-                */
-            waterColor2: BABYLON.Color3;
-            /**
-                * @param {number}: The blend factor related to the water color (reflection, far)
-                */
-            colorBlendFactor2: number;
-            /**
-             * @param {number}: Represents the maximum length of a wave
-             */
-            waveLength: number;
-            /**
-             * @param {number}: Defines the waves speed
-             */
-            waveSpeed: number;
-            protected _renderTargets: BABYLON.SmartArray<BABYLON.RenderTargetTexture>;
-            /**
-                * Gets a boolean indicating that current material needs to register RTT
-                */
-            readonly hasRenderTargetTextures: boolean;
-            /**
-             * Constructor
-             */
-            constructor(name: string, scene: BABYLON.Scene, renderTargetSize?: BABYLON.Vector2);
-            useLogarithmicDepth: boolean;
-            readonly refractionTexture: BABYLON.Nullable<BABYLON.RenderTargetTexture>;
-            readonly reflectionTexture: BABYLON.Nullable<BABYLON.RenderTargetTexture>;
-            addToRenderList(node: any): void;
-            enableRenderTargets(enable: boolean): void;
-            getRenderList(): BABYLON.Nullable<BABYLON.AbstractMesh[]>;
-            readonly renderTargetsEnabled: boolean;
-            needAlphaBlending(): boolean;
-            needAlphaTesting(): boolean;
-            getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
-            isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
-            bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
-            getAnimatables(): BABYLON.IAnimatable[];
-            getActiveTextures(): BABYLON.BaseTexture[];
-            hasTexture(texture: BABYLON.BaseTexture): boolean;
-            dispose(forceDisposeEffect?: boolean): void;
-            clone(name: string): WaterMaterial;
-            serialize(): any;
-            getClassName(): string;
-            static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): WaterMaterial;
-            static CreateDefaultMesh(name: string, scene: BABYLON.Scene): BABYLON.Mesh;
-    }
-}

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

@@ -91,46 +91,76 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy-mix.ts");
+/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-mix.ts");
 /******/ })
 /************************************************************************/
 /******/ ({
 
-/***/ "../../Tools/Gulp/node_modules/webpack/buildin/global.js":
-/*!***********************************!*\
-  !*** (webpack)/buildin/global.js ***!
-  \***********************************/
+/***/ "../Tools/Gulp/node_modules/webpack/buildin/global.js":
+/*!************************************************************!*\
+  !*** ../Tools/Gulp/node_modules/webpack/buildin/global.js ***!
+  \************************************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
-var g;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
-// This works in non-strict mode
-g = (function() {
-	return this;
-})();
 
-try {
-	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("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) { ...}
+/***/ "./legacy/legacy-mix.ts":
+/*!******************************!*\
+  !*** ./legacy/legacy-mix.ts ***!
+  \******************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
 
-module.exports = g;
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var MatLib = __webpack_require__(/*! ../src/mix/index */ "./src/mix/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];
+    }
+}
+__export(__webpack_require__(/*! ../src/mix/index */ "./src/mix/index.ts"));
 
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "../src/mix/index.ts":
-/*!***************************!*\
-  !*** ../src/mix/index.ts ***!
-  \***************************/
+/***/ "./src/mix/index.ts":
+/*!**************************!*\
+  !*** ./src/mix/index.ts ***!
+  \**************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -140,15 +170,15 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./mixMaterial */ "../src/mix/mixMaterial.ts"));
+__export(__webpack_require__(/*! ./mixMaterial */ "./src/mix/mixMaterial.ts"));
 
 
 /***/ }),
 
-/***/ "../src/mix/mix.fragment.fx":
-/*!**********************************!*\
-  !*** ../src/mix/mix.fragment.fx ***!
-  \**********************************/
+/***/ "./src/mix/mix.fragment.fx":
+/*!*********************************!*\
+  !*** ./src/mix/mix.fragment.fx ***!
+  \*********************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -156,10 +186,10 @@ module.exports = "precision highp float;\n\nuniform vec3 vEyePosition;\nuniform
 
 /***/ }),
 
-/***/ "../src/mix/mix.vertex.fx":
-/*!********************************!*\
-  !*** ../src/mix/mix.vertex.fx ***!
-  \********************************/
+/***/ "./src/mix/mix.vertex.fx":
+/*!*******************************!*\
+  !*** ./src/mix/mix.vertex.fx ***!
+  \*******************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -167,10 +197,10 @@ module.exports = "precision highp float;\n\nattribute vec3 position;\n#ifdef NOR
 
 /***/ }),
 
-/***/ "../src/mix/mixMaterial.ts":
-/*!*********************************!*\
-  !*** ../src/mix/mixMaterial.ts ***!
-  \*********************************/
+/***/ "./src/mix/mixMaterial.ts":
+/*!********************************!*\
+  !*** ./src/mix/mixMaterial.ts ***!
+  \********************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -197,8 +227,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
-babylonjs_1.Effect.ShadersStore["mixPixelShader"] = __webpack_require__(/*! ./mix.fragment.fx */ "../src/mix/mix.fragment.fx");
-babylonjs_1.Effect.ShadersStore["mixVertexShader"] = __webpack_require__(/*! ./mix.vertex.fx */ "../src/mix/mix.vertex.fx");
+babylonjs_1.Effect.ShadersStore["mixPixelShader"] = __webpack_require__(/*! ./mix.fragment.fx */ "./src/mix/mix.fragment.fx");
+babylonjs_1.Effect.ShadersStore["mixVertexShader"] = __webpack_require__(/*! ./mix.vertex.fx */ "./src/mix/mix.vertex.fx");
 var MixMaterialDefines = /** @class */ (function (_super) {
     __extends(MixMaterialDefines, _super);
     function MixMaterialDefines() {
@@ -650,36 +680,6 @@ exports.MixMaterial = MixMaterial;
 
 /***/ }),
 
-/***/ "./legacy-mix.ts":
-/*!***********************!*\
-  !*** ./legacy-mix.ts ***!
-  \***********************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-var MatLib = __webpack_require__(/*! ../src/mix/index */ "../src/mix/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];
-    }
-}
-__export(__webpack_require__(/*! ../src/mix/index */ "../src/mix/index.ts"));
-
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../../Tools/Gulp/node_modules/webpack/buildin/global.js")))
-
-/***/ }),
-
 /***/ "babylonjs":
 /*!****************************************************************************************************!*\
   !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!

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

@@ -91,46 +91,76 @@ return /******/ (function(modules) { // webpackBootstrap
 /******/
 /******/
 /******/ 	// Load entry module and return exports
-/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy-normal.ts");
+/******/ 	return __webpack_require__(__webpack_require__.s = "./legacy/legacy-normal.ts");
 /******/ })
 /************************************************************************/
 /******/ ({
 
-/***/ "../../Tools/Gulp/node_modules/webpack/buildin/global.js":
-/*!***********************************!*\
-  !*** (webpack)/buildin/global.js ***!
-  \***********************************/
+/***/ "../Tools/Gulp/node_modules/webpack/buildin/global.js":
+/*!************************************************************!*\
+  !*** ../Tools/Gulp/node_modules/webpack/buildin/global.js ***!
+  \************************************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
-var g;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
-// This works in non-strict mode
-g = (function() {
-	return this;
-})();
 
-try {
-	// This works if eval is allowed (see CSP)
-	g = g || Function("return this")() || (1, eval)("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) { ...}
+/***/ "./legacy/legacy-normal.ts":
+/*!*********************************!*\
+  !*** ./legacy/legacy-normal.ts ***!
+  \*********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
 
-module.exports = g;
+"use strict";
+/* WEBPACK VAR INJECTION */(function(global) {
+function __export(m) {
+    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
+}
+Object.defineProperty(exports, "__esModule", { value: true });
+var MatLib = __webpack_require__(/*! ../src/normal/index */ "./src/normal/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];
+    }
+}
+__export(__webpack_require__(/*! ../src/normal/index */ "./src/normal/index.ts"));
 
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../Tools/Gulp/node_modules/webpack/buildin/global.js")))
 
 /***/ }),
 
-/***/ "../src/normal/index.ts":
-/*!******************************!*\
-  !*** ../src/normal/index.ts ***!
-  \******************************/
+/***/ "./src/normal/index.ts":
+/*!*****************************!*\
+  !*** ./src/normal/index.ts ***!
+  \*****************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -140,15 +170,15 @@ function __export(m) {
     for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
 }
 Object.defineProperty(exports, "__esModule", { value: true });
-__export(__webpack_require__(/*! ./normalMaterial */ "../src/normal/normalMaterial.ts"));
+__export(__webpack_require__(/*! ./normalMaterial */ "./src/normal/normalMaterial.ts"));
 
 
 /***/ }),
 
-/***/ "../src/normal/normal.fragment.fx":
-/*!****************************************!*\
-  !*** ../src/normal/normal.fragment.fx ***!
-  \****************************************/
+/***/ "./src/normal/normal.fragment.fx":
+/*!***************************************!*\
+  !*** ./src/normal/normal.fragment.fx ***!
+  \***************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -156,10 +186,10 @@ module.exports = "precision highp float;\n\nuniform vec3 vEyePosition;\nuniform
 
 /***/ }),
 
-/***/ "../src/normal/normal.vertex.fx":
-/*!**************************************!*\
-  !*** ../src/normal/normal.vertex.fx ***!
-  \**************************************/
+/***/ "./src/normal/normal.vertex.fx":
+/*!*************************************!*\
+  !*** ./src/normal/normal.vertex.fx ***!
+  \*************************************/
 /*! no static exports found */
 /***/ (function(module, exports) {
 
@@ -167,10 +197,10 @@ module.exports = "precision highp float;\n\nattribute vec3 position;\n#ifdef NOR
 
 /***/ }),
 
-/***/ "../src/normal/normalMaterial.ts":
-/*!***************************************!*\
-  !*** ../src/normal/normalMaterial.ts ***!
-  \***************************************/
+/***/ "./src/normal/normalMaterial.ts":
+/*!**************************************!*\
+  !*** ./src/normal/normalMaterial.ts ***!
+  \**************************************/
 /*! no static exports found */
 /***/ (function(module, exports, __webpack_require__) {
 
@@ -197,8 +227,8 @@ var __decorate = (this && this.__decorate) || function (decorators, target, key,
 };
 Object.defineProperty(exports, "__esModule", { value: true });
 var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
-babylonjs_1.Effect.ShadersStore["normalPixelShader"] = __webpack_require__(/*! ./normal.fragment.fx */ "../src/normal/normal.fragment.fx");
-babylonjs_1.Effect.ShadersStore["normalVertexShader"] = __webpack_require__(/*! ./normal.vertex.fx */ "../src/normal/normal.vertex.fx");
+babylonjs_1.Effect.ShadersStore["normalPixelShader"] = __webpack_require__(/*! ./normal.fragment.fx */ "./src/normal/normal.fragment.fx");
+babylonjs_1.Effect.ShadersStore["normalVertexShader"] = __webpack_require__(/*! ./normal.vertex.fx */ "./src/normal/normal.vertex.fx");
 var NormalMaterialDefines = /** @class */ (function (_super) {
     __extends(NormalMaterialDefines, _super);
     function NormalMaterialDefines() {
@@ -507,36 +537,6 @@ exports.NormalMaterial = NormalMaterial;
 
 /***/ }),
 
-/***/ "./legacy-normal.ts":
-/*!**************************!*\
-  !*** ./legacy-normal.ts ***!
-  \**************************/
-/*! no static exports found */
-/***/ (function(module, exports, __webpack_require__) {
-
-"use strict";
-/* WEBPACK VAR INJECTION */(function(global) {
-function __export(m) {
-    for (var p in m) if (!exports.hasOwnProperty(p)) exports[p] = m[p];
-}
-Object.defineProperty(exports, "__esModule", { value: true });
-var MatLib = __webpack_require__(/*! ../src/normal/index */ "../src/normal/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];
-    }
-}
-__export(__webpack_require__(/*! ../src/normal/index */ "../src/normal/index.ts"));
-
-/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../Tools/Gulp/node_modules/webpack/buildin/global.js */ "../../Tools/Gulp/node_modules/webpack/buildin/global.js")))
-
-/***/ }),
-
 /***/ "babylonjs":
 /*!****************************************************************************************************!*\
   !*** external {"root":"BABYLON","commonjs":"babylonjs","commonjs2":"babylonjs","amd":"babylonjs"} ***!

dist/preview release/materialsLibrary/babylonjs.materials.d.ts

@@ -0,0 +1,487 @@
+/*BabylonJS Materials*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+export declare class CellMaterial extends BABYLON.PushMaterial {
+    diffuseTexture: BABYLON.BaseTexture;
+    diffuseColor: BABYLON.Color3;
+    _computeHighLevel: boolean;
+    computeHighLevel: boolean;
+    disableLighting: boolean;
+    maxSimultaneousLights: number;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    getActiveTextures(): BABYLON.BaseTexture[];
+    hasTexture(texture: BABYLON.BaseTexture): boolean;
+    dispose(forceDisposeEffect?: boolean): void;
+    getClassName(): string;
+    clone(name: string): CellMaterial;
+    serialize(): any;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): CellMaterial;
+}
+export declare class CustomShaderStructure {
+    FragmentStore: string;
+    VertexStore: string;
+    constructor();
+}
+export declare class ShaderSpecialParts {
+    constructor();
+    Fragment_Begin: string;
+    Fragment_Definitions: string;
+    Fragment_MainBegin: string;
+    Fragment_Custom_Diffuse: string;
+    Fragment_Custom_Alpha: string;
+    Fragment_Before_FragColor: string;
+    Vertex_Begin: string;
+    Vertex_Definitions: string;
+    Vertex_MainBegin: string;
+    Vertex_Before_PositionUpdated: string;
+    Vertex_Before_NormalUpdated: string;
+}
+export declare class CustomMaterial extends BABYLON.StandardMaterial {
+    static ShaderIndexer: number;
+    CustomParts: ShaderSpecialParts;
+    _isCreatedShader: boolean;
+    _createdShaderName: string;
+    _customUniform: string[];
+    _newUniforms: string[];
+    _newUniformInstances: any[];
+    _newSamplerInstances: BABYLON.Texture[];
+    FragmentShader: string;
+    VertexShader: string;
+    AttachAfterBind(mesh: BABYLON.Mesh, effect: BABYLON.Effect): void;
+    ReviewUniform(name: string, arr: string[]): string[];
+    Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: BABYLON.StandardMaterialDefines): string;
+    constructor(name: string, scene: BABYLON.Scene);
+    AddUniform(name: string, kind: string, param: any): CustomMaterial;
+    Fragment_Begin(shaderPart: string): CustomMaterial;
+    Fragment_Definitions(shaderPart: string): CustomMaterial;
+    Fragment_MainBegin(shaderPart: string): CustomMaterial;
+    Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
+    Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
+    Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
+    Vertex_Begin(shaderPart: string): CustomMaterial;
+    Vertex_Definitions(shaderPart: string): CustomMaterial;
+    Vertex_MainBegin(shaderPart: string): CustomMaterial;
+    Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
+    Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
+}
+export declare class FireMaterial extends BABYLON.PushMaterial {
+    diffuseTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
+    distortionTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
+    opacityTexture: BABYLON.Nullable<BABYLON.BaseTexture>;
+    diffuseColor: BABYLON.Color3;
+    speed: number;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    getActiveTextures(): BABYLON.BaseTexture[];
+    hasTexture(texture: BABYLON.BaseTexture): boolean;
+    getClassName(): string;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): FireMaterial;
+    serialize(): any;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FireMaterial;
+}
+export declare class FurMaterial extends BABYLON.PushMaterial {
+    diffuseTexture: BABYLON.BaseTexture;
+    heightTexture: BABYLON.BaseTexture;
+    diffuseColor: BABYLON.Color3;
+    furLength: number;
+    furAngle: number;
+    furColor: BABYLON.Color3;
+    furOffset: number;
+    furSpacing: number;
+    furGravity: BABYLON.Vector3;
+    furSpeed: number;
+    furDensity: number;
+    furOcclusion: number;
+    furTexture: BABYLON.DynamicTexture;
+    disableLighting: boolean;
+    maxSimultaneousLights: number;
+    highLevelFur: boolean;
+    _meshes: BABYLON.AbstractMesh[];
+    constructor(name: string, scene: BABYLON.Scene);
+    furTime: number;
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    updateFur(): void;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    getActiveTextures(): BABYLON.BaseTexture[];
+    hasTexture(texture: BABYLON.BaseTexture): boolean;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): FurMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): FurMaterial;
+    static GenerateTexture(name: string, scene: BABYLON.Scene): BABYLON.DynamicTexture;
+    static FurifyMesh(sourceMesh: BABYLON.Mesh, quality: number): BABYLON.Mesh[];
+}
+export declare class GradientMaterial extends BABYLON.PushMaterial {
+    maxSimultaneousLights: number;
+    topColor: BABYLON.Color3;
+    topColorAlpha: number;
+    bottomColor: BABYLON.Color3;
+    bottomColorAlpha: number;
+    offset: number;
+    scale: number;
+    smoothness: number;
+    disableLighting: boolean;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): GradientMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): GradientMaterial;
+}
+/**
+    * The grid materials allows you to wrap any shape with a grid.
+    * Colors are customizable.
+    */
+export declare class GridMaterial extends BABYLON.PushMaterial {
+        /**
+            * Main color of the grid (e.g. between lines)
+            */
+        mainColor: BABYLON.Color3;
+        /**
+            * Color of the grid lines.
+            */
+        lineColor: BABYLON.Color3;
+        /**
+            * The scale of the grid compared to unit.
+            */
+        gridRatio: number;
+        /**
+            * Allows setting an offset for the grid lines.
+            */
+        gridOffset: BABYLON.Vector3;
+        /**
+            * The frequency of thicker lines.
+            */
+        majorUnitFrequency: number;
+        /**
+            * The visibility of minor units in the grid.
+            */
+        minorUnitVisibility: number;
+        /**
+            * The grid opacity outside of the lines.
+            */
+        opacity: number;
+        /**
+            * Determine RBG output is premultiplied by alpha value.
+            */
+        preMultiplyAlpha: boolean;
+        /**
+            * constructor
+            * @param name The name given to the material in order to identify it afterwards.
+            * @param scene The scene the material is used in.
+            */
+        constructor(name: string, scene: BABYLON.Scene);
+        /**
+            * Returns wehter or not the grid requires alpha blending.
+            */
+        needAlphaBlending(): boolean;
+        needAlphaBlendingForMesh(mesh: BABYLON.AbstractMesh): boolean;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): GridMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): GridMaterial;
+}
+export declare class LavaMaterial extends BABYLON.PushMaterial {
+    diffuseTexture: BABYLON.BaseTexture;
+    noiseTexture: BABYLON.BaseTexture;
+    fogColor: BABYLON.Color3;
+    speed: number;
+    movingSpeed: number;
+    lowFrequencySpeed: number;
+    fogDensity: number;
+    diffuseColor: BABYLON.Color3;
+    disableLighting: boolean;
+    unlit: boolean;
+    maxSimultaneousLights: number;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    getActiveTextures(): BABYLON.BaseTexture[];
+    hasTexture(texture: BABYLON.BaseTexture): boolean;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): LavaMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): LavaMaterial;
+}
+export declare class MixMaterial extends BABYLON.PushMaterial {
+        mixTexture1: BABYLON.BaseTexture;
+        mixTexture2: BABYLON.BaseTexture;
+        diffuseTexture1: BABYLON.Texture;
+        diffuseTexture2: BABYLON.Texture;
+        diffuseTexture3: BABYLON.Texture;
+        diffuseTexture4: BABYLON.Texture;
+        diffuseTexture5: BABYLON.Texture;
+        diffuseTexture6: BABYLON.Texture;
+        diffuseTexture7: BABYLON.Texture;
+        diffuseTexture8: BABYLON.Texture;
+        /**
+            * Uniforms
+            */
+        diffuseColor: BABYLON.Color3;
+        specularColor: BABYLON.Color3;
+        specularPower: number;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        constructor(name: string, scene: BABYLON.Scene);
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): MixMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): MixMaterial;
+}
+export declare class NormalMaterial extends BABYLON.PushMaterial {
+    diffuseTexture: BABYLON.BaseTexture;
+    diffuseColor: BABYLON.Color3;
+    disableLighting: boolean;
+    maxSimultaneousLights: number;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    getActiveTextures(): BABYLON.BaseTexture[];
+    hasTexture(texture: BABYLON.BaseTexture): boolean;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): NormalMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): NormalMaterial;
+}
+export declare class ShadowOnlyMaterial extends BABYLON.PushMaterial {
+    constructor(name: string, scene: BABYLON.Scene);
+    shadowColor: BABYLON.Color3;
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    activeLight: BABYLON.IShadowLight;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    clone(name: string): ShadowOnlyMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): ShadowOnlyMaterial;
+}
+export declare class SimpleMaterial extends BABYLON.PushMaterial {
+    diffuseTexture: BABYLON.BaseTexture;
+    diffuseColor: BABYLON.Color3;
+    disableLighting: boolean;
+    maxSimultaneousLights: number;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    getActiveTextures(): BABYLON.BaseTexture[];
+    hasTexture(texture: BABYLON.BaseTexture): boolean;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): SimpleMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): SimpleMaterial;
+}
+export declare class SkyMaterial extends BABYLON.PushMaterial {
+    luminance: number;
+    turbidity: number;
+    rayleigh: number;
+    mieCoefficient: number;
+    mieDirectionalG: number;
+    distance: number;
+    inclination: number;
+    azimuth: number;
+    sunPosition: BABYLON.Vector3;
+    useSunPosition: boolean;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): SkyMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): SkyMaterial;
+}
+export declare class TerrainMaterial extends BABYLON.PushMaterial {
+    mixTexture: BABYLON.BaseTexture;
+    diffuseTexture1: BABYLON.Texture;
+    diffuseTexture2: BABYLON.Texture;
+    diffuseTexture3: BABYLON.Texture;
+    bumpTexture1: BABYLON.Texture;
+    bumpTexture2: BABYLON.Texture;
+    bumpTexture3: BABYLON.Texture;
+    diffuseColor: BABYLON.Color3;
+    specularColor: BABYLON.Color3;
+    specularPower: number;
+    disableLighting: boolean;
+    maxSimultaneousLights: number;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    getActiveTextures(): BABYLON.BaseTexture[];
+    hasTexture(texture: BABYLON.BaseTexture): boolean;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): TerrainMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): TerrainMaterial;
+}
+export declare class TriPlanarMaterial extends BABYLON.PushMaterial {
+    mixTexture: BABYLON.BaseTexture;
+    diffuseTextureX: BABYLON.BaseTexture;
+    diffuseTextureY: BABYLON.BaseTexture;
+    diffuseTextureZ: BABYLON.BaseTexture;
+    normalTextureX: BABYLON.BaseTexture;
+    normalTextureY: BABYLON.BaseTexture;
+    normalTextureZ: BABYLON.BaseTexture;
+    tileSize: number;
+    diffuseColor: BABYLON.Color3;
+    specularColor: BABYLON.Color3;
+    specularPower: number;
+    disableLighting: boolean;
+    maxSimultaneousLights: number;
+    constructor(name: string, scene: BABYLON.Scene);
+    needAlphaBlending(): boolean;
+    needAlphaTesting(): boolean;
+    getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+    isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+    bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+    getAnimatables(): BABYLON.IAnimatable[];
+    getActiveTextures(): BABYLON.BaseTexture[];
+    hasTexture(texture: BABYLON.BaseTexture): boolean;
+    dispose(forceDisposeEffect?: boolean): void;
+    clone(name: string): TriPlanarMaterial;
+    serialize(): any;
+    getClassName(): string;
+    static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): TriPlanarMaterial;
+}
+export declare class WaterMaterial extends BABYLON.PushMaterial {
+        renderTargetSize: BABYLON.Vector2;
+        bumpTexture: BABYLON.BaseTexture;
+        diffuseColor: BABYLON.Color3;
+        specularColor: BABYLON.Color3;
+        specularPower: number;
+        disableLighting: boolean;
+        maxSimultaneousLights: number;
+        /**
+         * @param {number}: Represents the wind force
+         */
+        windForce: number;
+        /**
+         * @param {Vector2}: The direction of the wind in the plane (X, Z)
+         */
+        windDirection: BABYLON.Vector2;
+        /**
+         * @param {number}: Wave height, represents the height of the waves
+         */
+        waveHeight: number;
+        /**
+         * @param {number}: Bump height, represents the bump height related to the bump map
+         */
+        bumpHeight: number;
+        bumpSuperimpose: boolean;
+        fresnelSeparate: boolean;
+        bumpAffectsReflection: boolean;
+        /**
+         * @param {number}: The water color blended with the refraction (near)
+         */
+        waterColor: BABYLON.Color3;
+        /**
+         * @param {number}: The blend factor related to the water color
+         */
+        colorBlendFactor: number;
+        /**
+            * @param {number}: The water color blended with the reflection (far)
+            */
+        waterColor2: BABYLON.Color3;
+        /**
+            * @param {number}: The blend factor related to the water color (reflection, far)
+            */
+        colorBlendFactor2: number;
+        /**
+         * @param {number}: Represents the maximum length of a wave
+         */
+        waveLength: number;
+        /**
+         * @param {number}: Defines the waves speed
+         */
+        waveSpeed: number;
+        protected _renderTargets: BABYLON.SmartArray<BABYLON.RenderTargetTexture>;
+        /**
+            * Gets a boolean indicating that current material needs to register RTT
+            */
+        readonly hasRenderTargetTextures: boolean;
+        /**
+         * Constructor
+         */
+        constructor(name: string, scene: BABYLON.Scene, renderTargetSize?: BABYLON.Vector2);
+        useLogarithmicDepth: boolean;
+        readonly refractionTexture: BABYLON.Nullable<BABYLON.RenderTargetTexture>;
+        readonly reflectionTexture: BABYLON.Nullable<BABYLON.RenderTargetTexture>;
+        addToRenderList(node: any): void;
+        enableRenderTargets(enable: boolean): void;
+        getRenderList(): BABYLON.Nullable<BABYLON.AbstractMesh[]>;
+        readonly renderTargetsEnabled: boolean;
+        needAlphaBlending(): boolean;
+        needAlphaTesting(): boolean;
+        getAlphaTestTexture(): BABYLON.Nullable<BABYLON.BaseTexture>;
+        isReadyForSubMesh(mesh: BABYLON.AbstractMesh, subMesh: BABYLON.SubMesh, useInstances?: boolean): boolean;
+        bindForSubMesh(world: BABYLON.Matrix, mesh: BABYLON.Mesh, subMesh: BABYLON.SubMesh): void;
+        getAnimatables(): BABYLON.IAnimatable[];
+        getActiveTextures(): BABYLON.BaseTexture[];
+        hasTexture(texture: BABYLON.BaseTexture): boolean;
+        dispose(forceDisposeEffect?: boolean): void;
+        clone(name: string): WaterMaterial;
+        serialize(): any;
+        getClassName(): string;
+        static Parse(source: any, scene: BABYLON.Scene, rootUrl: string): WaterMaterial;
+        static CreateDefaultMesh(name: string, scene: BABYLON.Scene): BABYLON.Mesh;
+}

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

@@ -103,26 +103,26 @@ return /******/ (function(modules) { // webpackBootstrap
 /*! 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 || Function("return this")() || (1, eval)("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;
+var g;
+
+// This works in non-strict mode
+g = (function() {
+	return this;
+})();
+
+try {
+	// This works if eval is allowed (see CSP)
+	g = g || Function("return this")() || (1, eval)("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;
 
 
 /***/ }),
@@ -377,7 +377,6 @@ var CellMaterial = /** @class */ (function (_super) {
         if (scene.fogEnabled && mesh.applyFog && scene.fogMode !== babylonjs_1.Scene.FOGMODE_NONE) {
             this._activeEffect.setMatrix("view", scene.getViewMatrix());
         }
-        console.log("TOTO");
         // Fog
         babylonjs_1.MaterialHelper.BindFogParameters(scene, mesh, this._activeEffect);
         this._afterBind(mesh, this._activeEffect);
@@ -6136,4 +6135,4 @@ module.exports = __WEBPACK_EXTERNAL_MODULE_babylonjs__;
 
 /******/ });
 });
-//# sourceMappingURL=babylon.materials.js.map
+//# sourceMappingURL=babylonjs.materials.js.map

dist/preview release/postProcessesLibrary/babylon.postProcesses.d.ts

@@ -1,169 +0,0 @@
-/*BabylonJS Postprocess library*/
-// Dependencies for this module:
-//   ../../../../Tools/Gulp/babylonjs
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-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.
-        */
-    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;
-    }
-    /**
-        * 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;
-    }
-    /**
-        * 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);
-    }
-}
-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.
-        */
-    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;
-    }
-    /**
-        * 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;
-    }
-    /**
-        * 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);
-    }
-}

dist/preview release/postProcessesLibrary/babylon.postProcesses.module.d.ts

@@ -1,351 +0,0 @@
-/*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-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";
-    /**
-        * 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;
-    }
-    /**
-        * 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;
-    }
-    /**
-        * 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);
-    }
-}
-
-declare module 'babylonjs-postProcessLibrary/src/digitalRain/digitalRainPostProcess' {
-    import { BaseTexture, Nullable, Scene, PostProcess, Camera } from "babylonjs";
-    /**
-        * 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;
-    }
-    /**
-        * 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;
-    }
-    /**
-        * 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);
-    }
-}
-
-
-/*BabylonJS Postprocess library*/
-// Dependencies for this module:
-//   ../../../../Tools/Gulp/babylonjs
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-declare module BABYLON {
-}
-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.
-        */
-    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;
-    }
-    /**
-        * 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;
-    }
-    /**
-        * 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);
-    }
-}
-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.
-        */
-    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;
-    }
-    /**
-        * 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;
-    }
-    /**
-        * 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);
-    }
-}

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

@@ -0,0 +1,159 @@
+/*BabylonJS Postprocess library*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+/**
+    * 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 declare 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;
+}
+/**
+    * 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;
+}
+/**
+    * 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 declare 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);
+}
+/**
+    * 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 declare 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;
+}
+/**
+    * 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;
+}
+/**
+    * 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 declare 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);
+}

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

@@ -0,0 +1,331 @@
+/*BabylonJS Postprocess library*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+
+export * from "babylonjs-postProcessLibrary/--/--/--/--/postProcessLibrary/build/src/asciiArt";
+export * from "babylonjs-postProcessLibrary/--/--/--/--/postProcessLibrary/build/src/digitalRain";
+
+export * from "babylonjs-postProcessLibrary/--/--/--/--/postProcessLibrary/build/src/asciiArt/asciiArtPostProcess";
+
+export * from "babylonjs-postProcessLibrary/--/--/--/--/postProcessLibrary/build/src/digitalRain/digitalRainPostProcess";
+
+import { BaseTexture, Nullable, Scene, PostProcess, Camera } from "babylonjs";
+/**
+    * 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 declare 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;
+}
+/**
+    * 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;
+}
+/**
+    * 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 declare 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);
+}
+
+import { BaseTexture, Nullable, Scene, PostProcess, Camera } from "babylonjs";
+/**
+    * 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 declare 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;
+}
+/**
+    * 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;
+}
+/**
+    * 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 declare 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);
+}
+
+
+/*BabylonJS Postprocess library*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+/**
+    * 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 declare 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;
+}
+/**
+    * 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;
+}
+/**
+    * 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 declare 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);
+}
+/**
+    * 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 declare 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;
+}
+/**
+    * 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;
+}
+/**
+    * 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 declare 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);
+}