Build

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

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

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

@@ -1,201 +1,163 @@
-
-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.
-     */
-    class AsciiArtFontTexture extends BaseTexture {
-        private _font;
-        private _text;
-        private _charSize;
-        /**
-         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-         */
-        readonly charSize: number;
-        /**
-         * Create a new instance of the Ascii Art FontTexture class
-         * @param name the name of the texture
-         * @param font the font to use, use the W3C CSS notation
-         * @param text the caracter set to use in the rendering.
-         * @param scene the scene that owns the texture
-         */
-        constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
-        /**
-         * Gets the max char width of a font.
-         * @param font the font to use, use the W3C CSS notation
-         * @return the max char width
-         */
-        private getFontWidth;
-        /**
-         * Gets the max char height of a font.
-         * @param font the font to use, use the W3C CSS notation
-         * @return the max char height
-         */
-        private getFontHeight;
-        /**
-         * Clones the current AsciiArtTexture.
-         * @return the clone of the texture.
-         */
-        clone(): AsciiArtFontTexture;
-        /**
-         * Parses a json object representing the texture and returns an instance of it.
-         * @param source the source JSON representation
-         * @param scene the scene to create the texture for
-         * @return the parsed texture
-         */
-        static Parse(source: any, scene: Scene): AsciiArtFontTexture;
-    }
-    /**
-     * Option available in the Ascii Art Post Process.
-     */
-    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);
-     */
-    class AsciiArtPostProcess extends PostProcess {
-        /**
-         * The font texture used to render the char in the post process.
-         */
-        private _asciiArtFontTexture;
-        /**
-         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
-         * This number is defined between 0 and 1;
-         */
-        mixToTile: number;
-        /**
-         * This defines the amount you want to mix the normal rendering pass in the ascii art.
-         * This number is defined between 0 and 1;
-         */
-        mixToNormal: number;
-        /**
-         * Instantiates a new Ascii Art Post Process.
-         * @param name the name to give to the postprocess
-         * @camera the camera to apply the post process to.
-         * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
-         */
-        constructor(name: string, camera: Camera, options?: string | IAsciiArtPostProcessOptions);
-    }
-}
-
-
-declare module 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.
-     */
-    class DigitalRainFontTexture extends BaseTexture {
-        private _font;
-        private _text;
-        private _charSize;
-        /**
-         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-         */
-        readonly charSize: number;
-        /**
-         * Create a new instance of the Digital Rain FontTexture class
-         * @param name the name of the texture
-         * @param font the font to use, use the W3C CSS notation
-         * @param text the caracter set to use in the rendering.
-         * @param scene the scene that owns the texture
-         */
-        constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
-        /**
-         * Gets the max char width of a font.
-         * @param font the font to use, use the W3C CSS notation
-         * @return the max char width
-         */
-        private getFontWidth;
-        /**
-         * Gets the max char height of a font.
-         * @param font the font to use, use the W3C CSS notation
-         * @return the max char height
-         */
-        private getFontHeight;
-        /**
-         * Clones the current DigitalRainFontTexture.
-         * @return the clone of the texture.
-         */
-        clone(): DigitalRainFontTexture;
-        /**
-         * Parses a json object representing the texture and returns an instance of it.
-         * @param source the source JSON representation
-         * @param scene the scene to create the texture for
-         * @return the parsed texture
-         */
-        static Parse(source: any, scene: Scene): DigitalRainFontTexture;
-    }
-    /**
-     * Option available in the Digital Rain Post Process.
-     */
-    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);
-     */
-    class DigitalRainPostProcess extends PostProcess {
-        /**
-         * The font texture used to render the char in the post process.
-         */
-        private _digitalRainFontTexture;
-        /**
-         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
-         * This number is defined between 0 and 1;
-         */
-        mixToTile: number;
-        /**
-         * This defines the amount you want to mix the normal rendering pass in the digital rain.
-         * This number is defined between 0 and 1;
-         */
-        mixToNormal: number;
-        /**
-         * Instantiates a new Digital Rain Post Process.
-         * @param name the name to give to the postprocess
-         * @camera the camera to apply the post process to.
-         * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
-         */
-        constructor(name: string, camera: Camera, options?: string | IDigitalRainPostProcessOptions);
-    }
-}
+/*BabylonJS Postprocess library*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+declare module 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.module.d.ts

@@ -1,206 +1,347 @@
+/*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";
+    import "./asciiart.fragment";
+    /**
+        * AsciiArtFontTexture is the helper class used to easily create your ascii art font texture.
+        *
+        * It basically takes care rendering the font front the given font size to a texture.
+        * This is used later on in the postprocess.
+        */
+    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";
+    import "./digitalrain.fragment";
+    /**
+        * DigitalRainFontTexture is the helper class used to easily create your digital rain font texture.
+        *
+        * It basically takes care rendering the font front the given font size to a texture.
+        * This is used later on in the postprocess.
+        */
+    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);
+    }
+}
+
 
-
-declare module 'babylonjs-post-process' { 
-    export = 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.
-     */
-    class AsciiArtFontTexture extends BaseTexture {
-        private _font;
-        private _text;
-        private _charSize;
-        /**
-         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-         */
-        readonly charSize: number;
-        /**
-         * Create a new instance of the Ascii Art FontTexture class
-         * @param name the name of the texture
-         * @param font the font to use, use the W3C CSS notation
-         * @param text the caracter set to use in the rendering.
-         * @param scene the scene that owns the texture
-         */
-        constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
-        /**
-         * Gets the max char width of a font.
-         * @param font the font to use, use the W3C CSS notation
-         * @return the max char width
-         */
-        private getFontWidth;
-        /**
-         * Gets the max char height of a font.
-         * @param font the font to use, use the W3C CSS notation
-         * @return the max char height
-         */
-        private getFontHeight;
-        /**
-         * Clones the current AsciiArtTexture.
-         * @return the clone of the texture.
-         */
-        clone(): AsciiArtFontTexture;
-        /**
-         * Parses a json object representing the texture and returns an instance of it.
-         * @param source the source JSON representation
-         * @param scene the scene to create the texture for
-         * @return the parsed texture
-         */
-        static Parse(source: any, scene: Scene): AsciiArtFontTexture;
-    }
-    /**
-     * Option available in the Ascii Art Post Process.
-     */
-    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);
-     */
-    class AsciiArtPostProcess extends PostProcess {
-        /**
-         * The font texture used to render the char in the post process.
-         */
-        private _asciiArtFontTexture;
-        /**
-         * This defines the amount you want to mix the "tile" or caracter space colored in the ascii art.
-         * This number is defined between 0 and 1;
-         */
-        mixToTile: number;
-        /**
-         * This defines the amount you want to mix the normal rendering pass in the ascii art.
-         * This number is defined between 0 and 1;
-         */
-        mixToNormal: number;
-        /**
-         * Instantiates a new Ascii Art Post Process.
-         * @param name the name to give to the postprocess
-         * @camera the camera to apply the post process to.
-         * @param options can either be the font name or an option object following the IAsciiArtPostProcessOptions format
-         */
-        constructor(name: string, camera: Camera, options?: string | IAsciiArtPostProcessOptions);
-    }
-}
-
-
-declare module 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.
-     */
-    class DigitalRainFontTexture extends BaseTexture {
-        private _font;
-        private _text;
-        private _charSize;
-        /**
-         * Gets the size of one char in the texture (each char fits in size * size space in the texture).
-         */
-        readonly charSize: number;
-        /**
-         * Create a new instance of the Digital Rain FontTexture class
-         * @param name the name of the texture
-         * @param font the font to use, use the W3C CSS notation
-         * @param text the caracter set to use in the rendering.
-         * @param scene the scene that owns the texture
-         */
-        constructor(name: string, font: string, text: string, scene?: Nullable<Scene>);
-        /**
-         * Gets the max char width of a font.
-         * @param font the font to use, use the W3C CSS notation
-         * @return the max char width
-         */
-        private getFontWidth;
-        /**
-         * Gets the max char height of a font.
-         * @param font the font to use, use the W3C CSS notation
-         * @return the max char height
-         */
-        private getFontHeight;
-        /**
-         * Clones the current DigitalRainFontTexture.
-         * @return the clone of the texture.
-         */
-        clone(): DigitalRainFontTexture;
-        /**
-         * Parses a json object representing the texture and returns an instance of it.
-         * @param source the source JSON representation
-         * @param scene the scene to create the texture for
-         * @return the parsed texture
-         */
-        static Parse(source: any, scene: Scene): DigitalRainFontTexture;
-    }
-    /**
-     * Option available in the Digital Rain Post Process.
-     */
-    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);
-     */
-    class DigitalRainPostProcess extends PostProcess {
-        /**
-         * The font texture used to render the char in the post process.
-         */
-        private _digitalRainFontTexture;
-        /**
-         * This defines the amount you want to mix the "tile" or caracter space colored in the digital rain.
-         * This number is defined between 0 and 1;
-         */
-        mixToTile: number;
-        /**
-         * This defines the amount you want to mix the normal rendering pass in the digital rain.
-         * This number is defined between 0 and 1;
-         */
-        mixToNormal: number;
-        /**
-         * Instantiates a new Digital Rain Post Process.
-         * @param name the name to give to the postprocess
-         * @camera the camera to apply the post process to.
-         * @param options can either be the font name or an option object following the IDigitalRainPostProcessOptions format
-         */
-        constructor(name: string, camera: Camera, options?: string | IDigitalRainPostProcessOptions);
-    }
-}
+/*BabylonJS Postprocess library*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+declare module 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/proceduralTexturesLibrary/babylonjs.proceduralTextures.d.ts

@@ -1,286 +1,237 @@
-
-declare module BABYLON {
-    class WoodProceduralTexture extends ProceduralTexture {
-        private _ampScale;
-        private _woodColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        ampScale: number;
-        woodColor: Color3;
-        /**
-         * Serializes this wood procedural texture
-         * @returns a serialized wood procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Wood Procedural Texture from parsed wood procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing wood procedural texture information
-         * @returns a parsed Wood Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): WoodProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class FireProceduralTexture extends ProceduralTexture {
-        private _time;
-        private _speed;
-        private _autoGenerateTime;
-        private _fireColors;
-        private _alphaThreshold;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        render(useCameraPostProcess?: boolean): void;
-        static readonly PurpleFireColors: Color3[];
-        static readonly GreenFireColors: Color3[];
-        static readonly RedFireColors: Color3[];
-        static readonly BlueFireColors: Color3[];
-        autoGenerateTime: boolean;
-        fireColors: Color3[];
-        time: number;
-        speed: Vector2;
-        alphaThreshold: number;
-        /**
-         * Serializes this fire procedural texture
-         * @returns a serialized fire procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Fire Procedural Texture from parsed fire procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing fire procedural texture information
-         * @returns a parsed Fire Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): FireProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class CloudProceduralTexture extends ProceduralTexture {
-        private _skyColor;
-        private _cloudColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        skyColor: Color4;
-        cloudColor: Color4;
-        /**
-         * Serializes this cloud procedural texture
-         * @returns a serialized cloud procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Cloud Procedural Texture from parsed cloud procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing cloud procedural texture information
-         * @returns a parsed Cloud Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): CloudProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class GrassProceduralTexture extends ProceduralTexture {
-        private _grassColors;
-        private _groundColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        grassColors: Color3[];
-        groundColor: Color3;
-        /**
-         * Serializes this grass procedural texture
-         * @returns a serialized grass procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Grass Procedural Texture from parsed grass procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing grass procedural texture information
-         * @returns a parsed Grass Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): GrassProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class RoadProceduralTexture extends ProceduralTexture {
-        private _roadColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        roadColor: Color3;
-        /**
-         * Serializes this road procedural texture
-         * @returns a serialized road procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Road Procedural Texture from parsed road procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing road procedural texture information
-         * @returns a parsed Road Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): RoadProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class BrickProceduralTexture extends ProceduralTexture {
-        private _numberOfBricksHeight;
-        private _numberOfBricksWidth;
-        private _jointColor;
-        private _brickColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        numberOfBricksHeight: number;
-        numberOfBricksWidth: number;
-        jointColor: Color3;
-        brickColor: Color3;
-        /**
-         * Serializes this brick procedural texture
-         * @returns a serialized brick procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Brick Procedural Texture from parsed brick procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing brick procedural texture information
-         * @returns a parsed Brick Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): BrickProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class MarbleProceduralTexture extends ProceduralTexture {
-        private _numberOfTilesHeight;
-        private _numberOfTilesWidth;
-        private _amplitude;
-        private _jointColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        numberOfTilesHeight: number;
-        amplitude: number;
-        numberOfTilesWidth: number;
-        jointColor: Color3;
-        /**
-         * Serializes this marble procedural texture
-         * @returns a serialized marble procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Marble Procedural Texture from parsed marble procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing marble procedural texture information
-         * @returns a parsed Marble Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): MarbleProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class StarfieldProceduralTexture extends ProceduralTexture {
-        private _time;
-        private _alpha;
-        private _beta;
-        private _zoom;
-        private _formuparam;
-        private _stepsize;
-        private _tile;
-        private _brightness;
-        private _darkmatter;
-        private _distfading;
-        private _saturation;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        time: number;
-        alpha: number;
-        beta: number;
-        formuparam: number;
-        stepsize: number;
-        zoom: number;
-        tile: number;
-        brightness: number;
-        darkmatter: number;
-        distfading: number;
-        saturation: number;
-        /**
-         * Serializes this starfield procedural texture
-         * @returns a serialized starfield procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Starfield Procedural Texture from parsed startfield procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing startfield procedural texture information
-         * @returns a parsed Starfield Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): StarfieldProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class NormalMapProceduralTexture extends ProceduralTexture {
-        private _baseTexture;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        render(useCameraPostProcess?: boolean): void;
-        resize(size: any, generateMipMaps: any): void;
-        baseTexture: Texture;
-        /**
-         * Serializes this normal map procedural texture
-         * @returns a serialized normal map procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing normal map procedural texture information
-         * @returns a parsed Normal Map Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): NormalMapProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class PerlinNoiseProceduralTexture extends ProceduralTexture {
-        time: number;
-        timeScale: number;
-        translationSpeed: number;
-        private _currentTranslation;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        render(useCameraPostProcess?: boolean): void;
-        resize(size: any, generateMipMaps: any): void;
-        /**
-         * Serializes this perlin noise procedural texture
-         * @returns a serialized perlin noise procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Perlin Noise Procedural Texture from parsed perlin noise procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing perlin noise procedural texture information
-         * @returns a parsed Perlin Noise Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): PerlinNoiseProceduralTexture;
-    }
-}
+/*BabylonJS Procedural Textures*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+declare module BABYLON {
+    export class BrickProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            numberOfBricksHeight: number;
+            numberOfBricksWidth: number;
+            jointColor: BABYLON.Color3;
+            brickColor: BABYLON.Color3;
+            /**
+                * Serializes this brick procedural texture
+                * @returns a serialized brick procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Brick Procedural BABYLON.Texture from parsed brick procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing brick procedural texture information
+                * @returns a parsed Brick Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): BrickProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class CloudProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            skyColor: BABYLON.Color4;
+            cloudColor: BABYLON.Color4;
+            /**
+                * Serializes this cloud procedural texture
+                * @returns a serialized cloud procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Cloud Procedural BABYLON.Texture from parsed cloud procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing cloud procedural texture information
+                * @returns a parsed Cloud Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): CloudProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class FireProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            static readonly PurpleFireColors: BABYLON.Color3[];
+            static readonly GreenFireColors: BABYLON.Color3[];
+            static readonly RedFireColors: BABYLON.Color3[];
+            static readonly BlueFireColors: BABYLON.Color3[];
+            autoGenerateTime: boolean;
+            fireColors: BABYLON.Color3[];
+            time: number;
+            speed: BABYLON.Vector2;
+            alphaThreshold: number;
+            /**
+                * Serializes this fire procedural texture
+                * @returns a serialized fire procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Fire Procedural BABYLON.Texture from parsed fire procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing fire procedural texture information
+                * @returns a parsed Fire Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): FireProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class GrassProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            grassColors: BABYLON.Color3[];
+            groundColor: BABYLON.Color3;
+            /**
+                * Serializes this grass procedural texture
+                * @returns a serialized grass procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Grass Procedural BABYLON.Texture from parsed grass procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing grass procedural texture information
+                * @returns a parsed Grass Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): GrassProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class MarbleProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            numberOfTilesHeight: number;
+            amplitude: number;
+            numberOfTilesWidth: number;
+            jointColor: BABYLON.Color3;
+            /**
+                * Serializes this marble procedural texture
+                * @returns a serialized marble procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Marble Procedural BABYLON.Texture from parsed marble procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing marble procedural texture information
+                * @returns a parsed Marble Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): MarbleProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class NormalMapProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            resize(size: any, generateMipMaps: any): void;
+            baseTexture: BABYLON.Texture;
+            /**
+                * Serializes this normal map procedural texture
+                * @returns a serialized normal map procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Normal Map Procedural BABYLON.Texture from parsed normal map procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing normal map procedural texture information
+                * @returns a parsed Normal Map Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): NormalMapProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class PerlinNoiseProceduralTexture extends BABYLON.ProceduralTexture {
+            time: number;
+            timeScale: number;
+            translationSpeed: number;
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            resize(size: any, generateMipMaps: any): void;
+            /**
+                * Serializes this perlin noise procedural texture
+                * @returns a serialized perlin noise procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Perlin Noise Procedural BABYLON.Texture from parsed perlin noise procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing perlin noise procedural texture information
+                * @returns a parsed Perlin Noise Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): PerlinNoiseProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class RoadProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            roadColor: BABYLON.Color3;
+            /**
+                * Serializes this road procedural texture
+                * @returns a serialized road procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Road Procedural BABYLON.Texture from parsed road procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing road procedural texture information
+                * @returns a parsed Road Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): RoadProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class StarfieldProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            time: number;
+            alpha: number;
+            beta: number;
+            formuparam: number;
+            stepsize: number;
+            zoom: number;
+            tile: number;
+            brightness: number;
+            darkmatter: number;
+            distfading: number;
+            saturation: number;
+            /**
+                * Serializes this starfield procedural texture
+                * @returns a serialized starfield procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Starfield Procedural BABYLON.Texture from parsed startfield procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing startfield procedural texture information
+                * @returns a parsed Starfield Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): StarfieldProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class WoodProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            ampScale: number;
+            woodColor: BABYLON.Color3;
+            /**
+                * Serializes this wood procedural texture
+                * @returns a serialized wood procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Wood Procedural BABYLON.Texture from parsed wood procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing wood procedural texture information
+                * @returns a parsed Wood Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): WoodProceduralTexture;
+    }
+}

dist/preview release/proceduralTexturesLibrary/babylonjs.proceduralTextures.module.d.ts

@@ -1,291 +1,559 @@
+/*BabylonJS Procedural Textures*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+
+declare module 'babylonjs-procedural-textures' {
+    export * from "babylonjs-procedural-textures/src/brick";
+    export * from "babylonjs-procedural-textures/src/cloud";
+    export * from "babylonjs-procedural-textures/src/fire";
+    export * from "babylonjs-procedural-textures/src/grass";
+    export * from "babylonjs-procedural-textures/src/marble";
+    export * from "babylonjs-procedural-textures/src/normalMap";
+    export * from "babylonjs-procedural-textures/src/perlinNoise";
+    export * from "babylonjs-procedural-textures/src/road";
+    export * from "babylonjs-procedural-textures/src/starfield";
+    export * from "babylonjs-procedural-textures/src/wood";
+}
+
+declare module 'babylonjs-procedural-textures/src/brick' {
+    export * from "babylonjs-procedural-textures/src/brick/brickProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/cloud' {
+    export * from "babylonjs-procedural-textures/src/cloud/cloudProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/fire' {
+    export * from "babylonjs-procedural-textures/src/fire/fireProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/grass' {
+    export * from "babylonjs-procedural-textures/src/grass/grassProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/marble' {
+    export * from "babylonjs-procedural-textures/src/marble/marbleProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/normalMap' {
+    export * from "babylonjs-procedural-textures/src/normalMap/normalMapProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/perlinNoise' {
+    export * from "babylonjs-procedural-textures/src/perlinNoise/perlinNoiseProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/road' {
+    export * from "babylonjs-procedural-textures/src/road/roadProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/starfield' {
+    export * from "babylonjs-procedural-textures/src/starfield/starfieldProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/wood' {
+    export * from "babylonjs-procedural-textures/src/wood/woodProceduralTexture";
+}
+
+declare module 'babylonjs-procedural-textures/src/brick/brickProceduralTexture' {
+    import { ProceduralTexture, Color3, Scene, Texture } from "babylonjs";
+    import "./brickProceduralTexture.fragment";
+    export class BrickProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            numberOfBricksHeight: number;
+            numberOfBricksWidth: number;
+            jointColor: Color3;
+            brickColor: Color3;
+            /**
+                * Serializes this brick procedural texture
+                * @returns a serialized brick procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Brick Procedural Texture from parsed brick procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing brick procedural texture information
+                * @returns a parsed Brick Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): BrickProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/cloud/cloudProceduralTexture' {
+    import { ProceduralTexture, Color4, Scene, Texture } from "babylonjs";
+    import "./cloudProceduralTexture.fragment";
+    export class CloudProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            skyColor: Color4;
+            cloudColor: Color4;
+            /**
+                * Serializes this cloud procedural texture
+                * @returns a serialized cloud procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Cloud Procedural Texture from parsed cloud procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing cloud procedural texture information
+                * @returns a parsed Cloud Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): CloudProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/fire/fireProceduralTexture' {
+    import { ProceduralTexture, Vector2, Color3, Scene, Texture } from "babylonjs";
+    import "./fireProceduralTexture.fragment";
+    export class FireProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            static readonly PurpleFireColors: Color3[];
+            static readonly GreenFireColors: Color3[];
+            static readonly RedFireColors: Color3[];
+            static readonly BlueFireColors: Color3[];
+            autoGenerateTime: boolean;
+            fireColors: Color3[];
+            time: number;
+            speed: Vector2;
+            alphaThreshold: number;
+            /**
+                * Serializes this fire procedural texture
+                * @returns a serialized fire procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Fire Procedural Texture from parsed fire procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing fire procedural texture information
+                * @returns a parsed Fire Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): FireProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/grass/grassProceduralTexture' {
+    import { ProceduralTexture, Color3, Scene, Texture } from "babylonjs";
+    import "./grassProceduralTexture.fragment";
+    export class GrassProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            grassColors: Color3[];
+            groundColor: Color3;
+            /**
+                * Serializes this grass procedural texture
+                * @returns a serialized grass procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Grass Procedural Texture from parsed grass procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing grass procedural texture information
+                * @returns a parsed Grass Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): GrassProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/marble/marbleProceduralTexture' {
+    import { ProceduralTexture, Color3, Scene, Texture } from "babylonjs";
+    import "./marbleProceduralTexture.fragment";
+    export class MarbleProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            numberOfTilesHeight: number;
+            amplitude: number;
+            numberOfTilesWidth: number;
+            jointColor: Color3;
+            /**
+                * Serializes this marble procedural texture
+                * @returns a serialized marble procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Marble Procedural Texture from parsed marble procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing marble procedural texture information
+                * @returns a parsed Marble Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): MarbleProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/normalMap/normalMapProceduralTexture' {
+    import { ProceduralTexture, Texture, Scene } from "babylonjs";
+    import "./normalMapProceduralTexture.fragment";
+    export class NormalMapProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            resize(size: any, generateMipMaps: any): void;
+            baseTexture: Texture;
+            /**
+                * Serializes this normal map procedural texture
+                * @returns a serialized normal map procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing normal map procedural texture information
+                * @returns a parsed Normal Map Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): NormalMapProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/perlinNoise/perlinNoiseProceduralTexture' {
+    import { ProceduralTexture, Scene, Texture } from "babylonjs";
+    import "./perlinNoiseProceduralTexture.fragment";
+    export class PerlinNoiseProceduralTexture extends ProceduralTexture {
+            time: number;
+            timeScale: number;
+            translationSpeed: number;
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            resize(size: any, generateMipMaps: any): void;
+            /**
+                * Serializes this perlin noise procedural texture
+                * @returns a serialized perlin noise procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Perlin Noise Procedural Texture from parsed perlin noise procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing perlin noise procedural texture information
+                * @returns a parsed Perlin Noise Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): PerlinNoiseProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/road/roadProceduralTexture' {
+    import { ProceduralTexture, Color3, Scene, Texture } from "babylonjs";
+    import "./roadProceduralTexture.fragment";
+    export class RoadProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            roadColor: Color3;
+            /**
+                * Serializes this road procedural texture
+                * @returns a serialized road procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Road Procedural Texture from parsed road procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing road procedural texture information
+                * @returns a parsed Road Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): RoadProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/starfield/starfieldProceduralTexture' {
+    import { ProceduralTexture, Scene, Texture } from "babylonjs";
+    import "./starfieldProceduralTexture.fragment";
+    export class StarfieldProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            time: number;
+            alpha: number;
+            beta: number;
+            formuparam: number;
+            stepsize: number;
+            zoom: number;
+            tile: number;
+            brightness: number;
+            darkmatter: number;
+            distfading: number;
+            saturation: number;
+            /**
+                * Serializes this starfield procedural texture
+                * @returns a serialized starfield procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Starfield Procedural Texture from parsed startfield procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing startfield procedural texture information
+                * @returns a parsed Starfield Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): StarfieldProceduralTexture;
+    }
+}
+
+declare module 'babylonjs-procedural-textures/src/wood/woodProceduralTexture' {
+    import { ProceduralTexture, Color3, Scene, Texture } from "babylonjs";
+    import "./woodProceduralTexture.fragment";
+    export class WoodProceduralTexture extends ProceduralTexture {
+            constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            ampScale: number;
+            woodColor: Color3;
+            /**
+                * Serializes this wood procedural texture
+                * @returns a serialized wood procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Wood Procedural Texture from parsed wood procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing wood procedural texture information
+                * @returns a parsed Wood Procedural Texture
+                */
+            static Parse(parsedTexture: any, scene: Scene, rootUrl: string): WoodProceduralTexture;
+    }
+}
+
 
-
-declare module 'babylonjs-procedural-textures' { 
-    export = BABYLON; 
-}
-
-declare module BABYLON {
-    class WoodProceduralTexture extends ProceduralTexture {
-        private _ampScale;
-        private _woodColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        ampScale: number;
-        woodColor: Color3;
-        /**
-         * Serializes this wood procedural texture
-         * @returns a serialized wood procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Wood Procedural Texture from parsed wood procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing wood procedural texture information
-         * @returns a parsed Wood Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): WoodProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class FireProceduralTexture extends ProceduralTexture {
-        private _time;
-        private _speed;
-        private _autoGenerateTime;
-        private _fireColors;
-        private _alphaThreshold;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        render(useCameraPostProcess?: boolean): void;
-        static readonly PurpleFireColors: Color3[];
-        static readonly GreenFireColors: Color3[];
-        static readonly RedFireColors: Color3[];
-        static readonly BlueFireColors: Color3[];
-        autoGenerateTime: boolean;
-        fireColors: Color3[];
-        time: number;
-        speed: Vector2;
-        alphaThreshold: number;
-        /**
-         * Serializes this fire procedural texture
-         * @returns a serialized fire procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Fire Procedural Texture from parsed fire procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing fire procedural texture information
-         * @returns a parsed Fire Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): FireProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class CloudProceduralTexture extends ProceduralTexture {
-        private _skyColor;
-        private _cloudColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        skyColor: Color4;
-        cloudColor: Color4;
-        /**
-         * Serializes this cloud procedural texture
-         * @returns a serialized cloud procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Cloud Procedural Texture from parsed cloud procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing cloud procedural texture information
-         * @returns a parsed Cloud Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): CloudProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class GrassProceduralTexture extends ProceduralTexture {
-        private _grassColors;
-        private _groundColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        grassColors: Color3[];
-        groundColor: Color3;
-        /**
-         * Serializes this grass procedural texture
-         * @returns a serialized grass procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Grass Procedural Texture from parsed grass procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing grass procedural texture information
-         * @returns a parsed Grass Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): GrassProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class RoadProceduralTexture extends ProceduralTexture {
-        private _roadColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        roadColor: Color3;
-        /**
-         * Serializes this road procedural texture
-         * @returns a serialized road procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Road Procedural Texture from parsed road procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing road procedural texture information
-         * @returns a parsed Road Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): RoadProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class BrickProceduralTexture extends ProceduralTexture {
-        private _numberOfBricksHeight;
-        private _numberOfBricksWidth;
-        private _jointColor;
-        private _brickColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        numberOfBricksHeight: number;
-        numberOfBricksWidth: number;
-        jointColor: Color3;
-        brickColor: Color3;
-        /**
-         * Serializes this brick procedural texture
-         * @returns a serialized brick procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Brick Procedural Texture from parsed brick procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing brick procedural texture information
-         * @returns a parsed Brick Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): BrickProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class MarbleProceduralTexture extends ProceduralTexture {
-        private _numberOfTilesHeight;
-        private _numberOfTilesWidth;
-        private _amplitude;
-        private _jointColor;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        numberOfTilesHeight: number;
-        amplitude: number;
-        numberOfTilesWidth: number;
-        jointColor: Color3;
-        /**
-         * Serializes this marble procedural texture
-         * @returns a serialized marble procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Marble Procedural Texture from parsed marble procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing marble procedural texture information
-         * @returns a parsed Marble Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): MarbleProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class StarfieldProceduralTexture extends ProceduralTexture {
-        private _time;
-        private _alpha;
-        private _beta;
-        private _zoom;
-        private _formuparam;
-        private _stepsize;
-        private _tile;
-        private _brightness;
-        private _darkmatter;
-        private _distfading;
-        private _saturation;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        time: number;
-        alpha: number;
-        beta: number;
-        formuparam: number;
-        stepsize: number;
-        zoom: number;
-        tile: number;
-        brightness: number;
-        darkmatter: number;
-        distfading: number;
-        saturation: number;
-        /**
-         * Serializes this starfield procedural texture
-         * @returns a serialized starfield procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Starfield Procedural Texture from parsed startfield procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing startfield procedural texture information
-         * @returns a parsed Starfield Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): StarfieldProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class NormalMapProceduralTexture extends ProceduralTexture {
-        private _baseTexture;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        render(useCameraPostProcess?: boolean): void;
-        resize(size: any, generateMipMaps: any): void;
-        baseTexture: Texture;
-        /**
-         * Serializes this normal map procedural texture
-         * @returns a serialized normal map procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Normal Map Procedural Texture from parsed normal map procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing normal map procedural texture information
-         * @returns a parsed Normal Map Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): NormalMapProceduralTexture;
-    }
-}
-
-
-declare module BABYLON {
-    class PerlinNoiseProceduralTexture extends ProceduralTexture {
-        time: number;
-        timeScale: number;
-        translationSpeed: number;
-        private _currentTranslation;
-        constructor(name: string, size: number, scene: Scene, fallbackTexture?: Texture, generateMipMaps?: boolean);
-        updateShaderUniforms(): void;
-        render(useCameraPostProcess?: boolean): void;
-        resize(size: any, generateMipMaps: any): void;
-        /**
-         * Serializes this perlin noise procedural texture
-         * @returns a serialized perlin noise procedural texture object
-         */
-        serialize(): any;
-        /**
-         * Creates a Perlin Noise Procedural Texture from parsed perlin noise procedural texture data
-         * @param parsedTexture defines parsed texture data
-         * @param scene defines the current scene
-         * @param rootUrl defines the root URL containing perlin noise procedural texture information
-         * @returns a parsed Perlin Noise Procedural Texture
-         */
-        static Parse(parsedTexture: any, scene: Scene, rootUrl: string): PerlinNoiseProceduralTexture;
-    }
-}
+/*BabylonJS Procedural Textures*/
+// Dependencies for this module:
+//   ../../../../Tools/Gulp/babylonjs
+declare module BABYLON {
+    export class BrickProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            numberOfBricksHeight: number;
+            numberOfBricksWidth: number;
+            jointColor: BABYLON.Color3;
+            brickColor: BABYLON.Color3;
+            /**
+                * Serializes this brick procedural texture
+                * @returns a serialized brick procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Brick Procedural BABYLON.Texture from parsed brick procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing brick procedural texture information
+                * @returns a parsed Brick Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): BrickProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class CloudProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            skyColor: BABYLON.Color4;
+            cloudColor: BABYLON.Color4;
+            /**
+                * Serializes this cloud procedural texture
+                * @returns a serialized cloud procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Cloud Procedural BABYLON.Texture from parsed cloud procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing cloud procedural texture information
+                * @returns a parsed Cloud Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): CloudProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class FireProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            static readonly PurpleFireColors: BABYLON.Color3[];
+            static readonly GreenFireColors: BABYLON.Color3[];
+            static readonly RedFireColors: BABYLON.Color3[];
+            static readonly BlueFireColors: BABYLON.Color3[];
+            autoGenerateTime: boolean;
+            fireColors: BABYLON.Color3[];
+            time: number;
+            speed: BABYLON.Vector2;
+            alphaThreshold: number;
+            /**
+                * Serializes this fire procedural texture
+                * @returns a serialized fire procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Fire Procedural BABYLON.Texture from parsed fire procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing fire procedural texture information
+                * @returns a parsed Fire Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): FireProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class GrassProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            grassColors: BABYLON.Color3[];
+            groundColor: BABYLON.Color3;
+            /**
+                * Serializes this grass procedural texture
+                * @returns a serialized grass procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Grass Procedural BABYLON.Texture from parsed grass procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing grass procedural texture information
+                * @returns a parsed Grass Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): GrassProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class MarbleProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            numberOfTilesHeight: number;
+            amplitude: number;
+            numberOfTilesWidth: number;
+            jointColor: BABYLON.Color3;
+            /**
+                * Serializes this marble procedural texture
+                * @returns a serialized marble procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Marble Procedural BABYLON.Texture from parsed marble procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing marble procedural texture information
+                * @returns a parsed Marble Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): MarbleProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class NormalMapProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            resize(size: any, generateMipMaps: any): void;
+            baseTexture: BABYLON.Texture;
+            /**
+                * Serializes this normal map procedural texture
+                * @returns a serialized normal map procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Normal Map Procedural BABYLON.Texture from parsed normal map procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing normal map procedural texture information
+                * @returns a parsed Normal Map Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): NormalMapProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class PerlinNoiseProceduralTexture extends BABYLON.ProceduralTexture {
+            time: number;
+            timeScale: number;
+            translationSpeed: number;
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            render(useCameraPostProcess?: boolean): void;
+            resize(size: any, generateMipMaps: any): void;
+            /**
+                * Serializes this perlin noise procedural texture
+                * @returns a serialized perlin noise procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Perlin Noise Procedural BABYLON.Texture from parsed perlin noise procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing perlin noise procedural texture information
+                * @returns a parsed Perlin Noise Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): PerlinNoiseProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class RoadProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            roadColor: BABYLON.Color3;
+            /**
+                * Serializes this road procedural texture
+                * @returns a serialized road procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Road Procedural BABYLON.Texture from parsed road procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing road procedural texture information
+                * @returns a parsed Road Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): RoadProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class StarfieldProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            time: number;
+            alpha: number;
+            beta: number;
+            formuparam: number;
+            stepsize: number;
+            zoom: number;
+            tile: number;
+            brightness: number;
+            darkmatter: number;
+            distfading: number;
+            saturation: number;
+            /**
+                * Serializes this starfield procedural texture
+                * @returns a serialized starfield procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Starfield Procedural BABYLON.Texture from parsed startfield procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing startfield procedural texture information
+                * @returns a parsed Starfield Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): StarfieldProceduralTexture;
+    }
+}
+declare module BABYLON {
+    export class WoodProceduralTexture extends BABYLON.ProceduralTexture {
+            constructor(name: string, size: number, scene: BABYLON.Scene, fallbackTexture?: BABYLON.Texture, generateMipMaps?: boolean);
+            updateShaderUniforms(): void;
+            ampScale: number;
+            woodColor: BABYLON.Color3;
+            /**
+                * Serializes this wood procedural texture
+                * @returns a serialized wood procedural texture object
+                */
+            serialize(): any;
+            /**
+                * Creates a Wood Procedural BABYLON.Texture from parsed wood procedural texture data
+                * @param parsedTexture defines parsed texture data
+                * @param scene defines the current scene
+                * @param rootUrl defines the root URL containing wood procedural texture information
+                * @returns a parsed Wood Procedural BABYLON.Texture
+                */
+            static Parse(parsedTexture: any, scene: BABYLON.Scene, rootUrl: string): WoodProceduralTexture;
+    }
+}

dist/preview release/serializers/babylon.glTF2Serializer.js

@@ -201,7 +201,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
 var glTFExporter_1 = __webpack_require__(/*! ../glTFExporter */ "./src/glTF/2.0/glTFExporter.ts");
 var NAME = "KHR_texture_transform";
-babylonjs_1.Effect.ShadersStore["textureTransformPixelShader"] = __webpack_require__(/*! ../shaders/textureTransform.fragment.fx */ "./src/glTF/2.0/shaders/textureTransform.fragment.fx");
+__webpack_require__(/*! ../shaders/textureTransform.fragment */ "./src/glTF/2.0/shaders/textureTransform.fragment.ts");
 /**
  * @hidden
  */
@@ -3816,14 +3816,23 @@ __export(__webpack_require__(/*! ./Extensions */ "./src/glTF/2.0/Extensions/inde
 
 /***/ }),
 
-/***/ "./src/glTF/2.0/shaders/textureTransform.fragment.fx":
+/***/ "./src/glTF/2.0/shaders/textureTransform.fragment.ts":
 /*!***********************************************************!*\
-  !*** ./src/glTF/2.0/shaders/textureTransform.fragment.fx ***!
+  !*** ./src/glTF/2.0/shaders/textureTransform.fragment.ts ***!
   \***********************************************************/
 /*! no static exports found */
-/***/ (function(module, exports) {
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
+var name = 'textureTransformPixelShader';
+exports.name = name;
+var shader = "precision highp float;\nvarying vec2 vUV;\nuniform sampler2D textureSampler;\nuniform mat4 textureTransformMat;\nvoid main(void) {\nvec2 uvTransformed=(textureTransformMat*vec4(vUV.xy,1,1)).xy;\ngl_FragColor=texture2D(textureSampler,uvTransformed);\n}";
+exports.shader = shader;
+babylonjs_1.Effect.ShadersStore[name] = shader;
 
-module.exports = "precision highp float;\nvarying vec2 vUV;\nuniform sampler2D textureSampler;\nuniform mat4 textureTransformMat;\nvoid main(void) {\nvec2 uvTransformed=(textureTransformMat*vec4(vUV.xy,1,1)).xy;\ngl_FragColor=texture2D(textureSampler,uvTransformed);\n}"
 
 /***/ }),
 

dist/preview release/serializers/babylon.glTF2Serializer.min.js

@@ -201,7 +201,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
 var glTFExporter_1 = __webpack_require__(/*! ../glTFExporter */ "./src/glTF/2.0/glTFExporter.ts");
 var NAME = "KHR_texture_transform";
-babylonjs_1.Effect.ShadersStore["textureTransformPixelShader"] = __webpack_require__(/*! ../shaders/textureTransform.fragment.fx */ "./src/glTF/2.0/shaders/textureTransform.fragment.fx");
+__webpack_require__(/*! ../shaders/textureTransform.fragment */ "./src/glTF/2.0/shaders/textureTransform.fragment.ts");
 /**
  * @hidden
  */
@@ -3816,14 +3816,23 @@ __export(__webpack_require__(/*! ./Extensions */ "./src/glTF/2.0/Extensions/inde
 
 /***/ }),
 
-/***/ "./src/glTF/2.0/shaders/textureTransform.fragment.fx":
+/***/ "./src/glTF/2.0/shaders/textureTransform.fragment.ts":
 /*!***********************************************************!*\
-  !*** ./src/glTF/2.0/shaders/textureTransform.fragment.fx ***!
+  !*** ./src/glTF/2.0/shaders/textureTransform.fragment.ts ***!
   \***********************************************************/
 /*! no static exports found */
-/***/ (function(module, exports) {
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
+var name = 'textureTransformPixelShader';
+exports.name = name;
+var shader = "precision highp float;\nvarying vec2 vUV;\nuniform sampler2D textureSampler;\nuniform mat4 textureTransformMat;\nvoid main(void) {\nvec2 uvTransformed=(textureTransformMat*vec4(vUV.xy,1,1)).xy;\ngl_FragColor=texture2D(textureSampler,uvTransformed);\n}";
+exports.shader = shader;
+babylonjs_1.Effect.ShadersStore[name] = shader;
 
-module.exports = "precision highp float;\nvarying vec2 vUV;\nuniform sampler2D textureSampler;\nuniform mat4 textureTransformMat;\nvoid main(void) {\nvec2 uvTransformed=(textureTransformMat*vec4(vUV.xy,1,1)).xy;\ngl_FragColor=texture2D(textureSampler,uvTransformed);\n}"
 
 /***/ }),
 

dist/preview release/serializers/babylon.objSerializer.js

@@ -1,135 +1,349 @@
-/// <reference path="../../../dist/preview release/babylon.d.ts"/>
-var BABYLON;
-(function (BABYLON) {
-    var OBJExport = /** @class */ (function () {
-        function OBJExport() {
-        }
-        //Exports the geometry of a Mesh array in .OBJ file format (text)
-        OBJExport.OBJ = function (mesh, materials, matlibname, globalposition) {
-            var output = [];
-            var v = 1;
-            if (materials) {
-                if (!matlibname) {
-                    matlibname = 'mat';
-                }
-                output.push("mtllib " + matlibname + ".mtl");
-            }
-            for (var j = 0; j < mesh.length; j++) {
-                output.push("g object" + j);
-                output.push("o object_" + j);
-                //Uses the position of the item in the scene, to the file (this back to normal in the end)
-                var lastMatrix = null;
-                if (globalposition) {
-                    var newMatrix = BABYLON.Matrix.Translation(mesh[j].position.x, mesh[j].position.y, mesh[j].position.z);
-                    lastMatrix = BABYLON.Matrix.Translation(-(mesh[j].position.x), -(mesh[j].position.y), -(mesh[j].position.z));
-                    mesh[j].bakeTransformIntoVertices(newMatrix);
-                }
-                //TODO: submeshes (groups)
-                //TODO: smoothing groups (s 1, s off);
-                if (materials) {
-                    var mat = mesh[j].material;
-                    if (mat) {
-                        output.push("usemtl " + mat.id);
-                    }
-                }
-                var g = mesh[j].geometry;
-                if (!g) {
-                    BABYLON.Tools.Warn("No geometry is present on the mesh");
-                    continue;
-                }
-                var trunkVerts = g.getVerticesData('position');
-                var trunkNormals = g.getVerticesData('normal');
-                var trunkUV = g.getVerticesData('uv');
-                var trunkFaces = g.getIndices();
-                var curV = 0;
-                if (!trunkVerts || !trunkFaces) {
-                    BABYLON.Tools.Warn("There are no position vertices or indices on the mesh!");
-                    continue;
-                }
-                for (var i = 0; i < trunkVerts.length; i += 3) {
-                    output.push("v " + trunkVerts[i] + " " + trunkVerts[i + 1] + " " + trunkVerts[i + 2]);
-                    curV++;
-                }
-                if (trunkNormals != null) {
-                    for (i = 0; i < trunkNormals.length; i += 3) {
-                        output.push("vn " + trunkNormals[i] + " " + trunkNormals[i + 1] + " " + trunkNormals[i + 2]);
-                    }
-                }
-                if (trunkUV != null) {
-                    for (i = 0; i < trunkUV.length; i += 2) {
-                        output.push("vt " + trunkUV[i] + " " + trunkUV[i + 1]);
-                    }
-                }
-                for (i = 0; i < trunkFaces.length; i += 3) {
-                    var indices = [String(trunkFaces[i + 2] + v), String(trunkFaces[i + 1] + v), String(trunkFaces[i] + v)];
-                    var blanks = ["", "", ""];
-                    var facePositions = indices;
-                    var faceUVs = trunkUV != null ? indices : blanks;
-                    var faceNormals = trunkNormals != null ? indices : blanks;
-                    output.push("f " + facePositions[0] + "/" + faceUVs[0] + "/" + faceNormals[0] +
-                        " " + facePositions[1] + "/" + faceUVs[1] + "/" + faceNormals[1] +
-                        " " + facePositions[2] + "/" + faceUVs[2] + "/" + faceNormals[2]);
-                }
-                //back de previous matrix, to not change the original mesh in the scene
-                if (globalposition && lastMatrix) {
-                    mesh[j].bakeTransformIntoVertices(lastMatrix);
-                }
-                v += curV;
-            }
-            var text = output.join("\n");
-            return (text);
-        };
-        //Exports the material(s) of a mesh in .MTL file format (text)
-        //TODO: Export the materials of mesh array
-        OBJExport.MTL = function (mesh) {
-            var output = [];
-            var m = mesh.material;
-            output.push("newmtl mat1");
-            output.push("  Ns " + m.specularPower.toFixed(4));
-            output.push("  Ni 1.5000");
-            output.push("  d " + m.alpha.toFixed(4));
-            output.push("  Tr 0.0000");
-            output.push("  Tf 1.0000 1.0000 1.0000");
-            output.push("  illum 2");
-            output.push("  Ka " + m.ambientColor.r.toFixed(4) + " " + m.ambientColor.g.toFixed(4) + " " + m.ambientColor.b.toFixed(4));
-            output.push("  Kd " + m.diffuseColor.r.toFixed(4) + " " + m.diffuseColor.g.toFixed(4) + " " + m.diffuseColor.b.toFixed(4));
-            output.push("  Ks " + m.specularColor.r.toFixed(4) + " " + m.specularColor.g.toFixed(4) + " " + m.specularColor.b.toFixed(4));
-            output.push("  Ke " + m.emissiveColor.r.toFixed(4) + " " + m.emissiveColor.g.toFixed(4) + " " + m.emissiveColor.b.toFixed(4));
-            //TODO: uv scale, offset, wrap
-            //TODO: UV mirrored in Blender? second UV channel? lightMap? reflection textures?
-            var uvscale = "";
-            if (m.ambientTexture) {
-                output.push("  map_Ka " + uvscale + m.ambientTexture.name);
-            }
-            if (m.diffuseTexture) {
-                output.push("  map_Kd " + uvscale + m.diffuseTexture.name);
-                //TODO: alpha testing, opacity in diffuse texture alpha channel (diffuseTexture.hasAlpha -> map_d)
-            }
-            if (m.specularTexture) {
-                output.push("  map_Ks " + uvscale + m.specularTexture.name);
-                /* TODO: glossiness = specular highlight component is in alpha channel of specularTexture. (???)
-                if (m.useGlossinessFromSpecularMapAlpha)  {
-                    output.push("  map_Ns "+uvscale + m.specularTexture.name);
-                }
-                */
-            }
-            /* TODO: emissive texture not in .MAT format (???)
-            if (m.emissiveTexture) {
-                output.push("  map_d "+uvscale+m.emissiveTexture.name);
-            }
-            */
-            if (m.bumpTexture) {
-                output.push("  map_bump -imfchan z " + uvscale + m.bumpTexture.name);
-            }
-            if (m.opacityTexture) {
-                output.push("  map_d " + uvscale + m.opacityTexture.name);
-            }
-            var text = output.join("\n");
-            return (text);
-        };
-        return OBJExport;
-    }());
-    BABYLON.OBJExport = OBJExport;
-})(BABYLON || (BABYLON = {}));
-
-//# sourceMappingURL=babylon.objSerializer.js.map
+(function webpackUniversalModuleDefinition(root, factory) {
+	if(typeof exports === 'object' && typeof module === 'object')
+		module.exports = factory(require("babylonjs"));
+	else if(typeof define === 'function' && define.amd)
+		define("babylonjs-serializers", ["babylonjs"], factory);
+	else if(typeof exports === 'object')
+		exports["babylonjs-serializers"] = factory(require("babylonjs"));
+	else
+		root["SERIALIZERS"] = 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-objSerializer.ts");
+/******/ })
+/************************************************************************/
+/******/ ({
+
+/***/ "../node_modules/webpack/buildin/global.js":
+/*!*************************************************!*\
+  !*** ../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-objSerializer.ts":
+/*!****************************************!*\
+  !*** ./legacy/legacy-objSerializer.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 Serializers = __webpack_require__(/*! ../src/OBJ */ "./src/OBJ/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 serializer in Serializers) {
+        globalObject.BABYLON[serializer] = Serializers[serializer];
+    }
+}
+__export(__webpack_require__(/*! ../src/OBJ */ "./src/OBJ/index.ts"));
+
+/* WEBPACK VAR INJECTION */}.call(this, __webpack_require__(/*! ./../../node_modules/webpack/buildin/global.js */ "../node_modules/webpack/buildin/global.js")))
+
+/***/ }),
+
+/***/ "./src/OBJ/index.ts":
+/*!**************************!*\
+  !*** ./src/OBJ/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__(/*! ./objSerializer */ "./src/OBJ/objSerializer.ts"));
+
+
+/***/ }),
+
+/***/ "./src/OBJ/objSerializer.ts":
+/*!**********************************!*\
+  !*** ./src/OBJ/objSerializer.ts ***!
+  \**********************************/
+/*! no static exports found */
+/***/ (function(module, exports, __webpack_require__) {
+
+"use strict";
+
+Object.defineProperty(exports, "__esModule", { value: true });
+var babylonjs_1 = __webpack_require__(/*! babylonjs */ "babylonjs");
+/**
+ * Class for generating OBJ data from a Babylon scene.
+ */
+var OBJExport = /** @class */ (function () {
+    function OBJExport() {
+    }
+    /**
+     * Exports the geometry of a Mesh array in .OBJ file format (text)
+     * @param mesh defines the list of meshes to serialize
+     * @param materials defines if materials should be exported
+     * @param matlibname defines the name of the associated mtl file
+     * @param globalposition defines if the exported positions are globals or local to the exported mesh
+     * @returns the OBJ content
+     */
+    OBJExport.OBJ = function (mesh, materials, matlibname, globalposition) {
+        var output = [];
+        var v = 1;
+        if (materials) {
+            if (!matlibname) {
+                matlibname = 'mat';
+            }
+            output.push("mtllib " + matlibname + ".mtl");
+        }
+        for (var j = 0; j < mesh.length; j++) {
+            output.push("g object" + j);
+            output.push("o object_" + j);
+            //Uses the position of the item in the scene, to the file (this back to normal in the end)
+            var lastMatrix = null;
+            if (globalposition) {
+                var newMatrix = BABYLON.Matrix.Translation(mesh[j].position.x, mesh[j].position.y, mesh[j].position.z);
+                lastMatrix = BABYLON.Matrix.Translation(-(mesh[j].position.x), -(mesh[j].position.y), -(mesh[j].position.z));
+                mesh[j].bakeTransformIntoVertices(newMatrix);
+            }
+            //TODO: submeshes (groups)
+            //TODO: smoothing groups (s 1, s off);
+            if (materials) {
+                var mat = mesh[j].material;
+                if (mat) {
+                    output.push("usemtl " + mat.id);
+                }
+            }
+            var g = mesh[j].geometry;
+            if (!g) {
+                babylonjs_1.Tools.Warn("No geometry is present on the mesh");
+                continue;
+            }
+            var trunkVerts = g.getVerticesData('position');
+            var trunkNormals = g.getVerticesData('normal');
+            var trunkUV = g.getVerticesData('uv');
+            var trunkFaces = g.getIndices();
+            var curV = 0;
+            if (!trunkVerts || !trunkFaces) {
+                babylonjs_1.Tools.Warn("There are no position vertices or indices on the mesh!");
+                continue;
+            }
+            for (var i = 0; i < trunkVerts.length; i += 3) {
+                output.push("v " + trunkVerts[i] + " " + trunkVerts[i + 1] + " " + trunkVerts[i + 2]);
+                curV++;
+            }
+            if (trunkNormals != null) {
+                for (i = 0; i < trunkNormals.length; i += 3) {
+                    output.push("vn " + trunkNormals[i] + " " + trunkNormals[i + 1] + " " + trunkNormals[i + 2]);
+                }
+            }
+            if (trunkUV != null) {
+                for (i = 0; i < trunkUV.length; i += 2) {
+                    output.push("vt " + trunkUV[i] + " " + trunkUV[i + 1]);
+                }
+            }
+            for (i = 0; i < trunkFaces.length; i += 3) {
+                var indices = [String(trunkFaces[i + 2] + v), String(trunkFaces[i + 1] + v), String(trunkFaces[i] + v)];
+                var blanks = ["", "", ""];
+                var facePositions = indices;
+                var faceUVs = trunkUV != null ? indices : blanks;
+                var faceNormals = trunkNormals != null ? indices : blanks;
+                output.push("f " + facePositions[0] + "/" + faceUVs[0] + "/" + faceNormals[0] +
+                    " " + facePositions[1] + "/" + faceUVs[1] + "/" + faceNormals[1] +
+                    " " + facePositions[2] + "/" + faceUVs[2] + "/" + faceNormals[2]);
+            }
+            //back de previous matrix, to not change the original mesh in the scene
+            if (globalposition && lastMatrix) {
+                mesh[j].bakeTransformIntoVertices(lastMatrix);
+            }
+            v += curV;
+        }
+        var text = output.join("\n");
+        return (text);
+    };
+    /**
+     * Exports the material(s) of a mesh in .MTL file format (text)
+     * @param mesh defines the mesh to extract the material from
+     * @returns the mtl content
+     */
+    //TODO: Export the materials of mesh array
+    OBJExport.MTL = function (mesh) {
+        var output = [];
+        var m = mesh.material;
+        output.push("newmtl mat1");
+        output.push("  Ns " + m.specularPower.toFixed(4));
+        output.push("  Ni 1.5000");
+        output.push("  d " + m.alpha.toFixed(4));
+        output.push("  Tr 0.0000");
+        output.push("  Tf 1.0000 1.0000 1.0000");
+        output.push("  illum 2");
+        output.push("  Ka " + m.ambientColor.r.toFixed(4) + " " + m.ambientColor.g.toFixed(4) + " " + m.ambientColor.b.toFixed(4));
+        output.push("  Kd " + m.diffuseColor.r.toFixed(4) + " " + m.diffuseColor.g.toFixed(4) + " " + m.diffuseColor.b.toFixed(4));
+        output.push("  Ks " + m.specularColor.r.toFixed(4) + " " + m.specularColor.g.toFixed(4) + " " + m.specularColor.b.toFixed(4));
+        output.push("  Ke " + m.emissiveColor.r.toFixed(4) + " " + m.emissiveColor.g.toFixed(4) + " " + m.emissiveColor.b.toFixed(4));
+        //TODO: uv scale, offset, wrap
+        //TODO: UV mirrored in Blender? second UV channel? lightMap? reflection textures?
+        var uvscale = "";
+        if (m.ambientTexture) {
+            output.push("  map_Ka " + uvscale + m.ambientTexture.name);
+        }
+        if (m.diffuseTexture) {
+            output.push("  map_Kd " + uvscale + m.diffuseTexture.name);
+            //TODO: alpha testing, opacity in diffuse texture alpha channel (diffuseTexture.hasAlpha -> map_d)
+        }
+        if (m.specularTexture) {
+            output.push("  map_Ks " + uvscale + m.specularTexture.name);
+            /* TODO: glossiness = specular highlight component is in alpha channel of specularTexture. (???)
+            if (m.useGlossinessFromSpecularMapAlpha)  {
+                output.push("  map_Ns "+uvscale + m.specularTexture.name);
+            }
+            */
+        }
+        /* TODO: emissive texture not in .MAT format (???)
+        if (m.emissiveTexture) {
+            output.push("  map_d "+uvscale+m.emissiveTexture.name);
+        }
+        */
+        if (m.bumpTexture) {
+            output.push("  map_bump -imfchan z " + uvscale + m.bumpTexture.name);
+        }
+        if (m.opacityTexture) {
+            output.push("  map_d " + uvscale + m.opacityTexture.name);
+        }
+        var text = output.join("\n");
+        return (text);
+    };
+    return OBJExport;
+}());
+exports.OBJExport = OBJExport;
+
+
+/***/ }),
+
+/***/ "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.objSerializer.js.map