first try

Tools/Gulp/config.json

@@ -111,6 +111,7 @@
             "instrumentation",
             "backgroundMaterial",
             "environmentHelper",
+            "particleHelper",
             "videoDome"
         ],
         "minimal": [
@@ -1170,6 +1171,16 @@
                 "additionalTextures"
             ]
         },
+        "particleHelper": {
+            "files": [
+                "../../src/Helpers/babylon.particleHelper.js"
+            ],
+            "dependUpon": [
+                "core",
+                "backgroundMaterial",
+                "additionalTextures"
+            ]
+        },
         "videoDome": {
             "files": [
                 "../../src/Helpers/babylon.videoDome.js"

dist/preview release/Oimo.license

@@ -1,21 +0,0 @@
-The MIT License
-
-Copyright © 2010-2017 three.js authors
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in
-all copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN
-THE SOFTWARE.

dist/preview release/_headers

@@ -1,2 +0,0 @@
-/*
-	Access-Control-Allow-Origin: *

dist/preview release/babylon.max.js

@@ -7332,6 +7332,7 @@ var BABYLON;
                         amount += step;
                     }
                 }
+                catmullRom.push(catmullRom[0]);
             }
             else {
                 var totalPoints = new Array();
@@ -21366,11 +21367,7 @@ var BABYLON;
              * exceeding the number allowed of the materials.
              */
             _this.renderPriority = 0;
-            /**
-             * Defines wether or not the shadows are enabled for this light. This can help turning off/on shadow without detaching
-             * the current shadow generator.
-             */
-            _this.shadowEnabled = true;
+            _this._shadowEnabled = true;
             _this._excludeWithLayerMask = 0;
             _this._includeOnlyWithLayerMask = 0;
             _this._lightmapMode = 0;
@@ -21559,6 +21556,28 @@ var BABYLON;
         });
         ;
         ;
+        Object.defineProperty(Light.prototype, "shadowEnabled", {
+            /**
+             * Gets wether or not the shadows are enabled for this light. This can help turning off/on shadow without detaching
+             * the current shadow generator.
+             */
+            get: function () {
+                return this._shadowEnabled;
+            },
+            /**
+             * Sets wether or not the shadows are enabled for this light. This can help turning off/on shadow without detaching
+             * the current shadow generator.
+             */
+            set: function (value) {
+                if (this._shadowEnabled === value) {
+                    return;
+                }
+                this._shadowEnabled = value;
+                this._markMeshesAsLightDirty();
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(Light.prototype, "includedOnlyMeshes", {
             /**
              * Gets the only meshes impacted by this light.
@@ -22068,8 +22087,8 @@ var BABYLON;
             BABYLON.expandToProperty("_reorderLightsInScene")
         ], Light.prototype, "renderPriority", void 0);
         __decorate([
-            BABYLON.serialize()
-        ], Light.prototype, "shadowEnabled", void 0);
+            BABYLON.serialize("shadowEnabled")
+        ], Light.prototype, "_shadowEnabled", void 0);
         __decorate([
             BABYLON.serialize("excludeWithLayerMask")
         ], Light.prototype, "_excludeWithLayerMask", void 0);
@@ -58466,7 +58485,7 @@ var BABYLON;
     /**
      * The SPS is a single updatable mesh. The solid particles are simply separate parts or faces fo this big mesh.
      *As it is just a mesh, the SPS has all the same properties than any other BJS mesh : not more, not less. It can be scaled, rotated, translated, enlighted, textured, moved, etc.
-
+
      * The SPS is also a particle system. It provides some methods to manage the particles.
      * However it is behavior agnostic. This means it has no emitter, no particle physics, no particle recycler. You have to implement your own behavior.
      *
@@ -98422,6 +98441,127 @@ var BABYLON;
 
 //# sourceMappingURL=babylon.environmentHelper.js.map
 
+var BABYLON;
+(function (BABYLON) {
+    var ParticleSystemType;
+    (function (ParticleSystemType) {
+        ParticleSystemType[ParticleSystemType["None"] = 0] = "None";
+        ParticleSystemType[ParticleSystemType["Fire"] = 1] = "Fire";
+        ParticleSystemType[ParticleSystemType["Smoke"] = 2] = "Smoke";
+    })(ParticleSystemType = BABYLON.ParticleSystemType || (BABYLON.ParticleSystemType = {}));
+    var ParticleHelper = /** @class */ (function () {
+        function ParticleHelper() {
+        }
+        ParticleHelper.Create = function (type, emitter, scene, gpu) {
+            if (scene === void 0) { scene = BABYLON.Engine.LastCreatedScene; }
+            if (gpu === void 0) { gpu = false; }
+            var typeParsed = this._parseType(type);
+            if (typeParsed === ParticleSystemType.None) {
+                throw new Error("This particle system type doesn't exist.");
+            }
+            if (scene) {
+                this._scene = scene;
+            }
+            else {
+                throw new Error("A particle system need a scene.");
+            }
+            this._emitter = emitter;
+            switch (typeParsed) {
+                case ParticleSystemType.Fire:
+                    return this._createFire();
+                case ParticleSystemType.Smoke:
+                    return this._createSmoke();
+                default:
+                    throw new Error("Not yet implemented.");
+            }
+        };
+        ParticleHelper._parseType = function (type) {
+            switch (type) {
+                case "fire":
+                case "Fire":
+                case "FIRE":
+                    return ParticleSystemType.Fire;
+                case "smoke":
+                case "Smoke":
+                case "SMOKE":
+                    return ParticleSystemType.Smoke;
+                default:
+                    return ParticleSystemType.None;
+            }
+        };
+        ParticleHelper._createFire = function () {
+            // Create a particle system
+            var fireSystem = new BABYLON.ParticleSystem("particles", 2000, this._scene);
+            // Texture of each particle
+            fireSystem.particleTexture = new BABYLON.Texture(this._baseAssetsUrl + "textures/flare.png", this._scene);
+            // Where the particles come from
+            fireSystem.emitter = this._emitter; // the starting object, the emitter
+            fireSystem.minEmitBox = new BABYLON.Vector3(-0.5, 1, -0.5); // Starting all from
+            fireSystem.maxEmitBox = new BABYLON.Vector3(0.5, 1, 0.5); // To...
+            // Colors of all particles
+            fireSystem.color1 = new BABYLON.Color4(1, 0.5, 0, 1.0);
+            fireSystem.color2 = new BABYLON.Color4(1, 0.5, 0, 1.0);
+            fireSystem.colorDead = new BABYLON.Color4(0, 0, 0, 0.0);
+            // Size of each particle (random between...
+            fireSystem.minSize = 0.3;
+            fireSystem.maxSize = 1;
+            // Life time of each particle (random between...
+            fireSystem.minLifeTime = 0.2;
+            fireSystem.maxLifeTime = 0.4;
+            // Emission rate
+            fireSystem.emitRate = 600;
+            // Blend mode : BLENDMODE_ONEONE, or BLENDMODE_STANDARD
+            fireSystem.blendMode = BABYLON.ParticleSystem.BLENDMODE_ONEONE;
+            // Set the gravity of all particles
+            fireSystem.gravity = new BABYLON.Vector3(0, 0, 0);
+            // Direction of each particle after it has been emitted
+            fireSystem.direction1 = new BABYLON.Vector3(0, 4, 0);
+            fireSystem.direction2 = new BABYLON.Vector3(0, 4, 0);
+            // Angular speed, in radians
+            fireSystem.minAngularSpeed = 0;
+            fireSystem.maxAngularSpeed = Math.PI;
+            // Speed
+            fireSystem.minEmitPower = 1;
+            fireSystem.maxEmitPower = 3;
+            fireSystem.updateSpeed = 0.007;
+            return fireSystem;
+        };
+        ParticleHelper._createSmoke = function () {
+            var smokeSystem = new BABYLON.ParticleSystem("smoke", 1000, this._scene);
+            smokeSystem.particleTexture = new BABYLON.Texture(this._baseAssetsUrl + "textures/flare.png", this._scene);
+            smokeSystem.emitter = this._emitter;
+            smokeSystem.minEmitBox = new BABYLON.Vector3(-0.5, 1, -0.5);
+            smokeSystem.maxEmitBox = new BABYLON.Vector3(0.5, 1, 0.5);
+            smokeSystem.color1 = new BABYLON.Color4(0.1, 0.1, 0.1, 1.0);
+            smokeSystem.color2 = new BABYLON.Color4(0.1, 0.1, 0.1, 1.0);
+            smokeSystem.colorDead = new BABYLON.Color4(0, 0, 0, 0.0);
+            smokeSystem.minSize = 0.3;
+            smokeSystem.maxSize = 1;
+            smokeSystem.minLifeTime = 0.3;
+            smokeSystem.maxLifeTime = 1.5;
+            smokeSystem.emitRate = 350;
+            smokeSystem.blendMode = BABYLON.ParticleSystem.BLENDMODE_ONEONE;
+            smokeSystem.gravity = new BABYLON.Vector3(0, 0, 0);
+            smokeSystem.direction1 = new BABYLON.Vector3(-1.5, 8, -1.5);
+            smokeSystem.direction2 = new BABYLON.Vector3(1.5, 8, 1.5);
+            smokeSystem.minAngularSpeed = 0;
+            smokeSystem.maxAngularSpeed = Math.PI;
+            smokeSystem.minEmitPower = 0.5;
+            smokeSystem.maxEmitPower = 1.5;
+            smokeSystem.updateSpeed = 0.005;
+            return smokeSystem;
+        };
+        /**
+         * Base Assets URL.
+         */
+        ParticleHelper._baseAssetsUrl = "https://assets.babylonjs.com/particles/";
+        return ParticleHelper;
+    }());
+    BABYLON.ParticleHelper = ParticleHelper;
+})(BABYLON || (BABYLON = {}));
+
+//# sourceMappingURL=babylon.particleHelper.js.map
+
 
 var BABYLON;
 (function (BABYLON) {

dist/preview release/babylon.no-module.max.js

@@ -7299,6 +7299,7 @@ var BABYLON;
                         amount += step;
                     }
                 }
+                catmullRom.push(catmullRom[0]);
             }
             else {
                 var totalPoints = new Array();
@@ -21333,11 +21334,7 @@ var BABYLON;
              * exceeding the number allowed of the materials.
              */
             _this.renderPriority = 0;
-            /**
-             * Defines wether or not the shadows are enabled for this light. This can help turning off/on shadow without detaching
-             * the current shadow generator.
-             */
-            _this.shadowEnabled = true;
+            _this._shadowEnabled = true;
             _this._excludeWithLayerMask = 0;
             _this._includeOnlyWithLayerMask = 0;
             _this._lightmapMode = 0;
@@ -21526,6 +21523,28 @@ var BABYLON;
         });
         ;
         ;
+        Object.defineProperty(Light.prototype, "shadowEnabled", {
+            /**
+             * Gets wether or not the shadows are enabled for this light. This can help turning off/on shadow without detaching
+             * the current shadow generator.
+             */
+            get: function () {
+                return this._shadowEnabled;
+            },
+            /**
+             * Sets wether or not the shadows are enabled for this light. This can help turning off/on shadow without detaching
+             * the current shadow generator.
+             */
+            set: function (value) {
+                if (this._shadowEnabled === value) {
+                    return;
+                }
+                this._shadowEnabled = value;
+                this._markMeshesAsLightDirty();
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(Light.prototype, "includedOnlyMeshes", {
             /**
              * Gets the only meshes impacted by this light.
@@ -22035,8 +22054,8 @@ var BABYLON;
             BABYLON.expandToProperty("_reorderLightsInScene")
         ], Light.prototype, "renderPriority", void 0);
         __decorate([
-            BABYLON.serialize()
-        ], Light.prototype, "shadowEnabled", void 0);
+            BABYLON.serialize("shadowEnabled")
+        ], Light.prototype, "_shadowEnabled", void 0);
         __decorate([
             BABYLON.serialize("excludeWithLayerMask")
         ], Light.prototype, "_excludeWithLayerMask", void 0);
@@ -58433,7 +58452,7 @@ var BABYLON;
     /**
      * The SPS is a single updatable mesh. The solid particles are simply separate parts or faces fo this big mesh.
      *As it is just a mesh, the SPS has all the same properties than any other BJS mesh : not more, not less. It can be scaled, rotated, translated, enlighted, textured, moved, etc.
-
+
      * The SPS is also a particle system. It provides some methods to manage the particles.
      * However it is behavior agnostic. This means it has no emitter, no particle physics, no particle recycler. You have to implement your own behavior.
      *
@@ -98389,6 +98408,127 @@ var BABYLON;
 
 //# sourceMappingURL=babylon.environmentHelper.js.map
 
+var BABYLON;
+(function (BABYLON) {
+    var ParticleSystemType;
+    (function (ParticleSystemType) {
+        ParticleSystemType[ParticleSystemType["None"] = 0] = "None";
+        ParticleSystemType[ParticleSystemType["Fire"] = 1] = "Fire";
+        ParticleSystemType[ParticleSystemType["Smoke"] = 2] = "Smoke";
+    })(ParticleSystemType = BABYLON.ParticleSystemType || (BABYLON.ParticleSystemType = {}));
+    var ParticleHelper = /** @class */ (function () {
+        function ParticleHelper() {
+        }
+        ParticleHelper.Create = function (type, emitter, scene, gpu) {
+            if (scene === void 0) { scene = BABYLON.Engine.LastCreatedScene; }
+            if (gpu === void 0) { gpu = false; }
+            var typeParsed = this._parseType(type);
+            if (typeParsed === ParticleSystemType.None) {
+                throw new Error("This particle system type doesn't exist.");
+            }
+            if (scene) {
+                this._scene = scene;
+            }
+            else {
+                throw new Error("A particle system need a scene.");
+            }
+            this._emitter = emitter;
+            switch (typeParsed) {
+                case ParticleSystemType.Fire:
+                    return this._createFire();
+                case ParticleSystemType.Smoke:
+                    return this._createSmoke();
+                default:
+                    throw new Error("Not yet implemented.");
+            }
+        };
+        ParticleHelper._parseType = function (type) {
+            switch (type) {
+                case "fire":
+                case "Fire":
+                case "FIRE":
+                    return ParticleSystemType.Fire;
+                case "smoke":
+                case "Smoke":
+                case "SMOKE":
+                    return ParticleSystemType.Smoke;
+                default:
+                    return ParticleSystemType.None;
+            }
+        };
+        ParticleHelper._createFire = function () {
+            // Create a particle system
+            var fireSystem = new BABYLON.ParticleSystem("particles", 2000, this._scene);
+            // Texture of each particle
+            fireSystem.particleTexture = new BABYLON.Texture(this._baseAssetsUrl + "textures/flare.png", this._scene);
+            // Where the particles come from
+            fireSystem.emitter = this._emitter; // the starting object, the emitter
+            fireSystem.minEmitBox = new BABYLON.Vector3(-0.5, 1, -0.5); // Starting all from
+            fireSystem.maxEmitBox = new BABYLON.Vector3(0.5, 1, 0.5); // To...
+            // Colors of all particles
+            fireSystem.color1 = new BABYLON.Color4(1, 0.5, 0, 1.0);
+            fireSystem.color2 = new BABYLON.Color4(1, 0.5, 0, 1.0);
+            fireSystem.colorDead = new BABYLON.Color4(0, 0, 0, 0.0);
+            // Size of each particle (random between...
+            fireSystem.minSize = 0.3;
+            fireSystem.maxSize = 1;
+            // Life time of each particle (random between...
+            fireSystem.minLifeTime = 0.2;
+            fireSystem.maxLifeTime = 0.4;
+            // Emission rate
+            fireSystem.emitRate = 600;
+            // Blend mode : BLENDMODE_ONEONE, or BLENDMODE_STANDARD
+            fireSystem.blendMode = BABYLON.ParticleSystem.BLENDMODE_ONEONE;
+            // Set the gravity of all particles
+            fireSystem.gravity = new BABYLON.Vector3(0, 0, 0);
+            // Direction of each particle after it has been emitted
+            fireSystem.direction1 = new BABYLON.Vector3(0, 4, 0);
+            fireSystem.direction2 = new BABYLON.Vector3(0, 4, 0);
+            // Angular speed, in radians
+            fireSystem.minAngularSpeed = 0;
+            fireSystem.maxAngularSpeed = Math.PI;
+            // Speed
+            fireSystem.minEmitPower = 1;
+            fireSystem.maxEmitPower = 3;
+            fireSystem.updateSpeed = 0.007;
+            return fireSystem;
+        };
+        ParticleHelper._createSmoke = function () {
+            var smokeSystem = new BABYLON.ParticleSystem("smoke", 1000, this._scene);
+            smokeSystem.particleTexture = new BABYLON.Texture(this._baseAssetsUrl + "textures/flare.png", this._scene);
+            smokeSystem.emitter = this._emitter;
+            smokeSystem.minEmitBox = new BABYLON.Vector3(-0.5, 1, -0.5);
+            smokeSystem.maxEmitBox = new BABYLON.Vector3(0.5, 1, 0.5);
+            smokeSystem.color1 = new BABYLON.Color4(0.1, 0.1, 0.1, 1.0);
+            smokeSystem.color2 = new BABYLON.Color4(0.1, 0.1, 0.1, 1.0);
+            smokeSystem.colorDead = new BABYLON.Color4(0, 0, 0, 0.0);
+            smokeSystem.minSize = 0.3;
+            smokeSystem.maxSize = 1;
+            smokeSystem.minLifeTime = 0.3;
+            smokeSystem.maxLifeTime = 1.5;
+            smokeSystem.emitRate = 350;
+            smokeSystem.blendMode = BABYLON.ParticleSystem.BLENDMODE_ONEONE;
+            smokeSystem.gravity = new BABYLON.Vector3(0, 0, 0);
+            smokeSystem.direction1 = new BABYLON.Vector3(-1.5, 8, -1.5);
+            smokeSystem.direction2 = new BABYLON.Vector3(1.5, 8, 1.5);
+            smokeSystem.minAngularSpeed = 0;
+            smokeSystem.maxAngularSpeed = Math.PI;
+            smokeSystem.minEmitPower = 0.5;
+            smokeSystem.maxEmitPower = 1.5;
+            smokeSystem.updateSpeed = 0.005;
+            return smokeSystem;
+        };
+        /**
+         * Base Assets URL.
+         */
+        ParticleHelper._baseAssetsUrl = "https://assets.babylonjs.com/particles/";
+        return ParticleHelper;
+    }());
+    BABYLON.ParticleHelper = ParticleHelper;
+})(BABYLON || (BABYLON = {}));
+
+//# sourceMappingURL=babylon.particleHelper.js.map
+
 
 var BABYLON;
 (function (BABYLON) {

dist/preview release/cannon.license

@@ -1,22 +0,0 @@
-/*
- * Copyright (c) 2015 cannon.js Authors
- *
- * Permission is hereby granted, free of charge, to any person
- * obtaining a copy of this software and associated documentation
- * files (the "Software"), to deal in the Software without
- * restriction, including without limitation the rights to use, copy,
- * modify, merge, publish, distribute, sublicense, and/or sell copies
- * of the Software, and to permit persons to whom the Software is
- * furnished to do so, subject to the following conditions:
- *
- * The above copyright notice and this permission notice shall be
- * included in all copies or substantial portions of the Software.
- *
- * THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND,
- * EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF
- * MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND
- * NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE
- * LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION
- * OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION
- * WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
- */

dist/preview release/draco.license

@@ -1,201 +0,0 @@
-                                 Apache License
-                           Version 2.0, January 2004
-                        http://www.apache.org/licenses/
-
-   TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION
-
-   1. Definitions.
-
-      "License" shall mean the terms and conditions for use, reproduction,
-      and distribution as defined by Sections 1 through 9 of this document.
-
-      "Licensor" shall mean the copyright owner or entity authorized by
-      the copyright owner that is granting the License.
-
-      "Legal Entity" shall mean the union of the acting entity and all
-      other entities that control, are controlled by, or are under common
-      control with that entity. For the purposes of this definition,
-      "control" means (i) the power, direct or indirect, to cause the
-      direction or management of such entity, whether by contract or
-      otherwise, or (ii) ownership of fifty percent (50%) or more of the
-      outstanding shares, or (iii) beneficial ownership of such entity.
-
-      "You" (or "Your") shall mean an individual or Legal Entity
-      exercising permissions granted by this License.
-
-      "Source" form shall mean the preferred form for making modifications,
-      including but not limited to software source code, documentation
-      source, and configuration files.
-
-      "Object" form shall mean any form resulting from mechanical
-      transformation or translation of a Source form, including but
-      not limited to compiled object code, generated documentation,
-      and conversions to other media types.
-
-      "Work" shall mean the work of authorship, whether in Source or
-      Object form, made available under the License, as indicated by a
-      copyright notice that is included in or attached to the work
-      (an example is provided in the Appendix below).
-
-      "Derivative Works" shall mean any work, whether in Source or Object
-      form, that is based on (or derived from) the Work and for which the
-      editorial revisions, annotations, elaborations, or other modifications
-      represent, as a whole, an original work of authorship. For the purposes
-      of this License, Derivative Works shall not include works that remain
-      separable from, or merely link (or bind by name) to the interfaces of,
-      the Work and Derivative Works thereof.
-
-      "Contribution" shall mean any work of authorship, including
-      the original version of the Work and any modifications or additions
-      to that Work or Derivative Works thereof, that is intentionally
-      submitted to Licensor for inclusion in the Work by the copyright owner
-      or by an individual or Legal Entity authorized to submit on behalf of
-      the copyright owner. For the purposes of this definition, "submitted"
-      means any form of electronic, verbal, or written communication sent
-      to the Licensor or its representatives, including but not limited to
-      communication on electronic mailing lists, source code control systems,
-      and issue tracking systems that are managed by, or on behalf of, the
-      Licensor for the purpose of discussing and improving the Work, but
-      excluding communication that is conspicuously marked or otherwise
-      designated in writing by the copyright owner as "Not a Contribution."
-
-      "Contributor" shall mean Licensor and any individual or Legal Entity
-      on behalf of whom a Contribution has been received by Licensor and
-      subsequently incorporated within the Work.
-
-   2. Grant of Copyright License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      copyright license to reproduce, prepare Derivative Works of,
-      publicly display, publicly perform, sublicense, and distribute the
-      Work and such Derivative Works in Source or Object form.
-
-   3. Grant of Patent License. Subject to the terms and conditions of
-      this License, each Contributor hereby grants to You a perpetual,
-      worldwide, non-exclusive, no-charge, royalty-free, irrevocable
-      (except as stated in this section) patent license to make, have made,
-      use, offer to sell, sell, import, and otherwise transfer the Work,
-      where such license applies only to those patent claims licensable
-      by such Contributor that are necessarily infringed by their
-      Contribution(s) alone or by combination of their Contribution(s)
-      with the Work to which such Contribution(s) was submitted. If You
-      institute patent litigation against any entity (including a
-      cross-claim or counterclaim in a lawsuit) alleging that the Work
-      or a Contribution incorporated within the Work constitutes direct
-      or contributory patent infringement, then any patent licenses
-      granted to You under this License for that Work shall terminate
-      as of the date such litigation is filed.
-
-   4. Redistribution. You may reproduce and distribute copies of the
-      Work or Derivative Works thereof in any medium, with or without
-      modifications, and in Source or Object form, provided that You
-      meet the following conditions:
-
-      (a) You must give any other recipients of the Work or
-          Derivative Works a copy of this License; and
-
-      (b) You must cause any modified files to carry prominent notices
-          stating that You changed the files; and
-
-      (c) You must retain, in the Source form of any Derivative Works
-          that You distribute, all copyright, patent, trademark, and
-          attribution notices from the Source form of the Work,
-          excluding those notices that do not pertain to any part of
-          the Derivative Works; and
-
-      (d) If the Work includes a "NOTICE" text file as part of its
-          distribution, then any Derivative Works that You distribute must
-          include a readable copy of the attribution notices contained
-          within such NOTICE file, excluding those notices that do not
-          pertain to any part of the Derivative Works, in at least one
-          of the following places: within a NOTICE text file distributed
-          as part of the Derivative Works; within the Source form or
-          documentation, if provided along with the Derivative Works; or,
-          within a display generated by the Derivative Works, if and
-          wherever such third-party notices normally appear. The contents
-          of the NOTICE file are for informational purposes only and
-          do not modify the License. You may add Your own attribution
-          notices within Derivative Works that You distribute, alongside
-          or as an addendum to the NOTICE text from the Work, provided
-          that such additional attribution notices cannot be construed
-          as modifying the License.
-
-      You may add Your own copyright statement to Your modifications and
-      may provide additional or different license terms and conditions
-      for use, reproduction, or distribution of Your modifications, or
-      for any such Derivative Works as a whole, provided Your use,
-      reproduction, and distribution of the Work otherwise complies with
-      the conditions stated in this License.
-
-   5. Submission of Contributions. Unless You explicitly state otherwise,
-      any Contribution intentionally submitted for inclusion in the Work
-      by You to the Licensor shall be under the terms and conditions of
-      this License, without any additional terms or conditions.
-      Notwithstanding the above, nothing herein shall supersede or modify
-      the terms of any separate license agreement you may have executed
-      with Licensor regarding such Contributions.
-
-   6. Trademarks. This License does not grant permission to use the trade
-      names, trademarks, service marks, or product names of the Licensor,
-      except as required for reasonable and customary use in describing the
-      origin of the Work and reproducing the content of the NOTICE file.
-
-   7. Disclaimer of Warranty. Unless required by applicable law or
-      agreed to in writing, Licensor provides the Work (and each
-      Contributor provides its Contributions) on an "AS IS" BASIS,
-      WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or
-      implied, including, without limitation, any warranties or conditions
-      of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A
-      PARTICULAR PURPOSE. You are solely responsible for determining the
-      appropriateness of using or redistributing the Work and assume any
-      risks associated with Your exercise of permissions under this License.
-
-   8. Limitation of Liability. In no event and under no legal theory,
-      whether in tort (including negligence), contract, or otherwise,
-      unless required by applicable law (such as deliberate and grossly
-      negligent acts) or agreed to in writing, shall any Contributor be
-      liable to You for damages, including any direct, indirect, special,
-      incidental, or consequential damages of any character arising as a
-      result of this License or out of the use or inability to use the
-      Work (including but not limited to damages for loss of goodwill,
-      work stoppage, computer failure or malfunction, or any and all
-      other commercial damages or losses), even if such Contributor
-      has been advised of the possibility of such damages.
-
-   9. Accepting Warranty or Additional Liability. While redistributing
-      the Work or Derivative Works thereof, You may choose to offer,
-      and charge a fee for, acceptance of support, warranty, indemnity,
-      or other liability obligations and/or rights consistent with this
-      License. However, in accepting such obligations, You may act only
-      on Your own behalf and on Your sole responsibility, not on behalf
-      of any other Contributor, and only if You agree to indemnify,
-      defend, and hold each Contributor harmless for any liability
-      incurred by, or claims asserted against, such Contributor by reason
-      of your accepting any such warranty or additional liability.
-
-   END OF TERMS AND CONDITIONS
-
-   APPENDIX: How to apply the Apache License to your work.
-
-      To apply the Apache License to your work, attach the following
-      boilerplate notice, with the fields enclosed by brackets "[]"
-      replaced with your own identifying information. (Don't include
-      the brackets!)  The text should be enclosed in the appropriate
-      comment syntax for the file format. We also recommend that a
-      file or class name and description of purpose be included on the
-      same "printed page" as the copyright notice for easier
-      identification within third-party archives.
-
-   Copyright [yyyy] [name of copyright owner]
-
-   Licensed under the Apache License, Version 2.0 (the "License");
-   you may not use this file except in compliance with the License.
-   You may obtain a copy of the License at
-
-       http://www.apache.org/licenses/LICENSE-2.0
-
-   Unless required by applicable law or agreed to in writing, software
-   distributed under the License is distributed on an "AS IS" BASIS,
-   WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-   See the License for the specific language governing permissions and
-   limitations under the License.

dist/preview release/earcut.license

@@ -1,15 +0,0 @@
-ISC License
-
-Copyright (c) 2016, Mapbox
-
-Permission to use, copy, modify, and/or distribute this software for any purpose
-with or without fee is hereby granted, provided that the above copyright notice
-and this permission notice appear in all copies.
-
-THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
-REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY AND
-FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
-INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM LOSS
-OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR OTHER
-TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR PERFORMANCE OF
-THIS SOFTWARE.

dist/preview release/gltf2Interface/babylon.glTF2Interface.d.ts

@@ -1,855 +0,0 @@
-/**
- * @ignoreChildren
- * @ignore
- */
-declare module "babylonjs-gltf2interface" {
-    export = BABYLON.GLTF2;
-}
-/**
- * Moduel for glTF 2.0 Interface
- */
-declare module BABYLON.GLTF2 {
-    /**
-     * The datatype of the components in the attribute
-     */
-    const enum AccessorComponentType {
-        /**
-         * Byte
-         */
-        BYTE = 5120,
-        /**
-         * Unsigned Byte
-         */
-        UNSIGNED_BYTE = 5121,
-        /**
-         * Short
-         */
-        SHORT = 5122,
-        /**
-         * Unsigned Short
-         */
-        UNSIGNED_SHORT = 5123,
-        /**
-         * Unsigned Int
-         */
-        UNSIGNED_INT = 5125,
-        /**
-         * Float
-         */
-        FLOAT = 5126,
-    }
-    /**
-     * Specifies if the attirbute is a scalar, vector, or matrix
-     */
-    const enum AccessorType {
-        /**
-         * Scalar
-         */
-        SCALAR = "SCALAR",
-        /**
-         * Vector2
-         */
-        VEC2 = "VEC2",
-        /**
-         * Vector3
-         */
-        VEC3 = "VEC3",
-        /**
-         * Vector4
-         */
-        VEC4 = "VEC4",
-        /**
-         * Matrix2x2
-         */
-        MAT2 = "MAT2",
-        /**
-         * Matrix3x3
-         */
-        MAT3 = "MAT3",
-        /**
-         * Matrix4x4
-         */
-        MAT4 = "MAT4",
-    }
-    /**
-     * The name of the node's TRS property to modify, or the weights of the Morph Targets it instantiates
-     */
-    const enum AnimationChannelTargetPath {
-        /**
-         * Translation
-         */
-        TRANSLATION = "translation",
-        /**
-         * Rotation
-         */
-        ROTATION = "rotation",
-        /**
-         * Scale
-         */
-        SCALE = "scale",
-        /**
-         * Weights
-         */
-        WEIGHTS = "weights",
-    }
-    /**
-     * Interpolation algorithm
-     */
-    const enum AnimationSamplerInterpolation {
-        /**
-         * The animated values are linearly interpolated between keyframes
-         */
-        LINEAR = "LINEAR",
-        /**
-         * The animated values remain constant to the output of the first keyframe, until the next keyframe
-         */
-        STEP = "STEP",
-        /**
-         * The animation's interpolation is computed using a cubic spline with specified tangents
-         */
-        CUBICSPLINE = "CUBICSPLINE",
-    }
-    /**
-     * A camera's projection.  A node can reference a camera to apply a transform to place the camera in the scene
-     */
-    const enum CameraType {
-        /**
-         * A perspective camera containing properties to create a perspective projection matrix
-         */
-        PERSPECTIVE = "perspective",
-        /**
-         * An orthographic camera containing properties to create an orthographic projection matrix
-         */
-        ORTHOGRAPHIC = "orthographic",
-    }
-    /**
-     * The mime-type of the image
-     */
-    const enum ImageMimeType {
-        /**
-         * JPEG Mime-type
-         */
-        JPEG = "image/jpeg",
-        /**
-         * PNG Mime-type
-         */
-        PNG = "image/png",
-    }
-    /**
-     * The alpha rendering mode of the material
-     */
-    const enum MaterialAlphaMode {
-        /**
-         * The alpha value is ignored and the rendered output is fully opaque
-         */
-        OPAQUE = "OPAQUE",
-        /**
-         * The rendered output is either fully opaque or fully transparent depending on the alpha value and the specified alpha cutoff value
-         */
-        MASK = "MASK",
-        /**
-         * The alpha value is used to composite the source and destination areas. The rendered output is combined with the background using the normal painting operation (i.e. the Porter and Duff over operator)
-         */
-        BLEND = "BLEND",
-    }
-    /**
-     * The type of the primitives to render
-     */
-    const enum MeshPrimitiveMode {
-        /**
-         * Points
-         */
-        POINTS = 0,
-        /**
-         * Lines
-         */
-        LINES = 1,
-        /**
-         * Line Loop
-         */
-        LINE_LOOP = 2,
-        /**
-         * Line Strip
-         */
-        LINE_STRIP = 3,
-        /**
-         * Triangles
-         */
-        TRIANGLES = 4,
-        /**
-         * Triangle Strip
-         */
-        TRIANGLE_STRIP = 5,
-        /**
-         * Triangle Fan
-         */
-        TRIANGLE_FAN = 6,
-    }
-    /**
-     * Magnification filter.  Valid values correspond to WebGL enums: 9728 (NEAREST) and 9729 (LINEAR)
-     */
-    const enum TextureMagFilter {
-        /**
-         * Nearest
-         */
-        NEAREST = 9728,
-        /**
-         * Linear
-         */
-        LINEAR = 9729,
-    }
-    /**
-     * Minification filter.  All valid values correspond to WebGL enums
-     */
-    const enum TextureMinFilter {
-        /**
-         * Nearest
-         */
-        NEAREST = 9728,
-        /**
-         * Linear
-         */
-        LINEAR = 9729,
-        /**
-         * Nearest Mip-Map Nearest
-         */
-        NEAREST_MIPMAP_NEAREST = 9984,
-        /**
-         * Linear Mipmap Nearest
-         */
-        LINEAR_MIPMAP_NEAREST = 9985,
-        /**
-         * Nearest Mipmap Linear
-         */
-        NEAREST_MIPMAP_LINEAR = 9986,
-        /**
-         * Linear Mipmap Linear
-         */
-        LINEAR_MIPMAP_LINEAR = 9987,
-    }
-    /**
-     * S (U) wrapping mode.  All valid values correspond to WebGL enums
-     */
-    const enum TextureWrapMode {
-        /**
-         * Clamp to Edge
-         */
-        CLAMP_TO_EDGE = 33071,
-        /**
-         * Mirrored Repeat
-         */
-        MIRRORED_REPEAT = 33648,
-        /**
-         * Repeat
-         */
-        REPEAT = 10497,
-    }
-    /**
-     * glTF Property
-     */
-    interface IProperty {
-        /**
-         * Dictionary object with extension-specific objects
-         */
-        extensions?: {
-            [key: string]: any;
-        };
-        /**
-         * Application-Specific data 
-         */
-        extras?: any;
-    }
-    /**
-     * glTF Child of Root Property
-     */
-    interface IChildRootProperty extends IProperty {
-        /**
-         * The user-defined name of this object
-         */
-        name?: string;
-    }
-    /**
-     * Indices of those attributes that deviate from their initialization value
-     */
-    interface IAccessorSparseIndices extends IProperty {
-        /**
-         * The index of the bufferView with sparse indices. Referenced bufferView can't have ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER target
-         */
-        bufferView: number;
-        /**
-         * The offset relative to the start of the bufferView in bytes. Must be aligned
-         */
-        byteOffset?: number;
-        /**
-         * The indices data type.  Valid values correspond to WebGL enums: 5121 (UNSIGNED_BYTE), 5123 (UNSIGNED_SHORT), 5125 (UNSIGNED_INT)
-         */
-        componentType: AccessorComponentType;
-    }
-    /**
-     * Array of size accessor.sparse.count times number of components storing the displaced accessor attributes pointed by accessor.sparse.indices
-     */
-    interface IAccessorSparseValues extends IProperty {
-        /**
-         * The index of the bufferView with sparse values. Referenced bufferView can't have ARRAY_BUFFER or ELEMENT_ARRAY_BUFFER target
-         */
-        bufferView: number;
-        /**
-         * The offset relative to the start of the bufferView in bytes. Must be aligned
-         */
-        byteOffset?: number;
-    }
-    /**
-     * Sparse storage of attributes that deviate from their initialization value
-     */
-    interface IAccessorSparse extends IProperty {
-        /**
-         * The number of attributes encoded in this sparse accessor
-         */
-        count: number;
-        /**
-         * Index array of size count that points to those accessor attributes that deviate from their initialization value. Indices must strictly increase
-         */
-        indices: IAccessorSparseIndices;
-        /**
-         * Array of size count times number of components, storing the displaced accessor attributes pointed by indices. Substituted values must have the same componentType and number of components as the base accessor
-         */
-        values: IAccessorSparseValues;
-    }
-    /**
-     * A typed view into a bufferView.  A bufferView contains raw binary data.  An accessor provides a typed view into a bufferView or a subset of a bufferView similar to how WebGL's vertexAttribPointer() defines an attribute in a buffer
-     */
-    interface IAccessor extends IChildRootProperty {
-        /**
-         * The index of the bufferview
-         */
-        bufferView?: number;
-        /**
-         * The offset relative to the start of the bufferView in bytes
-         */
-        byteOffset?: number;
-        /**
-         * The datatype of components in the attribute
-         */
-        componentType: AccessorComponentType;
-        /**
-         * Specifies whether integer data values should be normalized
-         */
-        normalized?: boolean;
-        /**
-         * The number of attributes referenced by this accessor
-         */
-        count: number;
-        /**
-         * Specifies if the attribute is a scalar, vector, or matrix
-         */
-        type: AccessorType;
-        /**
-         * Maximum value of each component in this attribute
-         */
-        max?: number[];
-        /**
-         * Minimum value of each component in this attribute
-         */
-        min?: number[];
-        /**
-         * Sparse storage of attributes that deviate from their initialization value
-         */
-        sparse?: IAccessorSparse;
-    }
-    /**
-     * Targets an animation's sampler at a node's property
-     */
-    interface IAnimationChannel extends IProperty {
-        /**
-         * The index of a sampler in this animation used to compute the value for the target
-         */
-        sampler: number;
-        /**
-         * The index of the node and TRS property to target
-         */
-        target: IAnimationChannelTarget;
-    }
-    /**
-     * The index of the node and TRS property that an animation channel targets
-     */
-    interface IAnimationChannelTarget extends IProperty {
-        /**
-         * The index of the node to target
-         */
-        node: number;
-        /**
-         * The name of the node's TRS property to modify, or the weights of the Morph Targets it instantiates
-         */
-        path: AnimationChannelTargetPath;
-    }
-    /**
-     * Combines input and output accessors with an interpolation algorithm to define a keyframe graph (but not its target)
-     */
-    interface IAnimationSampler extends IProperty {
-        /**
-         * The index of an accessor containing keyframe input values, e.g., time
-         */
-        input: number;
-        /**
-         * Interpolation algorithm
-         */
-        interpolation?: AnimationSamplerInterpolation;
-        /**
-         * The index of an accessor, containing keyframe output values
-         */
-        output: number;
-    }
-    /**
-     * A keyframe animation
-     */
-    interface IAnimation extends IChildRootProperty {
-        /**
-         * An array of channels, each of which targets an animation's sampler at a node's property
-         */
-        channels: IAnimationChannel[];
-        /**
-         * An array of samplers that combines input and output accessors with an interpolation algorithm to define a keyframe graph (but not its target)
-         */
-        samplers: IAnimationSampler[];
-    }
-    /**
-     * Metadata about the glTF asset
-     */
-    interface IAsset extends IChildRootProperty {
-        /**
-         * A copyright message suitable for display to credit the content creator
-         */
-        copyright?: string;
-        /**
-         * Tool that generated this glTF model.  Useful for debugging
-         */
-        generator?: string;
-        /**
-         * The glTF version that this asset targets
-         */
-        version: string;
-        /**
-         * The minimum glTF version that this asset targets
-         */
-        minVersion?: string;
-    }
-    /**
-     * A buffer points to binary geometry, animation, or skins
-     */
-    interface IBuffer extends IChildRootProperty {
-        /**
-         * The uri of the buffer.  Relative paths are relative to the .gltf file.  Instead of referencing an external file, the uri can also be a data-uri
-         */
-        uri?: string;
-        /**
-         * The length of the buffer in bytes
-         */
-        byteLength: number;
-    }
-    /**
-     * A view into a buffer generally representing a subset of the buffer
-     */
-    interface IBufferView extends IChildRootProperty {
-        /**
-         * The index of the buffer
-         */
-        buffer: number;
-        /**
-         * The offset into the buffer in bytes
-         */
-        byteOffset?: number;
-        /**
-         * The lenth of the bufferView in bytes
-         */
-        byteLength: number;
-        /**
-         * The stride, in bytes
-         */
-        byteStride?: number;
-    }
-    /**
-     * An orthographic camera containing properties to create an orthographic projection matrix
-     */
-    interface ICameraOrthographic extends IProperty {
-        /**
-         * The floating-point horizontal magnification of the view. Must not be zero
-         */
-        xmag: number;
-        /**
-         * The floating-point vertical magnification of the view. Must not be zero
-         */
-        ymag: number;
-        /**
-         * The floating-point distance to the far clipping plane. zfar must be greater than znear
-         */
-        zfar: number;
-        /**
-         * The floating-point distance to the near clipping plane
-         */
-        znear: number;
-    }
-    /**
-     * A perspective camera containing properties to create a perspective projection matrix
-     */
-    interface ICameraPerspective extends IProperty {
-        /**
-         * The floating-point aspect ratio of the field of view
-         */
-        aspectRatio?: number;
-        /**
-         * The floating-point vertical field of view in radians
-         */
-        yfov: number;
-        /**
-         * The floating-point distance to the far clipping plane
-         */
-        zfar?: number;
-        /**
-         * The floating-point distance to the near clipping plane
-         */
-        znear: number;
-    }
-    /**
-     * A camera's projection.  A node can reference a camera to apply a transform to place the camera in the scene
-     */
-    interface ICamera extends IChildRootProperty {
-        /**
-         * An orthographic camera containing properties to create an orthographic projection matrix
-         */
-        orthographic?: ICameraOrthographic;
-        /**
-         * A perspective camera containing properties to create a perspective projection matrix
-         */
-        perspective?: ICameraPerspective;
-        /**
-         * Specifies if the camera uses a perspective or orthographic projection
-         */
-        type: CameraType;
-    }
-    /**
-     * Image data used to create a texture. Image can be referenced by URI or bufferView index. mimeType is required in the latter case
-     */
-    interface IImage extends IChildRootProperty {
-        /**
-         * The uri of the image.  Relative paths are relative to the .gltf file.  Instead of referencing an external file, the uri can also be a data-uri.  The image format must be jpg or png
-         */
-        uri?: string;
-        /**
-         * The image's MIME type
-         */
-        mimeType?: ImageMimeType;
-        /**
-         * The index of the bufferView that contains the image. Use this instead of the image's uri property
-         */
-        bufferView?: number;
-    }
-    /**
-     * Material Normal Texture Info
-     */
-    interface IMaterialNormalTextureInfo extends ITextureInfo {
-        /**
-         * The scalar multiplier applied to each normal vector of the normal texture
-         */
-        scale?: number;
-    }
-    /**
-     * Material Occlusion Texture Info
-     */
-    interface IMaterialOcclusionTextureInfo extends ITextureInfo {
-        /**
-         * A scalar multiplier controlling the amount of occlusion applied
-         */
-        strength?: number;
-    }
-    /**
-     * A set of parameter values that are used to define the metallic-roughness material model from Physically-Based Rendering (PBR) methodology
-     */
-    interface IMaterialPbrMetallicRoughness {
-        /**
-         * The material's base color factor
-         */
-        baseColorFactor?: number[];
-        /**
-         * The base color texture
-         */
-        baseColorTexture?: ITextureInfo;
-        /**
-         * The metalness of the material
-         */
-        metallicFactor?: number;
-        /**
-         * The roughness of the material
-         */
-        roughnessFactor?: number;
-        /**
-         * The metallic-roughness texture
-         */
-        metallicRoughnessTexture?: ITextureInfo;
-    }
-    /**
-     * The material appearance of a primitive
-     */
-    interface IMaterial extends IChildRootProperty {
-        /**
-         * A set of parameter values that are used to define the metallic-roughness material model from Physically-Based Rendering (PBR) methodology. When not specified, all the default values of pbrMetallicRoughness apply
-         */
-        pbrMetallicRoughness?: IMaterialPbrMetallicRoughness;
-        /**
-         * The normal map texture
-         */
-        normalTexture?: IMaterialNormalTextureInfo;
-        /**
-         * The occlusion map texture
-         */
-        occlusionTexture?: IMaterialOcclusionTextureInfo;
-        /**
-         * The emissive map texture
-         */
-        emissiveTexture?: ITextureInfo;
-        /**
-         * The RGB components of the emissive color of the material. These values are linear. If an emissiveTexture is specified, this value is multiplied with the texel values
-         */
-        emissiveFactor?: number[];
-        /**
-         * The alpha rendering mode of the material
-         */
-        alphaMode?: MaterialAlphaMode;
-        /**
-         * The alpha cutoff value of the material
-         */
-        alphaCutoff?: number;
-        /**
-         * Specifies whether the material is double sided
-         */
-        doubleSided?: boolean;
-    }
-    /**
-     * Geometry to be rendered with the given material
-     */
-    interface IMeshPrimitive extends IProperty {
-        /**
-         * A dictionary object, where each key corresponds to mesh attribute semantic and each value is the index of the accessor containing attribute's data
-         */
-        attributes: {
-            [name: string]: number;
-        };
-        /**
-         * The index of the accessor that contains the indices
-         */
-        indices?: number;
-        /**
-         * The index of the material to apply to this primitive when rendering
-         */
-        material?: number;
-        /**
-         * The type of primitives to render. All valid values correspond to WebGL enums
-         */
-        mode?: MeshPrimitiveMode;
-        /**
-         * An array of Morph Targets, each  Morph Target is a dictionary mapping attributes (only POSITION, NORMAL, and TANGENT supported) to their deviations in the Morph Target
-         */
-        targets?: {
-            [name: string]: number;
-        }[];
-    }
-    /**
-     * A set of primitives to be rendered.  A node can contain one mesh.  A node's transform places the mesh in the scene
-     */
-    interface IMesh extends IChildRootProperty {
-        /**
-         * An array of primitives, each defining geometry to be rendered with a material
-         */
-        primitives: IMeshPrimitive[];
-        /**
-         * Array of weights to be applied to the Morph Targets
-         */
-        weights?: number[];
-    }
-    /**
-     * A node in the node hierarchy
-     */
-    interface INode extends IChildRootProperty {
-        /**
-         * The index of the camera referenced by this node
-         */
-        camera?: number;
-        /**
-         * The indices of this node's children
-         */
-        children?: number[];
-        /**
-         * The index of the skin referenced by this node
-         */
-        skin?: number;
-        /**
-         * A floating-point 4x4 transformation matrix stored in column-major order
-         */
-        matrix?: number[];
-        /**
-         * The index of the mesh in this node
-         */
-        mesh?: number;
-        /**
-         * The node's unit quaternion rotation in the order (x, y, z, w), where w is the scalar
-         */
-        rotation?: number[];
-        /**
-         * The node's non-uniform scale, given as the scaling factors along the x, y, and z axes
-         */
-        scale?: number[];
-        /**
-         * The node's translation along the x, y, and z axes
-         */
-        translation?: number[];
-        /**
-         * The weights of the instantiated Morph Target. Number of elements must match number of Morph Targets of used mesh
-         */
-        weights?: number[];
-    }
-    /**
-     * Texture sampler properties for filtering and wrapping modes
-     */
-    interface ISampler extends IChildRootProperty {
-        /**
-         * Magnification filter.  Valid values correspond to WebGL enums: 9728 (NEAREST) and 9729 (LINEAR)
-         */
-        magFilter?: TextureMagFilter;
-        /**
-         * Minification filter.  All valid values correspond to WebGL enums
-         */
-        minFilter?: TextureMinFilter;
-        /**
-         * S (U) wrapping mode.  All valid values correspond to WebGL enums
-         */
-        wrapS?: TextureWrapMode;
-        /**
-         * T (V) wrapping mode.  All valid values correspond to WebGL enums
-         */
-        wrapT?: TextureWrapMode;
-    }
-    /**
-     * The root nodes of a scene
-     */
-    interface IScene extends IChildRootProperty {
-        /**
-         * The indices of each root node
-         */
-        nodes: number[];
-    }
-    /**
-     * Joints and matrices defining a skin
-     */
-    interface ISkin extends IChildRootProperty {
-        /**
-         * The index of the accessor containing the floating-point 4x4 inverse-bind matrices.  The default is that each matrix is a 4x4 identity matrix, which implies that inverse-bind matrices were pre-applied
-         */
-        inverseBindMatrices?: number;
-        /**
-         * The index of the node used as a skeleton root. When undefined, joints transforms resolve to scene root
-         */
-        skeleton?: number;
-        /**
-         * Indices of skeleton nodes, used as joints in this skin.  The array length must be the same as the count property of the inverseBindMatrices accessor (when defined)
-         */
-        joints: number[];
-    }
-    /**
-     * A texture and its sampler
-     */
-    interface ITexture extends IChildRootProperty {
-        /**
-         * The index of the sampler used by this texture. When undefined, a sampler with repeat wrapping and auto filtering should be used
-         */
-        sampler?: number;
-        /**
-         * The index of the image used by this texture
-         */
-        source: number;
-    }
-    /**
-     * Reference to a texture
-     */
-    interface ITextureInfo extends IProperty {
-        /**
-         * The index of the texture
-         */
-        index: number;
-        /**
-         * The set index of texture's TEXCOORD attribute used for texture coordinate mapping
-         */
-        texCoord?: number;
-    }
-    /**
-     * The root object for a glTF asset
-     */
-    interface IGLTF extends IProperty {
-        /**
-         * An array of accessors. An accessor is a typed view into a bufferView
-         */
-        accessors?: IAccessor[];
-        /**
-         * An array of keyframe animations
-         */
-        animations?: IAnimation[];
-        /**
-         * Metadata about the glTF asset
-         */
-        asset: IAsset;
-        /**
-         * An array of buffers.  A buffer points to binary geometry, animation, or skins
-         */
-        buffers?: IBuffer[];
-        /**
-         * An array of bufferViews.  A bufferView is a view into a buffer generally representing a subset of the buffer
-         */
-        bufferViews?: IBufferView[];
-        /**
-         * An array of cameras
-         */
-        cameras?: ICamera[];
-        /**
-         * Names of glTF extensions used somewhere in this asset
-         */
-        extensionsUsed?: string[];
-        /**
-         * Names of glTF extensions required to properly load this asset
-         */
-        extensionsRequired?: string[];
-        /**
-         * An array of images.  An image defines data used to create a texture
-         */
-        images?: IImage[];
-        /**
-         * An array of materials.  A material defines the appearance of a primitive
-         */
-        materials?: IMaterial[];
-        /**
-         * An array of meshes.  A mesh is a set of primitives to be rendered
-         */
-        meshes?: IMesh[];
-        /**
-         * An array of nodes
-         */
-        nodes?: INode[];
-        /**
-         * An array of samplers.  A sampler contains properties for texture filtering and wrapping modes
-         */
-        samplers?: ISampler[];
-        /**
-         * The index of the default scene
-         */
-        scene?: number;
-        /**
-         * An array of scenes
-         */
-        scenes?: IScene[];
-        /**
-         * An array of skins.  A skin is defined by joints and matrices
-         */
-        skins?: ISkin[];
-        /**
-         * An array of textures
-         */
-        textures?: ITexture[];
-    }
-}

dist/preview release/gltf2Interface/package.json

@@ -1,28 +0,0 @@
-{
-    "name": "babylonjs-gltf2interface",
-    "description": "A typescript declaration of babylon's gltf2 inteface.",
-    "version": "3.2.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/BabylonJS/Babylon.js.git"
-    },
-    "files": [
-        "babylon.glTF2Interface.d.ts",
-        "package.json"
-    ],
-    "typings": "babylon.glTF2Interface.d.ts",
-    "keywords": [
-        "3D",
-        "javascript",
-        "html5",
-        "webgl",
-        "gltf2"
-    ],
-    "license": "Apache-2.0",
-    "peerDependencies": {
-        "babylonjs": ">=3.2.0-alpha"
-    },
-    "engines": {
-        "node": "*"
-    }
-}

dist/preview release/gui/babylon.gui.d.ts

@@ -1,918 +0,0 @@
-
-declare module BABYLON.GUI {
-    interface IFocusableControl {
-        onFocus(): void;
-        onBlur(): void;
-        processKeyboard(evt: KeyboardEvent): void;
-    }
-    class AdvancedDynamicTexture extends DynamicTexture {
-        private _isDirty;
-        private _renderObserver;
-        private _resizeObserver;
-        private _preKeyboardObserver;
-        private _pointerMoveObserver;
-        private _pointerObserver;
-        private _canvasPointerOutObserver;
-        private _background;
-        _rootContainer: Container;
-        _lastPickedControl: Control;
-        _lastControlOver: {
-            [pointerId: number]: Control;
-        };
-        _lastControlDown: {
-            [pointerId: number]: Control;
-        };
-        _capturingControl: {
-            [pointerId: number]: Control;
-        };
-        _shouldBlockPointer: boolean;
-        _layerToDispose: Nullable<Layer>;
-        _linkedControls: Control[];
-        private _isFullscreen;
-        private _fullscreenViewport;
-        private _idealWidth;
-        private _idealHeight;
-        private _useSmallestIdeal;
-        private _renderAtIdealSize;
-        private _focusedControl;
-        private _blockNextFocusCheck;
-        private _renderScale;
-        renderScale: number;
-        background: string;
-        idealWidth: number;
-        idealHeight: number;
-        useSmallestIdeal: boolean;
-        renderAtIdealSize: boolean;
-        readonly layer: Nullable<Layer>;
-        readonly rootContainer: Container;
-        focusedControl: Nullable<IFocusableControl>;
-        isForeground: boolean;
-        constructor(name: string, width: number | undefined, height: number | undefined, scene: Nullable<Scene>, generateMipMaps?: boolean, samplingMode?: number);
-        executeOnAllControls(func: (control: Control) => void, container?: Container): void;
-        markAsDirty(): void;
-        addControl(control: Control): AdvancedDynamicTexture;
-        removeControl(control: Control): AdvancedDynamicTexture;
-        dispose(): void;
-        private _onResize();
-        _getGlobalViewport(scene: Scene): Viewport;
-        getProjectedPosition(position: Vector3, worldMatrix: Matrix): Vector2;
-        private _checkUpdate(camera);
-        private _render();
-        private _doPicking(x, y, type, pointerId, buttonIndex);
-        _cleanControlAfterRemovalFromList(list: {
-            [pointerId: number]: Control;
-        }, control: Control): void;
-        _cleanControlAfterRemoval(control: Control): void;
-        attach(): void;
-        attachToMesh(mesh: AbstractMesh, supportPointerMove?: boolean): void;
-        moveFocusToControl(control: IFocusableControl): void;
-        private _manageFocus();
-        private _attachToOnPointerOut(scene);
-        static CreateForMesh(mesh: AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean): AdvancedDynamicTexture;
-        /**
-         * FullScreenUI is created in a layer. This allows it to be treated like any other layer.
-         * As such, if you have a multi camera setup, you can set the layerMask on the GUI as well.
-         * When the GUI is not Created as FullscreenUI it does not respect the layerMask.
-         * layerMask is set through advancedTexture.layer.layerMask
-         * @param name name for the Texture
-         * @param foreground render in foreground (default is true)
-         * @param scene scene to be rendered in
-         * @param sampling method for scaling to fit screen
-         * @returns AdvancedDynamicTexture
-         */
-        static CreateFullscreenUI(name: string, foreground?: boolean, scene?: Nullable<Scene>, sampling?: number): AdvancedDynamicTexture;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Measure {
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-        constructor(left: number, top: number, width: number, height: number);
-        copyFrom(other: Measure): void;
-        isEqualsTo(other: Measure): boolean;
-        static Empty(): Measure;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Vector2WithInfo extends Vector2 {
-        buttonIndex: number;
-        constructor(source: Vector2, buttonIndex?: number);
-    }
-    class Matrix2D {
-        m: Float32Array;
-        constructor(m00: number, m01: number, m10: number, m11: number, m20: number, m21: number);
-        fromValues(m00: number, m01: number, m10: number, m11: number, m20: number, m21: number): Matrix2D;
-        determinant(): number;
-        invertToRef(result: Matrix2D): Matrix2D;
-        multiplyToRef(other: Matrix2D, result: Matrix2D): Matrix2D;
-        transformCoordinates(x: number, y: number, result: Vector2): Matrix2D;
-        static Identity(): Matrix2D;
-        static TranslationToRef(x: number, y: number, result: Matrix2D): void;
-        static ScalingToRef(x: number, y: number, result: Matrix2D): void;
-        static RotationToRef(angle: number, result: Matrix2D): void;
-        private static _TempPreTranslationMatrix;
-        private static _TempPostTranslationMatrix;
-        private static _TempRotationMatrix;
-        private static _TempScalingMatrix;
-        private static _TempCompose0;
-        private static _TempCompose1;
-        private static _TempCompose2;
-        static ComposeToRef(tx: number, ty: number, angle: number, scaleX: number, scaleY: number, parentMatrix: Nullable<Matrix2D>, result: Matrix2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class ValueAndUnit {
-        unit: number;
-        negativeValueAllowed: boolean;
-        private _value;
-        ignoreAdaptiveScaling: boolean;
-        constructor(value: number, unit?: number, negativeValueAllowed?: boolean);
-        readonly isPercentage: boolean;
-        readonly isPixel: boolean;
-        readonly internalValue: number;
-        getValueInPixel(host: AdvancedDynamicTexture, refValue: number): number;
-        getValue(host: AdvancedDynamicTexture): number;
-        toString(host: AdvancedDynamicTexture): string;
-        fromString(source: string | number): boolean;
-        private static _Regex;
-        private static _UNITMODE_PERCENTAGE;
-        private static _UNITMODE_PIXEL;
-        static readonly UNITMODE_PERCENTAGE: number;
-        static readonly UNITMODE_PIXEL: number;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class MultiLinePoint {
-        private _multiLine;
-        private _x;
-        private _y;
-        private _control;
-        private _mesh;
-        private _controlObserver;
-        private _meshObserver;
-        _point: Vector2;
-        constructor(multiLine: MultiLine);
-        x: string | number;
-        y: string | number;
-        control: Nullable<Control>;
-        mesh: Nullable<AbstractMesh>;
-        translate(): Vector2;
-        private _translatePoint();
-        dispose(): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Control {
-        name: string | undefined;
-        private _alpha;
-        private _alphaSet;
-        private _zIndex;
-        _root: Nullable<Container>;
-        _host: AdvancedDynamicTexture;
-        parent: Nullable<Container>;
-        _currentMeasure: Measure;
-        private _fontFamily;
-        private _fontStyle;
-        private _fontSize;
-        private _font;
-        _width: ValueAndUnit;
-        _height: ValueAndUnit;
-        protected _fontOffset: {
-            ascent: number;
-            height: number;
-            descent: number;
-        };
-        private _color;
-        protected _horizontalAlignment: number;
-        protected _verticalAlignment: number;
-        private _isDirty;
-        _tempParentMeasure: Measure;
-        protected _cachedParentMeasure: Measure;
-        private _paddingLeft;
-        private _paddingRight;
-        private _paddingTop;
-        private _paddingBottom;
-        _left: ValueAndUnit;
-        _top: ValueAndUnit;
-        private _scaleX;
-        private _scaleY;
-        private _rotation;
-        private _transformCenterX;
-        private _transformCenterY;
-        private _transformMatrix;
-        protected _invertTransformMatrix: Matrix2D;
-        protected _transformedPosition: Vector2;
-        private _onlyMeasureMode;
-        private _isMatrixDirty;
-        private _cachedOffsetX;
-        private _cachedOffsetY;
-        private _isVisible;
-        _linkedMesh: Nullable<AbstractMesh>;
-        private _fontSet;
-        private _dummyVector2;
-        private _downCount;
-        private _enterCount;
-        private _doNotRender;
-        private _downPointerIds;
-        isHitTestVisible: boolean;
-        isPointerBlocker: boolean;
-        isFocusInvisible: boolean;
-        shadowOffsetX: number;
-        shadowOffsetY: number;
-        shadowBlur: number;
-        shadowColor: string;
-        protected _linkOffsetX: ValueAndUnit;
-        protected _linkOffsetY: ValueAndUnit;
-        readonly typeName: string;
-        /**
-        * An event triggered when the pointer move over the control.
-        */
-        onPointerMoveObservable: Observable<Vector2>;
-        /**
-        * An event triggered when the pointer move out of the control.
-        */
-        onPointerOutObservable: Observable<Control>;
-        /**
-        * An event triggered when the pointer taps the control
-        */
-        onPointerDownObservable: Observable<Vector2WithInfo>;
-        /**
-        * An event triggered when pointer up
-        */
-        onPointerUpObservable: Observable<Vector2WithInfo>;
-        /**
-        * An event triggered when a control is clicked on
-        */
-        onPointerClickObservable: Observable<Vector2WithInfo>;
-        /**
-        * An event triggered when pointer enters the control
-        */
-        onPointerEnterObservable: Observable<Control>;
-        /**
-        * An event triggered when the control is marked as dirty
-        */
-        onDirtyObservable: Observable<Control>;
-        /**
-       * An event triggered after the control is drawn
-       */
-        onAfterDrawObservable: Observable<Control>;
-        /** Gets or set information about font offsets (used to render and align text) */
-        fontOffset: {
-            ascent: number;
-            height: number;
-            descent: number;
-        };
-        alpha: number;
-        scaleX: number;
-        scaleY: number;
-        rotation: number;
-        transformCenterY: number;
-        transformCenterX: number;
-        horizontalAlignment: number;
-        verticalAlignment: number;
-        width: string | number;
-        readonly widthInPixels: number;
-        height: string | number;
-        readonly heightInPixels: number;
-        fontFamily: string;
-        fontStyle: string;
-        /** @hidden */
-        readonly _isFontSizeInPercentage: boolean;
-        readonly fontSizeInPixels: number;
-        fontSize: string | number;
-        color: string;
-        zIndex: number;
-        notRenderable: boolean;
-        isVisible: boolean;
-        readonly isDirty: boolean;
-        paddingLeft: string | number;
-        readonly paddingLeftInPixels: number;
-        paddingRight: string | number;
-        readonly paddingRightInPixels: number;
-        paddingTop: string | number;
-        readonly paddingTopInPixels: number;
-        paddingBottom: string | number;
-        readonly paddingBottomInPixels: number;
-        left: string | number;
-        readonly leftInPixels: number;
-        top: string | number;
-        readonly topInPixels: number;
-        linkOffsetX: string | number;
-        readonly linkOffsetXInPixels: number;
-        linkOffsetY: string | number;
-        readonly linkOffsetYInPixels: number;
-        readonly centerX: number;
-        readonly centerY: number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        /** @hidden */
-        _resetFontCache(): void;
-        getLocalCoordinates(globalCoordinates: Vector2): Vector2;
-        getLocalCoordinatesToRef(globalCoordinates: Vector2, result: Vector2): Control;
-        getParentLocalCoordinates(globalCoordinates: Vector2): Vector2;
-        moveToVector3(position: Vector3, scene: Scene): void;
-        linkWithMesh(mesh: Nullable<AbstractMesh>): void;
-        _moveToProjectedPosition(projectedPosition: Vector3): void;
-        _markMatrixAsDirty(): void;
-        _markAsDirty(): void;
-        _markAllAsDirty(): void;
-        _link(root: Nullable<Container>, host: AdvancedDynamicTexture): void;
-        protected _transform(context: CanvasRenderingContext2D): void;
-        protected _applyStates(context: CanvasRenderingContext2D): void;
-        protected _processMeasures(parentMeasure: Measure, context: CanvasRenderingContext2D): boolean;
-        protected _clip(context: CanvasRenderingContext2D): void;
-        _measure(): void;
-        protected _computeAlignment(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _preMeasure(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        contains(x: number, y: number): boolean;
-        _processPicking(x: number, y: number, type: number, pointerId: number, buttonIndex: number): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2): void;
-        _onPointerEnter(target: Control): boolean;
-        _onPointerOut(target: Control): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-        forcePointerUp(pointerId?: Nullable<number>): void;
-        _processObservables(type: number, x: number, y: number, pointerId: number, buttonIndex: number): boolean;
-        private _prepareFont();
-        dispose(): void;
-        private static _HORIZONTAL_ALIGNMENT_LEFT;
-        private static _HORIZONTAL_ALIGNMENT_RIGHT;
-        private static _HORIZONTAL_ALIGNMENT_CENTER;
-        private static _VERTICAL_ALIGNMENT_TOP;
-        private static _VERTICAL_ALIGNMENT_BOTTOM;
-        private static _VERTICAL_ALIGNMENT_CENTER;
-        static readonly HORIZONTAL_ALIGNMENT_LEFT: number;
-        static readonly HORIZONTAL_ALIGNMENT_RIGHT: number;
-        static readonly HORIZONTAL_ALIGNMENT_CENTER: number;
-        static readonly VERTICAL_ALIGNMENT_TOP: number;
-        static readonly VERTICAL_ALIGNMENT_BOTTOM: number;
-        static readonly VERTICAL_ALIGNMENT_CENTER: number;
-        private static _FontHeightSizes;
-        static _GetFontOffset(font: string): {
-            ascent: number;
-            height: number;
-            descent: number;
-        };
-        static AddHeader(control: Control, text: string, size: string | number, options: {
-            isHorizontal: boolean;
-            controlFirst: boolean;
-        }): StackPanel;
-        protected static drawEllipse(x: number, y: number, width: number, height: number, context: CanvasRenderingContext2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Container extends Control {
-        name: string | undefined;
-        protected _children: Control[];
-        protected _measureForChildren: Measure;
-        protected _background: string;
-        protected _adaptWidthToChildren: boolean;
-        protected _adaptHeightToChildren: boolean;
-        adaptHeightToChildren: boolean;
-        adaptWidthToChildren: boolean;
-        background: string;
-        readonly children: Control[];
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        getChildByName(name: string): Nullable<Control>;
-        getChildByType(name: string, type: string): Nullable<Control>;
-        containsControl(control: Control): boolean;
-        addControl(control: Control): Container;
-        removeControl(control: Control): Container;
-        _reOrderControl(control: Control): void;
-        _markMatrixAsDirty(): void;
-        _markAllAsDirty(): void;
-        protected _localDraw(context: CanvasRenderingContext2D): void;
-        _link(root: Nullable<Container>, host: AdvancedDynamicTexture): void;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _processPicking(x: number, y: number, type: number, pointerId: number, buttonIndex: number): boolean;
-        protected _clipForChildren(context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        dispose(): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class StackPanel extends Container {
-        name: string | undefined;
-        private _isVertical;
-        private _manualWidth;
-        private _manualHeight;
-        private _doNotTrackManualChanges;
-        private _tempMeasureStore;
-        isVertical: boolean;
-        width: string | number;
-        height: string | number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        protected _preMeasure(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Rectangle extends Container {
-        name: string | undefined;
-        private _thickness;
-        private _cornerRadius;
-        thickness: number;
-        cornerRadius: number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        protected _localDraw(context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        private _drawRoundedRect(context, offset?);
-        protected _clipForChildren(context: CanvasRenderingContext2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Ellipse extends Container {
-        name: string | undefined;
-        private _thickness;
-        thickness: number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        protected _localDraw(context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _clipForChildren(context: CanvasRenderingContext2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Line extends Control {
-        name: string | undefined;
-        private _lineWidth;
-        private _x1;
-        private _y1;
-        private _x2;
-        private _y2;
-        private _dash;
-        private _connectedControl;
-        private _connectedControlDirtyObserver;
-        dash: Array<number>;
-        connectedControl: Control;
-        x1: string | number;
-        y1: string | number;
-        x2: string | number;
-        y2: string | number;
-        lineWidth: number;
-        horizontalAlignment: number;
-        verticalAlignment: number;
-        private readonly _effectiveX2;
-        private readonly _effectiveY2;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _measure(): void;
-        protected _computeAlignment(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        /**
-         * Move one end of the line given 3D cartesian coordinates.
-         * @param position Targeted world position
-         * @param scene Scene
-         * @param end (opt) Set to true to assign x2 and y2 coordinates of the line. Default assign to x1 and y1.
-         */
-        moveToVector3(position: Vector3, scene: Scene, end?: boolean): void;
-        /**
-         * Move one end of the line to a position in screen absolute space.
-         * @param projectedPosition Position in screen absolute space (X, Y)
-         * @param end (opt) Set to true to assign x2 and y2 coordinates of the line. Default assign to x1 and y1.
-         */
-        _moveToProjectedPosition(projectedPosition: Vector3, end?: boolean): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Slider extends Control {
-        name: string | undefined;
-        private _thumbWidth;
-        private _minimum;
-        private _maximum;
-        private _value;
-        private _background;
-        private _borderColor;
-        private _barOffset;
-        private _isThumbCircle;
-        private _isThumbClamped;
-        onValueChangedObservable: Observable<number>;
-        borderColor: string;
-        background: string;
-        barOffset: string | number;
-        readonly barOffsetInPixels: number;
-        thumbWidth: string | number;
-        readonly thumbWidthInPixels: number;
-        minimum: number;
-        maximum: number;
-        value: number;
-        isThumbCircle: boolean;
-        isThumbClamped: boolean;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        private _pointerIsDown;
-        private _updateValueFromPointer(x, y);
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2): void;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Checkbox extends Control {
-        name: string | undefined;
-        private _isChecked;
-        private _background;
-        private _checkSizeRatio;
-        private _thickness;
-        thickness: number;
-        onIsCheckedChangedObservable: Observable<boolean>;
-        checkSizeRatio: number;
-        background: string;
-        isChecked: boolean;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class RadioButton extends Control {
-        name: string | undefined;
-        private _isChecked;
-        private _background;
-        private _checkSizeRatio;
-        private _thickness;
-        thickness: number;
-        group: string;
-        onIsCheckedChangedObservable: Observable<boolean>;
-        checkSizeRatio: number;
-        background: string;
-        isChecked: boolean;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class TextBlock extends Control {
-        /**
-         * Defines the name of the control
-         */
-        name: string | undefined;
-        private _text;
-        private _textWrapping;
-        private _textHorizontalAlignment;
-        private _textVerticalAlignment;
-        private _lines;
-        private _resizeToFit;
-        private _lineSpacing;
-        private _outlineWidth;
-        private _outlineColor;
-        /**
-        * An event triggered after the text is changed
-        */
-        onTextChangedObservable: Observable<TextBlock>;
-        /**
-        * An event triggered after the text was broken up into lines
-        */
-        onLinesReadyObservable: Observable<TextBlock>;
-        /**
-         * Return the line list (you may need to use the onLinesReadyObservable to make sure the list is ready)
-         */
-        readonly lines: any[];
-        /**
-         * Gets or sets an boolean indicating that the TextBlock will be resized to fit container
-         */
-        /**
-         * Gets or sets an boolean indicating that the TextBlock will be resized to fit container
-         */
-        resizeToFit: boolean;
-        /**
-         * Gets or sets a boolean indicating if text must be wrapped
-         */
-        /**
-         * Gets or sets a boolean indicating if text must be wrapped
-         */
-        textWrapping: boolean;
-        /**
-         * Gets or sets text to display
-         */
-        /**
-         * Gets or sets text to display
-         */
-        text: string;
-        /**
-         * Gets or sets text horizontal alignment (BABYLON.GUI.Control.HORIZONTAL_ALIGNMENT_CENTER by default)
-         */
-        /**
-         * Gets or sets text horizontal alignment (BABYLON.GUI.Control.HORIZONTAL_ALIGNMENT_CENTER by default)
-         */
-        textHorizontalAlignment: number;
-        /**
-         * Gets or sets text vertical alignment (BABYLON.GUI.Control.VERTICAL_ALIGNMENT_CENTER by default)
-         */
-        /**
-         * Gets or sets text vertical alignment (BABYLON.GUI.Control.VERTICAL_ALIGNMENT_CENTER by default)
-         */
-        textVerticalAlignment: number;
-        /**
-         * Gets or sets line spacing value
-         */
-        /**
-         * Gets or sets line spacing value
-         */
-        lineSpacing: string | number;
-        /**
-         * Gets or sets outlineWidth of the text to display
-         */
-        /**
-         * Gets or sets outlineWidth of the text to display
-         */
-        outlineWidth: number;
-        /**
-         * Gets or sets outlineColor of the text to display
-         */
-        /**
-         * Gets or sets outlineColor of the text to display
-         */
-        outlineColor: string;
-        /**
-         * Creates a new TextBlock object
-         * @param name defines the name of the control
-         * @param text defines the text to display (emptry string by default)
-         */
-        constructor(
-            /**
-             * Defines the name of the control
-             */
-            name?: string | undefined, text?: string);
-        protected _getTypeName(): string;
-        private _drawText(text, textWidth, y, context);
-        /** @hidden */
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _applyStates(context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _parseLine(line: string | undefined, context: CanvasRenderingContext2D): object;
-        protected _parseLineWithTextWrapping(line: string | undefined, context: CanvasRenderingContext2D): object;
-        protected _renderLines(context: CanvasRenderingContext2D): void;
-        dispose(): void;
-    }
-}
-
-
-declare var DOMImage: new (width?: number | undefined, height?: number | undefined) => HTMLImageElement;
-declare module BABYLON.GUI {
-    class Image extends Control {
-        name: string | undefined;
-        private _domImage;
-        private _imageWidth;
-        private _imageHeight;
-        private _loaded;
-        private _stretch;
-        private _source;
-        private _autoScale;
-        private _sourceLeft;
-        private _sourceTop;
-        private _sourceWidth;
-        private _sourceHeight;
-        private _cellWidth;
-        private _cellHeight;
-        private _cellId;
-        sourceLeft: number;
-        sourceTop: number;
-        sourceWidth: number;
-        sourceHeight: number;
-        autoScale: boolean;
-        stretch: number;
-        domImage: HTMLImageElement;
-        private _onImageLoaded();
-        source: Nullable<string>;
-        cellWidth: number;
-        cellHeight: number;
-        cellId: number;
-        constructor(name?: string | undefined, url?: Nullable<string>);
-        protected _getTypeName(): string;
-        synchronizeSizeWithContent(): void;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        private static _STRETCH_NONE;
-        private static _STRETCH_FILL;
-        private static _STRETCH_UNIFORM;
-        private static _STRETCH_EXTEND;
-        static readonly STRETCH_NONE: number;
-        static readonly STRETCH_FILL: number;
-        static readonly STRETCH_UNIFORM: number;
-        static readonly STRETCH_EXTEND: number;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Button extends Rectangle {
-        name: string | undefined;
-        pointerEnterAnimation: () => void;
-        pointerOutAnimation: () => void;
-        pointerDownAnimation: () => void;
-        pointerUpAnimation: () => void;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _processPicking(x: number, y: number, type: number, pointerId: number, buttonIndex: number): boolean;
-        _onPointerEnter(target: Control): boolean;
-        _onPointerOut(target: Control): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-        static CreateImageButton(name: string, text: string, imageUrl: string): Button;
-        static CreateImageOnlyButton(name: string, imageUrl: string): Button;
-        static CreateSimpleButton(name: string, text: string): Button;
-        static CreateImageWithCenterTextButton(name: string, text: string, imageUrl: string): Button;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class ColorPicker extends Control {
-        name: string | undefined;
-        private _colorWheelCanvas;
-        private _value;
-        private _tmpColor;
-        private _pointerStartedOnSquare;
-        private _pointerStartedOnWheel;
-        private _squareLeft;
-        private _squareTop;
-        private _squareSize;
-        private _h;
-        private _s;
-        private _v;
-        onValueChangedObservable: Observable<Color3>;
-        value: Color3;
-        width: string | number;
-        height: string | number;
-        size: string | number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        private _updateSquareProps();
-        private _drawGradientSquare(hueValue, left, top, width, height, context);
-        private _drawCircle(centerX, centerY, radius, context);
-        private _createColorWheelCanvas(radius, thickness);
-        private _RGBtoHSV(color, result);
-        private _HSVtoRGB(hue, saturation, value, result);
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        private _pointerIsDown;
-        private _updateValueFromPointer(x, y);
-        private _isPointOnSquare(coordinates);
-        private _isPointOnWheel(coordinates);
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2): void;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class InputText extends Control implements IFocusableControl {
-        name: string | undefined;
-        private _text;
-        private _placeholderText;
-        private _background;
-        private _focusedBackground;
-        private _placeholderColor;
-        private _thickness;
-        private _margin;
-        private _autoStretchWidth;
-        private _maxWidth;
-        private _isFocused;
-        private _blinkTimeout;
-        private _blinkIsEven;
-        private _cursorOffset;
-        private _scrollLeft;
-        private _textWidth;
-        private _clickedCoordinate;
-        promptMessage: string;
-        onTextChangedObservable: Observable<InputText>;
-        onFocusObservable: Observable<InputText>;
-        onBlurObservable: Observable<InputText>;
-        maxWidth: string | number;
-        readonly maxWidthInPixels: number;
-        margin: string;
-        readonly marginInPixels: number;
-        autoStretchWidth: boolean;
-        thickness: number;
-        focusedBackground: string;
-        background: string;
-        placeholderColor: string;
-        placeholderText: string;
-        text: string;
-        width: string | number;
-        constructor(name?: string | undefined, text?: string);
-        onBlur(): void;
-        onFocus(): void;
-        protected _getTypeName(): string;
-        processKey(keyCode: number, key?: string): void;
-        processKeyboard(evt: KeyboardEvent): void;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-        dispose(): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class KeyPropertySet {
-        width?: string;
-        height?: string;
-        paddingLeft?: string;
-        paddingRight?: string;
-        paddingTop?: string;
-        paddingBottom?: string;
-        color?: string;
-        background?: string;
-    }
-    class VirtualKeyboard extends StackPanel {
-        onKeyPressObservable: Observable<string>;
-        defaultButtonWidth: string;
-        defaultButtonHeight: string;
-        defaultButtonPaddingLeft: string;
-        defaultButtonPaddingRight: string;
-        defaultButtonPaddingTop: string;
-        defaultButtonPaddingBottom: string;
-        defaultButtonColor: string;
-        defaultButtonBackground: string;
-        shiftButtonColor: string;
-        selectedShiftThickness: number;
-        shiftState: number;
-        protected _getTypeName(): string;
-        private _createKey(key, propertySet);
-        addKeysRow(keys: Array<string>, propertySets?: Array<KeyPropertySet>): void;
-        applyShiftState(shiftState: number): void;
-        private _connectedInputText;
-        private _onFocusObserver;
-        private _onBlurObserver;
-        private _onKeyPressObserver;
-        readonly connectedInputText: Nullable<InputText>;
-        connect(input: InputText): void;
-        disconnect(): void;
-        static CreateDefaultLayout(): VirtualKeyboard;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class MultiLine extends Control {
-        name: string | undefined;
-        private _lineWidth;
-        private _dash;
-        private _points;
-        private _minX;
-        private _minY;
-        private _maxX;
-        private _maxY;
-        constructor(name?: string | undefined);
-        dash: Array<number>;
-        getAt(index: number): MultiLinePoint;
-        onPointUpdate: () => void;
-        add(...items: (AbstractMesh | Control | {
-            x: string | number;
-            y: string | number;
-        })[]): MultiLinePoint[];
-        push(item?: (AbstractMesh | Control | {
-            x: string | number;
-            y: string | number;
-        })): MultiLinePoint;
-        remove(value: number | MultiLinePoint): void;
-        lineWidth: number;
-        horizontalAlignment: number;
-        verticalAlignment: number;
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _measure(): void;
-        protected _computeAlignment(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        dispose(): void;
-    }
-}

dist/preview release/gui/babylon.gui.module.d.ts

@@ -1,923 +0,0 @@
-
-
-declare module 'babylonjs-gui' { 
-    export = BABYLON.GUI; 
-}
-
-declare module BABYLON.GUI {
-    interface IFocusableControl {
-        onFocus(): void;
-        onBlur(): void;
-        processKeyboard(evt: KeyboardEvent): void;
-    }
-    class AdvancedDynamicTexture extends DynamicTexture {
-        private _isDirty;
-        private _renderObserver;
-        private _resizeObserver;
-        private _preKeyboardObserver;
-        private _pointerMoveObserver;
-        private _pointerObserver;
-        private _canvasPointerOutObserver;
-        private _background;
-        _rootContainer: Container;
-        _lastPickedControl: Control;
-        _lastControlOver: {
-            [pointerId: number]: Control;
-        };
-        _lastControlDown: {
-            [pointerId: number]: Control;
-        };
-        _capturingControl: {
-            [pointerId: number]: Control;
-        };
-        _shouldBlockPointer: boolean;
-        _layerToDispose: Nullable<Layer>;
-        _linkedControls: Control[];
-        private _isFullscreen;
-        private _fullscreenViewport;
-        private _idealWidth;
-        private _idealHeight;
-        private _useSmallestIdeal;
-        private _renderAtIdealSize;
-        private _focusedControl;
-        private _blockNextFocusCheck;
-        private _renderScale;
-        renderScale: number;
-        background: string;
-        idealWidth: number;
-        idealHeight: number;
-        useSmallestIdeal: boolean;
-        renderAtIdealSize: boolean;
-        readonly layer: Nullable<Layer>;
-        readonly rootContainer: Container;
-        focusedControl: Nullable<IFocusableControl>;
-        isForeground: boolean;
-        constructor(name: string, width: number | undefined, height: number | undefined, scene: Nullable<Scene>, generateMipMaps?: boolean, samplingMode?: number);
-        executeOnAllControls(func: (control: Control) => void, container?: Container): void;
-        markAsDirty(): void;
-        addControl(control: Control): AdvancedDynamicTexture;
-        removeControl(control: Control): AdvancedDynamicTexture;
-        dispose(): void;
-        private _onResize();
-        _getGlobalViewport(scene: Scene): Viewport;
-        getProjectedPosition(position: Vector3, worldMatrix: Matrix): Vector2;
-        private _checkUpdate(camera);
-        private _render();
-        private _doPicking(x, y, type, pointerId, buttonIndex);
-        _cleanControlAfterRemovalFromList(list: {
-            [pointerId: number]: Control;
-        }, control: Control): void;
-        _cleanControlAfterRemoval(control: Control): void;
-        attach(): void;
-        attachToMesh(mesh: AbstractMesh, supportPointerMove?: boolean): void;
-        moveFocusToControl(control: IFocusableControl): void;
-        private _manageFocus();
-        private _attachToOnPointerOut(scene);
-        static CreateForMesh(mesh: AbstractMesh, width?: number, height?: number, supportPointerMove?: boolean): AdvancedDynamicTexture;
-        /**
-         * FullScreenUI is created in a layer. This allows it to be treated like any other layer.
-         * As such, if you have a multi camera setup, you can set the layerMask on the GUI as well.
-         * When the GUI is not Created as FullscreenUI it does not respect the layerMask.
-         * layerMask is set through advancedTexture.layer.layerMask
-         * @param name name for the Texture
-         * @param foreground render in foreground (default is true)
-         * @param scene scene to be rendered in
-         * @param sampling method for scaling to fit screen
-         * @returns AdvancedDynamicTexture
-         */
-        static CreateFullscreenUI(name: string, foreground?: boolean, scene?: Nullable<Scene>, sampling?: number): AdvancedDynamicTexture;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Measure {
-        left: number;
-        top: number;
-        width: number;
-        height: number;
-        constructor(left: number, top: number, width: number, height: number);
-        copyFrom(other: Measure): void;
-        isEqualsTo(other: Measure): boolean;
-        static Empty(): Measure;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Vector2WithInfo extends Vector2 {
-        buttonIndex: number;
-        constructor(source: Vector2, buttonIndex?: number);
-    }
-    class Matrix2D {
-        m: Float32Array;
-        constructor(m00: number, m01: number, m10: number, m11: number, m20: number, m21: number);
-        fromValues(m00: number, m01: number, m10: number, m11: number, m20: number, m21: number): Matrix2D;
-        determinant(): number;
-        invertToRef(result: Matrix2D): Matrix2D;
-        multiplyToRef(other: Matrix2D, result: Matrix2D): Matrix2D;
-        transformCoordinates(x: number, y: number, result: Vector2): Matrix2D;
-        static Identity(): Matrix2D;
-        static TranslationToRef(x: number, y: number, result: Matrix2D): void;
-        static ScalingToRef(x: number, y: number, result: Matrix2D): void;
-        static RotationToRef(angle: number, result: Matrix2D): void;
-        private static _TempPreTranslationMatrix;
-        private static _TempPostTranslationMatrix;
-        private static _TempRotationMatrix;
-        private static _TempScalingMatrix;
-        private static _TempCompose0;
-        private static _TempCompose1;
-        private static _TempCompose2;
-        static ComposeToRef(tx: number, ty: number, angle: number, scaleX: number, scaleY: number, parentMatrix: Nullable<Matrix2D>, result: Matrix2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class ValueAndUnit {
-        unit: number;
-        negativeValueAllowed: boolean;
-        private _value;
-        ignoreAdaptiveScaling: boolean;
-        constructor(value: number, unit?: number, negativeValueAllowed?: boolean);
-        readonly isPercentage: boolean;
-        readonly isPixel: boolean;
-        readonly internalValue: number;
-        getValueInPixel(host: AdvancedDynamicTexture, refValue: number): number;
-        getValue(host: AdvancedDynamicTexture): number;
-        toString(host: AdvancedDynamicTexture): string;
-        fromString(source: string | number): boolean;
-        private static _Regex;
-        private static _UNITMODE_PERCENTAGE;
-        private static _UNITMODE_PIXEL;
-        static readonly UNITMODE_PERCENTAGE: number;
-        static readonly UNITMODE_PIXEL: number;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class MultiLinePoint {
-        private _multiLine;
-        private _x;
-        private _y;
-        private _control;
-        private _mesh;
-        private _controlObserver;
-        private _meshObserver;
-        _point: Vector2;
-        constructor(multiLine: MultiLine);
-        x: string | number;
-        y: string | number;
-        control: Nullable<Control>;
-        mesh: Nullable<AbstractMesh>;
-        translate(): Vector2;
-        private _translatePoint();
-        dispose(): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Control {
-        name: string | undefined;
-        private _alpha;
-        private _alphaSet;
-        private _zIndex;
-        _root: Nullable<Container>;
-        _host: AdvancedDynamicTexture;
-        parent: Nullable<Container>;
-        _currentMeasure: Measure;
-        private _fontFamily;
-        private _fontStyle;
-        private _fontSize;
-        private _font;
-        _width: ValueAndUnit;
-        _height: ValueAndUnit;
-        protected _fontOffset: {
-            ascent: number;
-            height: number;
-            descent: number;
-        };
-        private _color;
-        protected _horizontalAlignment: number;
-        protected _verticalAlignment: number;
-        private _isDirty;
-        _tempParentMeasure: Measure;
-        protected _cachedParentMeasure: Measure;
-        private _paddingLeft;
-        private _paddingRight;
-        private _paddingTop;
-        private _paddingBottom;
-        _left: ValueAndUnit;
-        _top: ValueAndUnit;
-        private _scaleX;
-        private _scaleY;
-        private _rotation;
-        private _transformCenterX;
-        private _transformCenterY;
-        private _transformMatrix;
-        protected _invertTransformMatrix: Matrix2D;
-        protected _transformedPosition: Vector2;
-        private _onlyMeasureMode;
-        private _isMatrixDirty;
-        private _cachedOffsetX;
-        private _cachedOffsetY;
-        private _isVisible;
-        _linkedMesh: Nullable<AbstractMesh>;
-        private _fontSet;
-        private _dummyVector2;
-        private _downCount;
-        private _enterCount;
-        private _doNotRender;
-        private _downPointerIds;
-        isHitTestVisible: boolean;
-        isPointerBlocker: boolean;
-        isFocusInvisible: boolean;
-        shadowOffsetX: number;
-        shadowOffsetY: number;
-        shadowBlur: number;
-        shadowColor: string;
-        protected _linkOffsetX: ValueAndUnit;
-        protected _linkOffsetY: ValueAndUnit;
-        readonly typeName: string;
-        /**
-        * An event triggered when the pointer move over the control.
-        */
-        onPointerMoveObservable: Observable<Vector2>;
-        /**
-        * An event triggered when the pointer move out of the control.
-        */
-        onPointerOutObservable: Observable<Control>;
-        /**
-        * An event triggered when the pointer taps the control
-        */
-        onPointerDownObservable: Observable<Vector2WithInfo>;
-        /**
-        * An event triggered when pointer up
-        */
-        onPointerUpObservable: Observable<Vector2WithInfo>;
-        /**
-        * An event triggered when a control is clicked on
-        */
-        onPointerClickObservable: Observable<Vector2WithInfo>;
-        /**
-        * An event triggered when pointer enters the control
-        */
-        onPointerEnterObservable: Observable<Control>;
-        /**
-        * An event triggered when the control is marked as dirty
-        */
-        onDirtyObservable: Observable<Control>;
-        /**
-       * An event triggered after the control is drawn
-       */
-        onAfterDrawObservable: Observable<Control>;
-        /** Gets or set information about font offsets (used to render and align text) */
-        fontOffset: {
-            ascent: number;
-            height: number;
-            descent: number;
-        };
-        alpha: number;
-        scaleX: number;
-        scaleY: number;
-        rotation: number;
-        transformCenterY: number;
-        transformCenterX: number;
-        horizontalAlignment: number;
-        verticalAlignment: number;
-        width: string | number;
-        readonly widthInPixels: number;
-        height: string | number;
-        readonly heightInPixels: number;
-        fontFamily: string;
-        fontStyle: string;
-        /** @hidden */
-        readonly _isFontSizeInPercentage: boolean;
-        readonly fontSizeInPixels: number;
-        fontSize: string | number;
-        color: string;
-        zIndex: number;
-        notRenderable: boolean;
-        isVisible: boolean;
-        readonly isDirty: boolean;
-        paddingLeft: string | number;
-        readonly paddingLeftInPixels: number;
-        paddingRight: string | number;
-        readonly paddingRightInPixels: number;
-        paddingTop: string | number;
-        readonly paddingTopInPixels: number;
-        paddingBottom: string | number;
-        readonly paddingBottomInPixels: number;
-        left: string | number;
-        readonly leftInPixels: number;
-        top: string | number;
-        readonly topInPixels: number;
-        linkOffsetX: string | number;
-        readonly linkOffsetXInPixels: number;
-        linkOffsetY: string | number;
-        readonly linkOffsetYInPixels: number;
-        readonly centerX: number;
-        readonly centerY: number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        /** @hidden */
-        _resetFontCache(): void;
-        getLocalCoordinates(globalCoordinates: Vector2): Vector2;
-        getLocalCoordinatesToRef(globalCoordinates: Vector2, result: Vector2): Control;
-        getParentLocalCoordinates(globalCoordinates: Vector2): Vector2;
-        moveToVector3(position: Vector3, scene: Scene): void;
-        linkWithMesh(mesh: Nullable<AbstractMesh>): void;
-        _moveToProjectedPosition(projectedPosition: Vector3): void;
-        _markMatrixAsDirty(): void;
-        _markAsDirty(): void;
-        _markAllAsDirty(): void;
-        _link(root: Nullable<Container>, host: AdvancedDynamicTexture): void;
-        protected _transform(context: CanvasRenderingContext2D): void;
-        protected _applyStates(context: CanvasRenderingContext2D): void;
-        protected _processMeasures(parentMeasure: Measure, context: CanvasRenderingContext2D): boolean;
-        protected _clip(context: CanvasRenderingContext2D): void;
-        _measure(): void;
-        protected _computeAlignment(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _preMeasure(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        contains(x: number, y: number): boolean;
-        _processPicking(x: number, y: number, type: number, pointerId: number, buttonIndex: number): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2): void;
-        _onPointerEnter(target: Control): boolean;
-        _onPointerOut(target: Control): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-        forcePointerUp(pointerId?: Nullable<number>): void;
-        _processObservables(type: number, x: number, y: number, pointerId: number, buttonIndex: number): boolean;
-        private _prepareFont();
-        dispose(): void;
-        private static _HORIZONTAL_ALIGNMENT_LEFT;
-        private static _HORIZONTAL_ALIGNMENT_RIGHT;
-        private static _HORIZONTAL_ALIGNMENT_CENTER;
-        private static _VERTICAL_ALIGNMENT_TOP;
-        private static _VERTICAL_ALIGNMENT_BOTTOM;
-        private static _VERTICAL_ALIGNMENT_CENTER;
-        static readonly HORIZONTAL_ALIGNMENT_LEFT: number;
-        static readonly HORIZONTAL_ALIGNMENT_RIGHT: number;
-        static readonly HORIZONTAL_ALIGNMENT_CENTER: number;
-        static readonly VERTICAL_ALIGNMENT_TOP: number;
-        static readonly VERTICAL_ALIGNMENT_BOTTOM: number;
-        static readonly VERTICAL_ALIGNMENT_CENTER: number;
-        private static _FontHeightSizes;
-        static _GetFontOffset(font: string): {
-            ascent: number;
-            height: number;
-            descent: number;
-        };
-        static AddHeader(control: Control, text: string, size: string | number, options: {
-            isHorizontal: boolean;
-            controlFirst: boolean;
-        }): StackPanel;
-        protected static drawEllipse(x: number, y: number, width: number, height: number, context: CanvasRenderingContext2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Container extends Control {
-        name: string | undefined;
-        protected _children: Control[];
-        protected _measureForChildren: Measure;
-        protected _background: string;
-        protected _adaptWidthToChildren: boolean;
-        protected _adaptHeightToChildren: boolean;
-        adaptHeightToChildren: boolean;
-        adaptWidthToChildren: boolean;
-        background: string;
-        readonly children: Control[];
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        getChildByName(name: string): Nullable<Control>;
-        getChildByType(name: string, type: string): Nullable<Control>;
-        containsControl(control: Control): boolean;
-        addControl(control: Control): Container;
-        removeControl(control: Control): Container;
-        _reOrderControl(control: Control): void;
-        _markMatrixAsDirty(): void;
-        _markAllAsDirty(): void;
-        protected _localDraw(context: CanvasRenderingContext2D): void;
-        _link(root: Nullable<Container>, host: AdvancedDynamicTexture): void;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _processPicking(x: number, y: number, type: number, pointerId: number, buttonIndex: number): boolean;
-        protected _clipForChildren(context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        dispose(): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class StackPanel extends Container {
-        name: string | undefined;
-        private _isVertical;
-        private _manualWidth;
-        private _manualHeight;
-        private _doNotTrackManualChanges;
-        private _tempMeasureStore;
-        isVertical: boolean;
-        width: string | number;
-        height: string | number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        protected _preMeasure(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Rectangle extends Container {
-        name: string | undefined;
-        private _thickness;
-        private _cornerRadius;
-        thickness: number;
-        cornerRadius: number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        protected _localDraw(context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        private _drawRoundedRect(context, offset?);
-        protected _clipForChildren(context: CanvasRenderingContext2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Ellipse extends Container {
-        name: string | undefined;
-        private _thickness;
-        thickness: number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        protected _localDraw(context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _clipForChildren(context: CanvasRenderingContext2D): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Line extends Control {
-        name: string | undefined;
-        private _lineWidth;
-        private _x1;
-        private _y1;
-        private _x2;
-        private _y2;
-        private _dash;
-        private _connectedControl;
-        private _connectedControlDirtyObserver;
-        dash: Array<number>;
-        connectedControl: Control;
-        x1: string | number;
-        y1: string | number;
-        x2: string | number;
-        y2: string | number;
-        lineWidth: number;
-        horizontalAlignment: number;
-        verticalAlignment: number;
-        private readonly _effectiveX2;
-        private readonly _effectiveY2;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _measure(): void;
-        protected _computeAlignment(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        /**
-         * Move one end of the line given 3D cartesian coordinates.
-         * @param position Targeted world position
-         * @param scene Scene
-         * @param end (opt) Set to true to assign x2 and y2 coordinates of the line. Default assign to x1 and y1.
-         */
-        moveToVector3(position: Vector3, scene: Scene, end?: boolean): void;
-        /**
-         * Move one end of the line to a position in screen absolute space.
-         * @param projectedPosition Position in screen absolute space (X, Y)
-         * @param end (opt) Set to true to assign x2 and y2 coordinates of the line. Default assign to x1 and y1.
-         */
-        _moveToProjectedPosition(projectedPosition: Vector3, end?: boolean): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Slider extends Control {
-        name: string | undefined;
-        private _thumbWidth;
-        private _minimum;
-        private _maximum;
-        private _value;
-        private _background;
-        private _borderColor;
-        private _barOffset;
-        private _isThumbCircle;
-        private _isThumbClamped;
-        onValueChangedObservable: Observable<number>;
-        borderColor: string;
-        background: string;
-        barOffset: string | number;
-        readonly barOffsetInPixels: number;
-        thumbWidth: string | number;
-        readonly thumbWidthInPixels: number;
-        minimum: number;
-        maximum: number;
-        value: number;
-        isThumbCircle: boolean;
-        isThumbClamped: boolean;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        private _pointerIsDown;
-        private _updateValueFromPointer(x, y);
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2): void;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Checkbox extends Control {
-        name: string | undefined;
-        private _isChecked;
-        private _background;
-        private _checkSizeRatio;
-        private _thickness;
-        thickness: number;
-        onIsCheckedChangedObservable: Observable<boolean>;
-        checkSizeRatio: number;
-        background: string;
-        isChecked: boolean;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class RadioButton extends Control {
-        name: string | undefined;
-        private _isChecked;
-        private _background;
-        private _checkSizeRatio;
-        private _thickness;
-        thickness: number;
-        group: string;
-        onIsCheckedChangedObservable: Observable<boolean>;
-        checkSizeRatio: number;
-        background: string;
-        isChecked: boolean;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class TextBlock extends Control {
-        /**
-         * Defines the name of the control
-         */
-        name: string | undefined;
-        private _text;
-        private _textWrapping;
-        private _textHorizontalAlignment;
-        private _textVerticalAlignment;
-        private _lines;
-        private _resizeToFit;
-        private _lineSpacing;
-        private _outlineWidth;
-        private _outlineColor;
-        /**
-        * An event triggered after the text is changed
-        */
-        onTextChangedObservable: Observable<TextBlock>;
-        /**
-        * An event triggered after the text was broken up into lines
-        */
-        onLinesReadyObservable: Observable<TextBlock>;
-        /**
-         * Return the line list (you may need to use the onLinesReadyObservable to make sure the list is ready)
-         */
-        readonly lines: any[];
-        /**
-         * Gets or sets an boolean indicating that the TextBlock will be resized to fit container
-         */
-        /**
-         * Gets or sets an boolean indicating that the TextBlock will be resized to fit container
-         */
-        resizeToFit: boolean;
-        /**
-         * Gets or sets a boolean indicating if text must be wrapped
-         */
-        /**
-         * Gets or sets a boolean indicating if text must be wrapped
-         */
-        textWrapping: boolean;
-        /**
-         * Gets or sets text to display
-         */
-        /**
-         * Gets or sets text to display
-         */
-        text: string;
-        /**
-         * Gets or sets text horizontal alignment (BABYLON.GUI.Control.HORIZONTAL_ALIGNMENT_CENTER by default)
-         */
-        /**
-         * Gets or sets text horizontal alignment (BABYLON.GUI.Control.HORIZONTAL_ALIGNMENT_CENTER by default)
-         */
-        textHorizontalAlignment: number;
-        /**
-         * Gets or sets text vertical alignment (BABYLON.GUI.Control.VERTICAL_ALIGNMENT_CENTER by default)
-         */
-        /**
-         * Gets or sets text vertical alignment (BABYLON.GUI.Control.VERTICAL_ALIGNMENT_CENTER by default)
-         */
-        textVerticalAlignment: number;
-        /**
-         * Gets or sets line spacing value
-         */
-        /**
-         * Gets or sets line spacing value
-         */
-        lineSpacing: string | number;
-        /**
-         * Gets or sets outlineWidth of the text to display
-         */
-        /**
-         * Gets or sets outlineWidth of the text to display
-         */
-        outlineWidth: number;
-        /**
-         * Gets or sets outlineColor of the text to display
-         */
-        /**
-         * Gets or sets outlineColor of the text to display
-         */
-        outlineColor: string;
-        /**
-         * Creates a new TextBlock object
-         * @param name defines the name of the control
-         * @param text defines the text to display (emptry string by default)
-         */
-        constructor(
-            /**
-             * Defines the name of the control
-             */
-            name?: string | undefined, text?: string);
-        protected _getTypeName(): string;
-        private _drawText(text, textWidth, y, context);
-        /** @hidden */
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _applyStates(context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _parseLine(line: string | undefined, context: CanvasRenderingContext2D): object;
-        protected _parseLineWithTextWrapping(line: string | undefined, context: CanvasRenderingContext2D): object;
-        protected _renderLines(context: CanvasRenderingContext2D): void;
-        dispose(): void;
-    }
-}
-
-
-declare var DOMImage: new (width?: number | undefined, height?: number | undefined) => HTMLImageElement;
-declare module BABYLON.GUI {
-    class Image extends Control {
-        name: string | undefined;
-        private _domImage;
-        private _imageWidth;
-        private _imageHeight;
-        private _loaded;
-        private _stretch;
-        private _source;
-        private _autoScale;
-        private _sourceLeft;
-        private _sourceTop;
-        private _sourceWidth;
-        private _sourceHeight;
-        private _cellWidth;
-        private _cellHeight;
-        private _cellId;
-        sourceLeft: number;
-        sourceTop: number;
-        sourceWidth: number;
-        sourceHeight: number;
-        autoScale: boolean;
-        stretch: number;
-        domImage: HTMLImageElement;
-        private _onImageLoaded();
-        source: Nullable<string>;
-        cellWidth: number;
-        cellHeight: number;
-        cellId: number;
-        constructor(name?: string | undefined, url?: Nullable<string>);
-        protected _getTypeName(): string;
-        synchronizeSizeWithContent(): void;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        private static _STRETCH_NONE;
-        private static _STRETCH_FILL;
-        private static _STRETCH_UNIFORM;
-        private static _STRETCH_EXTEND;
-        static readonly STRETCH_NONE: number;
-        static readonly STRETCH_FILL: number;
-        static readonly STRETCH_UNIFORM: number;
-        static readonly STRETCH_EXTEND: number;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class Button extends Rectangle {
-        name: string | undefined;
-        pointerEnterAnimation: () => void;
-        pointerOutAnimation: () => void;
-        pointerDownAnimation: () => void;
-        pointerUpAnimation: () => void;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        _processPicking(x: number, y: number, type: number, pointerId: number, buttonIndex: number): boolean;
-        _onPointerEnter(target: Control): boolean;
-        _onPointerOut(target: Control): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-        static CreateImageButton(name: string, text: string, imageUrl: string): Button;
-        static CreateImageOnlyButton(name: string, imageUrl: string): Button;
-        static CreateSimpleButton(name: string, text: string): Button;
-        static CreateImageWithCenterTextButton(name: string, text: string, imageUrl: string): Button;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class ColorPicker extends Control {
-        name: string | undefined;
-        private _colorWheelCanvas;
-        private _value;
-        private _tmpColor;
-        private _pointerStartedOnSquare;
-        private _pointerStartedOnWheel;
-        private _squareLeft;
-        private _squareTop;
-        private _squareSize;
-        private _h;
-        private _s;
-        private _v;
-        onValueChangedObservable: Observable<Color3>;
-        value: Color3;
-        width: string | number;
-        height: string | number;
-        size: string | number;
-        constructor(name?: string | undefined);
-        protected _getTypeName(): string;
-        private _updateSquareProps();
-        private _drawGradientSquare(hueValue, left, top, width, height, context);
-        private _drawCircle(centerX, centerY, radius, context);
-        private _createColorWheelCanvas(radius, thickness);
-        private _RGBtoHSV(color, result);
-        private _HSVtoRGB(hue, saturation, value, result);
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        private _pointerIsDown;
-        private _updateValueFromPointer(x, y);
-        private _isPointOnSquare(coordinates);
-        private _isPointOnWheel(coordinates);
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerMove(target: Control, coordinates: Vector2): void;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class InputText extends Control implements IFocusableControl {
-        name: string | undefined;
-        private _text;
-        private _placeholderText;
-        private _background;
-        private _focusedBackground;
-        private _placeholderColor;
-        private _thickness;
-        private _margin;
-        private _autoStretchWidth;
-        private _maxWidth;
-        private _isFocused;
-        private _blinkTimeout;
-        private _blinkIsEven;
-        private _cursorOffset;
-        private _scrollLeft;
-        private _textWidth;
-        private _clickedCoordinate;
-        promptMessage: string;
-        onTextChangedObservable: Observable<InputText>;
-        onFocusObservable: Observable<InputText>;
-        onBlurObservable: Observable<InputText>;
-        maxWidth: string | number;
-        readonly maxWidthInPixels: number;
-        margin: string;
-        readonly marginInPixels: number;
-        autoStretchWidth: boolean;
-        thickness: number;
-        focusedBackground: string;
-        background: string;
-        placeholderColor: string;
-        placeholderText: string;
-        text: string;
-        width: string | number;
-        constructor(name?: string | undefined, text?: string);
-        onBlur(): void;
-        onFocus(): void;
-        protected _getTypeName(): string;
-        processKey(keyCode: number, key?: string): void;
-        processKeyboard(evt: KeyboardEvent): void;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _onPointerDown(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number): boolean;
-        _onPointerUp(target: Control, coordinates: Vector2, pointerId: number, buttonIndex: number, notifyClick: boolean): void;
-        dispose(): void;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class KeyPropertySet {
-        width?: string;
-        height?: string;
-        paddingLeft?: string;
-        paddingRight?: string;
-        paddingTop?: string;
-        paddingBottom?: string;
-        color?: string;
-        background?: string;
-    }
-    class VirtualKeyboard extends StackPanel {
-        onKeyPressObservable: Observable<string>;
-        defaultButtonWidth: string;
-        defaultButtonHeight: string;
-        defaultButtonPaddingLeft: string;
-        defaultButtonPaddingRight: string;
-        defaultButtonPaddingTop: string;
-        defaultButtonPaddingBottom: string;
-        defaultButtonColor: string;
-        defaultButtonBackground: string;
-        shiftButtonColor: string;
-        selectedShiftThickness: number;
-        shiftState: number;
-        protected _getTypeName(): string;
-        private _createKey(key, propertySet);
-        addKeysRow(keys: Array<string>, propertySets?: Array<KeyPropertySet>): void;
-        applyShiftState(shiftState: number): void;
-        private _connectedInputText;
-        private _onFocusObserver;
-        private _onBlurObserver;
-        private _onKeyPressObserver;
-        readonly connectedInputText: Nullable<InputText>;
-        connect(input: InputText): void;
-        disconnect(): void;
-        static CreateDefaultLayout(): VirtualKeyboard;
-    }
-}
-
-
-declare module BABYLON.GUI {
-    class MultiLine extends Control {
-        name: string | undefined;
-        private _lineWidth;
-        private _dash;
-        private _points;
-        private _minX;
-        private _minY;
-        private _maxX;
-        private _maxY;
-        constructor(name?: string | undefined);
-        dash: Array<number>;
-        getAt(index: number): MultiLinePoint;
-        onPointUpdate: () => void;
-        add(...items: (AbstractMesh | Control | {
-            x: string | number;
-            y: string | number;
-        })[]): MultiLinePoint[];
-        push(item?: (AbstractMesh | Control | {
-            x: string | number;
-            y: string | number;
-        })): MultiLinePoint;
-        remove(value: number | MultiLinePoint): void;
-        lineWidth: number;
-        horizontalAlignment: number;
-        verticalAlignment: number;
-        protected _getTypeName(): string;
-        _draw(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        protected _additionalProcessing(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        _measure(): void;
-        protected _computeAlignment(parentMeasure: Measure, context: CanvasRenderingContext2D): void;
-        dispose(): void;
-    }
-}

dist/preview release/gui/package.json

@@ -1,36 +0,0 @@
-{
-    "author": {
-        "name": "David CATUHE"
-    },
-    "name": "babylonjs-gui",
-    "description": "The Babylon.js GUI library is an extension you can use to generate interactive user interface. It is build on top of the DynamicTexture.",
-    "version": "3.2.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/BabylonJS/Babylon.js.git"
-    },
-    "main": "babylon.gui.min.js",
-    "files": [
-        "babylon.gui.js",
-        "babylon.gui.min.js",
-        "babylon.gui.d.ts",
-        "babylon.gui.module.d.ts",
-        "readme.md",
-        "package.json"
-    ],
-    "typings": "babylon.gui.module.d.ts",
-    "keywords": [
-        "3D",
-        "javascript",
-        "html5",
-        "webgl",
-        "gui"
-    ],
-    "license": "Apache-2.0",
-    "peerDependencies": {
-        "babylonjs": ">=3.2.0-alpha"
-    },
-    "engines": {
-        "node": "*"
-    }
-}

dist/preview release/gui/readme.md

@@ -1,41 +0,0 @@
-Babylon.js GUI module
-=====================
-
-For usage documentation please visit http://doc.babylonjs.com/overviews/gui
-
-# Installation instructions
-
-## CDN
-
-Compiled js files (minified and source) are offered on our public CDN here:
-
-* https://preview.babylonjs.com/gui/babylon.gui.js
-* https://preview.babylonjs.com/gui/babylon.gui.min.js
-
-## NPM
-
-To install using npm :
-
-```
-npm install --save babylonjs babylonjs-gui
-```
-
-If using TypeScript, the typing needs to be added to tsconfig.json:
-
-```
-    ....
-    "types": [
-        "babylonjs",
-        "babylonjs-gui",
-        "angularFTW"
-    ],
-    ....
-```
-
-Afterwards it can be imported to the project using:
-
-```
-import * as GUI from 'babylonjs-gui';
-```
-
-Using webpack to package your project will use the minified js file.

dist/preview release/inspector/babylon.inspector.css

@@ -1,526 +0,0 @@
-@import url(https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css);
-@import url(https://fonts.googleapis.com/css?family=Inconsolata);
-
-@import url(https://maxcdn.bootstrapcdn.com/font-awesome/4.6.3/css/font-awesome.min.css);
-@import url(https://fonts.googleapis.com/css?family=Inconsolata);
-.insp-wrapper {
-  user-select: none;
-  display: flex;
-  font-size: 0.9em;
-  font-family: "Inconsolata", sans-serif;
-  background-color: #242424;
-  /**
- * A tool contained in the tree panel (available for each item of the tree)
- */
-  /**
- * The toolbar contains : 
- * - a refresh tool - refresh the whole panel
- * - a popup tool - Open the inspector in a new panel
- * ...
- */
-  /*
-* 1. Set to 0 height and width, and remove border for a slider without a thumb
-*/ }
-  .insp-wrapper .gutter {
-    background-color: #2c2c2c; }
-    .insp-wrapper .gutter.gutter-vertical:not(.blocked) {
-      cursor: ns-resize; }
-    .insp-wrapper .gutter.gutter-horizontal:not(.blocked) {
-      cursor: ew-resize; }
-  .insp-wrapper .insp-right-panel {
-    width: 750px;
-    overflow-y: auto;
-    display: flex;
-    flex-direction: column;
-    flex-shrink: 0; }
-    .insp-wrapper .insp-right-panel.popupmode {
-      width: 100% !important; }
-    .insp-wrapper .insp-right-panel .top-panel {
-      width: 100%;
-      height: 100%;
-      position: relative;
-      background-color: #242424;
-      color: #ccc;
-      font-size: 1em; }
-      .insp-wrapper .insp-right-panel .top-panel .tab-panel-content {
-        width: 100%;
-        height: calc(100% - 40px); }
-      .insp-wrapper .insp-right-panel .top-panel .more-tabs-panel {
-        position: absolute;
-        z-index: 10;
-        top: 40px;
-        right: 0;
-        width: 100px;
-        display: none;
-        flex-direction: column;
-        align-items: center;
-        justify-content: center;
-        border: 1px solid #454545;
-        background-color: #242424; }
-        .insp-wrapper .insp-right-panel .top-panel .more-tabs-panel .invisible-tab {
-          height: 25px;
-          width: 100%;
-          line-height: 25px;
-          text-align: center;
-          background-color: #2c2c2c;
-          cursor: pointer; }
-          .insp-wrapper .insp-right-panel .top-panel .more-tabs-panel .invisible-tab:hover {
-            background-color: #383838; }
-          .insp-wrapper .insp-right-panel .top-panel .more-tabs-panel .invisible-tab:active {
-            background-color: #454545; }
-  .insp-wrapper .tooltip {
-    position: absolute;
-    top: 40px;
-    right: 0;
-    color: #f29766;
-    display: none;
-    z-index: 4;
-    font-family: "Inconsolata", sans-serif;
-    padding: 2px;
-    background-color: #242424;
-    border: 1px solid #454545; }
-  .insp-wrapper .treeTool {
-    margin: 3px 8px 3px 3px;
-    cursor: pointer;
-    position: relative; }
-    .insp-wrapper .treeTool:hover {
-      color: #5db0d7; }
-    .insp-wrapper .treeTool.active {
-      color: #5db0d7; }
-  .insp-wrapper .tab-panel {
-    height: 100%; }
-    .insp-wrapper .tab-panel.searchable {
-      height: calc(100% - 30px - 10px); }
-    .insp-wrapper .tab-panel .texture-image {
-      max-height: 400px; }
-    .insp-wrapper .tab-panel .scene-actions {
-      overflow-y: auto;
-      padding-left: 5px; }
-      .insp-wrapper .tab-panel .scene-actions .actions-title {
-        font-size: 1.1em;
-        padding-bottom: 10px;
-        border-bottom: 1px solid #5db0d7;
-        margin: 10px 0 10px 0; }
-      .insp-wrapper .tab-panel .scene-actions .defaut-action, .insp-wrapper .tab-panel .scene-actions .action-radio, .insp-wrapper .tab-panel .scene-actions .action {
-        height: 20px;
-        line-height: 20px;
-        width: 100%;
-        cursor: pointer; }
-        .insp-wrapper .tab-panel .scene-actions .defaut-action:hover, .insp-wrapper .tab-panel .scene-actions .action-radio:hover, .insp-wrapper .tab-panel .scene-actions .action:hover {
-          background-color: #2c2c2c; }
-        .insp-wrapper .tab-panel .scene-actions .defaut-action:active, .insp-wrapper .tab-panel .scene-actions .action-radio:active, .insp-wrapper .tab-panel .scene-actions .action:active {
-          background-color: #383838; }
-      .insp-wrapper .tab-panel .scene-actions .action-radio:before {
-        width: 1em;
-        height: 1em;
-        line-height: 1em;
-        display: inline-block;
-        font-family: 'FontAwesome', sans-serif;
-        content: "\f10c";
-        margin-right: 10px; }
-      .insp-wrapper .tab-panel .scene-actions .action-radio.active:before {
-        width: 1em;
-        height: 1em;
-        line-height: 1em;
-        display: inline-block;
-        font-family: 'FontAwesome', sans-serif;
-        content: "\f192";
-        color: #5db0d7;
-        margin-right: 10px; }
-      .insp-wrapper .tab-panel .scene-actions .action:before {
-        width: 1em;
-        height: 1em;
-        line-height: 1em;
-        display: inline-block;
-        font-family: 'FontAwesome', sans-serif;
-        content: "\f096";
-        margin-right: 10px; }
-      .insp-wrapper .tab-panel .scene-actions .action.active:before {
-        width: 1em;
-        height: 1em;
-        line-height: 1em;
-        display: inline-block;
-        font-family: 'FontAwesome', sans-serif;
-        content: "\f14a";
-        color: #5db0d7;
-        margin-right: 10px; }
-  .insp-wrapper .tab-panel .shader-tree-panel {
-    height: 30px; }
-    .insp-wrapper .tab-panel .shader-tree-panel select {
-      height: 30px;
-      background-color: transparent;
-      color: #ccc;
-      height: 30px;
-      width: 100%;
-      max-width: 300px;
-      padding-left: 15px;
-      border: 1px solid #2c2c2c;
-      outline: 1px solid #454545; }
-      .insp-wrapper .tab-panel .shader-tree-panel select option {
-        padding: 5px;
-        color: gray; }
-  .insp-wrapper .tab-panel .shader-panel {
-    min-height: 100px;
-    user-select: text;
-    box-sizing: border-box;
-    padding: 0 15px; }
-    .insp-wrapper .tab-panel .shader-panel pre {
-      margin: 0;
-      white-space: pre-wrap; }
-      .insp-wrapper .tab-panel .shader-panel pre code {
-        background-color: #242424 !important;
-        padding: 0;
-        margin: 0; }
-    .insp-wrapper .tab-panel .shader-panel .shader-panel-title {
-      height: 25px;
-      border-bottom: 1px solid #383838;
-      text-transform: uppercase;
-      line-height: 25px;
-      margin-bottom: 10px; }
-  .insp-wrapper .tab-panel .console-panel {
-    min-height: 100px;
-    user-select: text;
-    box-sizing: border-box;
-    padding: 0 15px; }
-    .insp-wrapper .tab-panel .console-panel .console-panel-title {
-      height: 25px;
-      border-bottom: 1px solid #383838;
-      text-transform: uppercase;
-      line-height: 25px;
-      margin-bottom: 10px; }
-    .insp-wrapper .tab-panel .console-panel .console-panel-content {
-      overflow-y: auto;
-      overflow-x: hidden;
-      height: calc(100% - 30px); }
-    .insp-wrapper .tab-panel .console-panel .defaut-line, .insp-wrapper .tab-panel .console-panel .log, .insp-wrapper .tab-panel .console-panel .warn, .insp-wrapper .tab-panel .console-panel .error, .insp-wrapper .tab-panel .console-panel .object {
-      word-wrap: break-word;
-      padding: 3px 0 3px 5px; }
-    .insp-wrapper .tab-panel .console-panel .caller {
-      padding: 3px 0 3px 0;
-      color: #349ccd; }
-    .insp-wrapper .tab-panel .console-panel .log {
-      color: white; }
-    .insp-wrapper .tab-panel .console-panel .warn {
-      color: orange; }
-    .insp-wrapper .tab-panel .console-panel .error {
-      color: orangered; }
-    .insp-wrapper .tab-panel .console-panel .object {
-      color: #5db0d7; }
-  .insp-wrapper .tab-panel.stats-panel {
-    overflow-y: auto; }
-  .insp-wrapper .tab-panel .stats-fps {
-    font-weight: 600;
-    color: #f29766; }
-  .insp-wrapper .tab-panel .stat-title1 {
-    font-size: 1.1em;
-    padding: 10px; }
-  .insp-wrapper .tab-panel .stat-title2 {
-    margin: 10px 0 10px 0;
-    font-size: 1.05em;
-    border-bottom: 1px solid #5db0d7;
-    box-sizing: border-box; }
-  .insp-wrapper .tab-panel .stat-label {
-    display: inline-block;
-    width: 80%;
-    padding: 2px;
-    background-color: #2c2c2c;
-    border-bottom: 1px solid #242424;
-    border-top: 1px solid #242424;
-    height: 30px;
-    line-height: 30px;
-    box-sizing: border-box; }
-  .insp-wrapper .tab-panel .stat-value {
-    display: inline-block;
-    width: 20%;
-    padding: 2px;
-    background-color: #2c2c2c;
-    border-top: 1px solid #242424;
-    border-bottom: 1px solid #242424;
-    height: 30px;
-    line-height: 30px;
-    box-sizing: border-box; }
-  .insp-wrapper .tab-panel .stat-infos {
-    width: 100%;
-    padding: 4px; }
-  .insp-wrapper .tab-panel .gltf-actions {
-    overflow-y: auto;
-    padding-left: 5px; }
-    .insp-wrapper .tab-panel .gltf-actions .gltf-title {
-      font-size: 1.1em;
-      padding-bottom: 10px;
-      border-bottom: 1px solid #5db0d7;
-      margin: 10px 0 10px 0; }
-    .insp-wrapper .tab-panel .gltf-actions .gltf-input {
-      background-color: #2c2c2c;
-      border: none;
-      outline: none;
-      font-family: "Inconsolata", sans-serif;
-      color: #b3b3b3;
-      padding: 5px;
-      margin: 0px 6px 0px 0; }
-      .insp-wrapper .tab-panel .gltf-actions .gltf-input:hover {
-        background-color: #383838; }
-    .insp-wrapper .tab-panel .gltf-actions .gltf-button {
-      background-color: #2c2c2c;
-      border: none;
-      outline: none;
-      font-family: "Inconsolata", sans-serif;
-      color: #ccc;
-      padding: 5px 10px;
-      margin: 0px 6px 0px 0; }
-      .insp-wrapper .tab-panel .gltf-actions .gltf-button:hover {
-        background-color: #383838; }
-      .insp-wrapper .tab-panel .gltf-actions .gltf-button:active {
-        background-color: #454545; }
-  .insp-wrapper .property-type {
-    color: #5db0d7; }
-  .insp-wrapper .property-name, .insp-wrapper .insp-details .base-row .prop-name, .insp-wrapper .insp-details .row .prop-name, .insp-wrapper .insp-details .header-row .prop-name {
-    color: #f29766; }
-  .insp-wrapper .insp-tree {
-    overflow-y: auto;
-    overflow-x: hidden;
-    height: calc(50% - 40px - 30px); }
-    .insp-wrapper .insp-tree .line {
-      padding: 3px;
-      cursor: pointer; }
-      .insp-wrapper .insp-tree .line:hover {
-        background-color: #2c2c2c; }
-      .insp-wrapper .insp-tree .line.active {
-        background-color: #454545; }
-        .insp-wrapper .insp-tree .line.active .line-content {
-          background-color: #242424; }
-      .insp-wrapper .insp-tree .line.unfolded:before {
-        width: 1em;
-        height: 1em;
-        line-height: 1em;
-        display: inline-block;
-        font-family: 'FontAwesome', sans-serif;
-        content: "\f078"; }
-      .insp-wrapper .insp-tree .line.folded:before {
-        width: 1em;
-        height: 1em;
-        line-height: 1em;
-        display: inline-block;
-        font-family: 'FontAwesome', sans-serif;
-        content: "\f054"; }
-      .insp-wrapper .insp-tree .line.unfolded.transformNode > span:first-of-type {
-        color: #f29766; }
-      .insp-wrapper .insp-tree .line.folded.transformNode > span:first-of-type {
-        color: #f29766; }
-      .insp-wrapper .insp-tree .line .line-content {
-        padding-left: 15px; }
-        .insp-wrapper .insp-tree .line .line-content:hover {
-          background-color: #242424; }
-        .insp-wrapper .insp-tree .line .line-content .line:hover:first-child {
-          background-color: #383838; }
-    .insp-wrapper .insp-tree .line_invisible {
-      display: none; }
-  .insp-wrapper .insp-details {
-    background-color: #242424;
-    overflow-y: auto;
-    overflow-x: auto;
-    color: #ccc;
-    font-family: "Inconsolata", sans-serif; }
-    .insp-wrapper .insp-details .details {
-      padding-left: 5px; }
-    .insp-wrapper .insp-details .base-row, .insp-wrapper .insp-details .row, .insp-wrapper .insp-details .header-row {
-      display: flex;
-      width: 100%; }
-      .insp-wrapper .insp-details .base-row .base-property, .insp-wrapper .insp-details .row .base-property, .insp-wrapper .insp-details .header-row .base-property, .insp-wrapper .insp-details .base-row .prop-name, .insp-wrapper .insp-details .row .prop-name, .insp-wrapper .insp-details .header-row .prop-name, .insp-wrapper .insp-details .base-row .prop-value, .insp-wrapper .insp-details .row .prop-value, .insp-wrapper .insp-details .header-row .prop-value {
-        padding: 2px 0 2px 0;
-        text-overflow: ellipsis;
-        white-space: nowrap;
-        overflow: hidden; }
-      .insp-wrapper .insp-details .base-row .prop-name, .insp-wrapper .insp-details .row .prop-name, .insp-wrapper .insp-details .header-row .prop-name {
-        width: 35%; }
-      .insp-wrapper .insp-details .base-row .prop-value, .insp-wrapper .insp-details .row .prop-value, .insp-wrapper .insp-details .header-row .prop-value {
-        width: 59%;
-        padding-left: 5px; }
-        .insp-wrapper .insp-details .base-row .prop-value.clickable, .insp-wrapper .insp-details .row .prop-value.clickable, .insp-wrapper .insp-details .header-row .prop-value.clickable {
-          cursor: pointer; }
-          .insp-wrapper .insp-details .base-row .prop-value.clickable:hover, .insp-wrapper .insp-details .row .prop-value.clickable:hover, .insp-wrapper .insp-details .header-row .prop-value.clickable:hover {
-            background-color: #383838; }
-          .insp-wrapper .insp-details .base-row .prop-value.clickable:after, .insp-wrapper .insp-details .row .prop-value.clickable:after, .insp-wrapper .insp-details .header-row .prop-value.clickable:after {
-            font-family: 'FontAwesome', sans-serif;
-            content: "\00a0 \00a0 \00a0 \f054"; }
-    .insp-wrapper .insp-details .row:nth-child(even) {
-      background-color: #2c2c2c; }
-    .insp-wrapper .insp-details .row.unfolded .prop-value.clickable:after {
-      font-family: 'FontAwesome', sans-serif;
-      content: "\00a0 \00a0 \00a0 \f078"; }
-    .insp-wrapper .insp-details .header-row {
-      background-color: #2c2c2c;
-      color: #ccc;
-      width: 100%;
-      max-width: 100%; }
-      .insp-wrapper .insp-details .header-row > * {
-        color: #ccc !important;
-        padding: 5px 0 5px 5px !important;
-        cursor: pointer; }
-        .insp-wrapper .insp-details .header-row > *:hover {
-          background-color: #383838; }
-      .insp-wrapper .insp-details .header-row .header-col {
-        display: flex;
-        justify-content: space-between;
-        align-items: center; }
-        .insp-wrapper .insp-details .header-row .header-col .sort-direction {
-          margin-right: 5px; }
-    .insp-wrapper .insp-details .element-viewer, .insp-wrapper .insp-details .color-element, .insp-wrapper .insp-details .texture-element {
-      position: relative;
-      width: 10px;
-      height: 10px;
-      display: inline-block;
-      margin-left: 5px; }
-    .insp-wrapper .insp-details .color-element {
-      width: 20px;
-      height: 15px; }
-    .insp-wrapper .insp-details .texture-element {
-      color: #f29766;
-      margin-left: 10px; }
-      .insp-wrapper .insp-details .texture-element .texture-viewer {
-        color: #ccc;
-        position: absolute;
-        z-index: 10;
-        bottom: 0;
-        right: 0;
-        display: block;
-        width: 150px;
-        height: 150px;
-        border: 1px solid #454545;
-        background-color: #242424;
-        transform: translateX(100%) translateY(100%);
-        display: none;
-        flex-direction: column;
-        justify-content: flex-start;
-        align-items: center; }
-        .insp-wrapper .insp-details .texture-element .texture-viewer .texture-viewer-img {
-          margin: 10px 0 10px 0;
-          max-width: 110px;
-          max-height: 110px; }
-  .insp-wrapper .tabbar {
-    height: 40px;
-    display: flex;
-    align-items: center;
-    border-bottom: 1px solid #383838;
-    width: 100%;
-    overflow-x: auto;
-    overflow-y: hidden;
-    box-sizing: border-box; }
-    .insp-wrapper .tabbar .tab {
-      height: calc(40px - 2px);
-      width: auto;
-      padding: 0 10px 0 10px;
-      color: #ccc;
-      line-height: 40px;
-      text-align: center;
-      cursor: pointer;
-      margin: 0 5px 0 5px;
-      box-sizing: border-box; }
-      .insp-wrapper .tabbar .tab:hover {
-        border-bottom: 1px solid #f29766;
-        background-color: #2c2c2c; }
-      .insp-wrapper .tabbar .tab:active {
-        background-color: #383838; }
-      .insp-wrapper .tabbar .tab.active {
-        border-bottom: 1px solid #f29766; }
-    .insp-wrapper .tabbar .more-tabs {
-      width: 40px;
-      height: 40px;
-      display: flex;
-      justify-content: center;
-      align-items: center;
-      cursor: pointer;
-      position: relative;
-      border-right: 1px solid #383838; }
-      .insp-wrapper .tabbar .more-tabs:hover {
-        background-color: #383838; }
-      .insp-wrapper .tabbar .more-tabs:active {
-        color: #f29766;
-        background-color: #454545; }
-      .insp-wrapper .tabbar .more-tabs.active {
-        color: #f29766; }
-  .insp-wrapper .toolbar {
-    display: flex; }
-    .insp-wrapper .toolbar .tool {
-      width: 40px;
-      height: 40px;
-      display: flex;
-      justify-content: center;
-      align-items: center;
-      cursor: pointer;
-      position: relative;
-      border-right: 1px solid #383838; }
-      .insp-wrapper .toolbar .tool:hover {
-        background-color: #383838; }
-      .insp-wrapper .toolbar .tool:active {
-        color: #f29766;
-        background-color: #454545; }
-      .insp-wrapper .toolbar .tool.active {
-        color: #f29766; }
-  .insp-wrapper .searchbar {
-    border: 1px solid #2c2c2c;
-    margin-bottom: 5px;
-    display: flex;
-    align-items: center;
-    color: #b3b3b3; }
-    .insp-wrapper .searchbar input {
-      background-color: #242424;
-      border: none;
-      width: 100%;
-      outline: none;
-      font-family: "Inconsolata", sans-serif;
-      color: #b3b3b3;
-      padding: 3px 0 3px 10px;
-      margin: 6px 0 6px 0; }
-  .insp-wrapper input[type="range"] {
-    margin: auto;
-    -webkit-appearance: none;
-    position: relative;
-    overflow: hidden;
-    height: 15px;
-    width: 50%;
-    cursor: pointer;
-    border-radius: 0;
-    /* iOS */ }
-  .insp-wrapper ::-webkit-slider-runnable-track {
-    background: #ddd; }
-  .insp-wrapper ::-webkit-slider-thumb {
-    -webkit-appearance: none;
-    width: 20px;
-    /* 1 */
-    height: 15px;
-    /* 1 */
-    background: #fff;
-    box-shadow: -100vw 0 0 100vw dodgerblue;
-    border: 0px solid #999;
-    /* 1 */ }
-  .insp-wrapper ::-moz-range-track {
-    height: 15px;
-    background: #ddd; }
-  .insp-wrapper ::-moz-range-thumb {
-    background: #fff;
-    height: 15px;
-    width: 20px;
-    border: 0px solid #999;
-    border-radius: 0 !important;
-    box-shadow: -100vw 0 0 100vw dodgerblue;
-    box-sizing: border-box; }
-  .insp-wrapper ::-ms-fill-lower {
-    background: dodgerblue; }
-  .insp-wrapper ::-ms-thumb {
-    background: #fff;
-    border: 0px solid #999;
-    height: 15px;
-    width: 20px;
-    box-sizing: border-box; }
-  .insp-wrapper ::-ms-ticks-after {
-    display: none; }
-  .insp-wrapper ::-ms-ticks-before {
-    display: none; }
-  .insp-wrapper ::-ms-track {
-    background: #ddd;
-    color: transparent;
-    height: 15px;
-    border: none; }
-  .insp-wrapper ::-ms-tooltip {
-    display: none; }

dist/preview release/inspector/package.json

@@ -1,33 +0,0 @@
-{
-    "author": {
-        "name": "David CATUHE"
-    },
-    "name": "babylonjs-inspector",
-    "description": "The Babylon.js inspector.",
-    "version": "3.2.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/BabylonJS/Babylon.js.git"
-    },
-    "main": "babylon.inspector.bundle.js",
-    "files": [
-        "babylon.inspector.bundle.js",
-        "readme.md",
-        "package.json"
-    ],
-    "keywords": [
-        "3D",
-        "javascript",
-        "html5",
-        "webgl",
-        "babylonjs",
-        "inspector"
-    ],
-    "license": "Apache-2.0",
-    "peerDependencies": {
-        "babylonjs": ">=3.2.0-alpha"
-    },
-    "engines": {
-        "node": "*"
-    }
-}

dist/preview release/inspector/readme.md

@@ -1,34 +0,0 @@
-Babylon.js inspector module
-=====================
-
-For usage documentation please visit http://doc.babylonjs.com/how_to/debug_layer and search "inspector".
-
-# Installation instructions
-
-The inspector will be **automatically** (async) loaded when starting the debug layer, if not already included. So technically, nothing needs to be done!
-
-If you wish however to use a different version of the inspector or host it on your own, follow these instructions:
-
-## CDN
-
-The latest compiled js file is offered on our public CDN here:
-
-* https://preview.babylonjs.com/inspector/babylonjs.inspector.bundle.js
-
-## NPM
-
-To install using npm :
-
-```
-npm install --save babylonjs babylonjs-inspector
-```
-Afterwards it can be imported to the project using:
-
-```
-import * as BABYLON from 'babylonjs';
-import 'babylonjs-inspector';
-```
-
-This will create a global INSPECTOR variable that will be used bay BabylonJS
-
-Webpack is supported.

dist/preview release/loaders/babylon.glTF1FileLoader.d.ts

@@ -1,947 +0,0 @@
-
-declare module BABYLON {
-    /**
-     * Mode that determines the coordinate system to use.
-     */
-    enum GLTFLoaderCoordinateSystemMode {
-        /**
-         * Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene.
-         */
-        AUTO = 0,
-        /**
-         * Sets the useRightHandedSystem flag on the scene.
-         */
-        FORCE_RIGHT_HANDED = 1,
-    }
-    /**
-     * Mode that determines what animations will start.
-     */
-    enum GLTFLoaderAnimationStartMode {
-        /**
-         * No animation will start.
-         */
-        NONE = 0,
-        /**
-         * The first animation will start.
-         */
-        FIRST = 1,
-        /**
-         * All animations will start.
-         */
-        ALL = 2,
-    }
-    /**
-     * Interface that contains the data for the glTF asset.
-     */
-    interface IGLTFLoaderData {
-        /**
-         * JSON that represents the glTF.
-         */
-        json: Object;
-        /**
-         * The BIN chunk of a binary glTF
-         */
-        bin: Nullable<ArrayBufferView>;
-    }
-    /**
-     * Interface for extending the loader.
-     */
-    interface IGLTFLoaderExtension {
-        /**
-         * The name of this extension.
-         */
-        readonly name: string;
-        /**
-         * Defines whether this extension is enabled.
-         */
-        enabled: boolean;
-    }
-    /**
-     * Loader state.
-     */
-    enum GLTFLoaderState {
-        /**
-         * The asset is loading.
-         */
-        LOADING = 0,
-        /**
-         * The asset is ready for rendering.
-         */
-        READY = 1,
-        /**
-         * The asset is completely loaded.
-         */
-        COMPLETE = 2,
-    }
-    /**
-     * Loader interface.
-     */
-    interface IGLTFLoader extends IDisposable {
-        /**
-         * Mode that determines the coordinate system to use.
-         */
-        coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
-        /**
-         * Mode that determines what animations will start.
-         */
-        animationStartMode: GLTFLoaderAnimationStartMode;
-        /**
-         * Defines if the loader should compile materials.
-         */
-        compileMaterials: boolean;
-        /**
-         * Defines if the loader should also compile materials with clip planes.
-         */
-        useClipPlane: boolean;
-        /**
-         * Defines if the loader should compile shadow generators.
-         */
-        compileShadowGenerators: boolean;
-        /**
-         * Defines if the Alpha blended materials are only applied as coverage.
-         * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
-         * If true, no extra effects are applied to transparent pixels.
-         */
-        transparencyAsCoverage: boolean;
-        /** @hidden */
-        _normalizeAnimationGroupsToBeginAtZero: boolean;
-        /**
-         * Function called before loading a url referenced by the asset.
-         */
-        preprocessUrlAsync: (url: string) => Promise<string>;
-        /**
-         * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         */
-        onMeshLoadedObservable: Observable<AbstractMesh>;
-        /**
-         * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
-         */
-        onTextureLoadedObservable: Observable<BaseTexture>;
-        /**
-         * Observable raised when the loader creates a material after parsing the glTF properties of the material.
-         */
-        onMaterialLoadedObservable: Observable<Material>;
-        /**
-         * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
-         */
-        onCameraLoadedObservable: Observable<Camera>;
-        /**
-         * Observable raised when the asset is completely loaded, immediately before the loader is disposed.
-         * For assets with LODs, raised when all of the LODs are complete.
-         * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
-         */
-        onCompleteObservable: Observable<IGLTFLoader>;
-        /**
-         * Observable raised after the loader is disposed.
-         */
-        onDisposeObservable: Observable<IGLTFLoader>;
-        /**
-         * Observable raised after a loader extension is created.
-         * Set additional options for a loader extension in this event.
-         */
-        onExtensionLoadedObservable: Observable<IGLTFLoaderExtension>;
-        /**
-         * Loader state or null if the loader is not active.
-         */
-        state: Nullable<GLTFLoaderState>;
-        /**
-         * Imports meshes from the given data and adds them to the scene.
-         */
-        importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: ParticleSystem[];
-            skeletons: Skeleton[];
-            animationGroups: AnimationGroup[];
-        }>;
-        /**
-         * Loads all objects from the given data and adds them to the scene.
-         */
-        loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise<void>;
-    }
-    /**
-     * File loader for loading glTF files into a scene.
-     */
-    class GLTFFileLoader implements IDisposable, ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {
-        /**
-         * Factory function that creates a glTF 1.0 loader
-         */
-        static CreateGLTFLoaderV1: () => IGLTFLoader;
-        /**
-         * Factory function that creates a glTF 2.0 loader
-         */
-        static CreateGLTFLoaderV2: () => IGLTFLoader;
-        /**
-         * Raised when the asset has been parsed
-         */
-        onParsedObservable: Observable<IGLTFLoaderData>;
-        private _onParsedObserver;
-        /**
-         * Raised when the asset has been parsed
-         */
-        onParsed: (loaderData: IGLTFLoaderData) => void;
-        /**
-         * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.
-         * Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.
-         * Defaults to true.
-         */
-        static IncrementalLoading: boolean;
-        /**
-         * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.
-         * Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.
-         */
-        static HomogeneousCoordinates: boolean;
-        /**
-         * The coordinate system mode. Defaults to AUTO.
-         */
-        coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
-        /**
-        * The animation start mode. Defaults to FIRST.
-        */
-        animationStartMode: GLTFLoaderAnimationStartMode;
-        /**
-         * Defines if the loader should compile materials before raising the success callback. Defaults to false.
-         */
-        compileMaterials: boolean;
-        /**
-         * Defines if the loader should also compile materials with clip planes. Defaults to false.
-         */
-        useClipPlane: boolean;
-        /**
-         * Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.
-         */
-        compileShadowGenerators: boolean;
-        /**
-         * Defines if the Alpha blended materials are only applied as coverage.
-         * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
-         * If true, no extra effects are applied to transparent pixels.
-         */
-        transparencyAsCoverage: boolean;
-        /** @hidden */
-        _normalizeAnimationGroupsToBeginAtZero: boolean;
-        /**
-         * Function called before loading a url referenced by the asset.
-         */
-        preprocessUrlAsync: (url: string) => Promise<string>;
-        /**
-         * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         */
-        readonly onMeshLoadedObservable: Observable<AbstractMesh>;
-        private _onMeshLoadedObserver;
-        /**
-         * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         */
-        onMeshLoaded: (mesh: AbstractMesh) => void;
-        /**
-         * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
-         */
-        readonly onTextureLoadedObservable: Observable<BaseTexture>;
-        private _onTextureLoadedObserver;
-        /**
-         * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
-         */
-        onTextureLoaded: (texture: BaseTexture) => void;
-        /**
-         * Observable raised when the loader creates a material after parsing the glTF properties of the material.
-         */
-        readonly onMaterialLoadedObservable: Observable<Material>;
-        private _onMaterialLoadedObserver;
-        /**
-         * Callback raised when the loader creates a material after parsing the glTF properties of the material.
-         */
-        onMaterialLoaded: (material: Material) => void;
-        /**
-         * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
-         */
-        readonly onCameraLoadedObservable: Observable<Camera>;
-        private _onCameraLoadedObserver;
-        /**
-         * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
-         */
-        onCameraLoaded: (camera: Camera) => void;
-        /**
-         * Observable raised when the asset is completely loaded, immediately before the loader is disposed.
-         * For assets with LODs, raised when all of the LODs are complete.
-         * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
-         */
-        readonly onCompleteObservable: Observable<GLTFFileLoader>;
-        private _onCompleteObserver;
-        /**
-         * Callback raised when the asset is completely loaded, immediately before the loader is disposed.
-         */
-        onComplete: () => void;
-        /**
-         * Observable raised after the loader is disposed.
-         */
-        readonly onDisposeObservable: Observable<GLTFFileLoader>;
-        private _onDisposeObserver;
-        /**
-         * Callback raised after the loader is disposed.
-         */
-        onDispose: () => void;
-        /**
-         * Observable raised after a loader extension is created.
-         * Set additional options for a loader extension in this event.
-         */
-        readonly onExtensionLoadedObservable: Observable<IGLTFLoaderExtension>;
-        private _onExtensionLoadedObserver;
-        /**
-         * Callback raised after a loader extension is created.
-         */
-        onExtensionLoaded: (extension: IGLTFLoaderExtension) => void;
-        /**
-         * Returns a promise that resolves when the asset is completely loaded.
-         * @returns a promise that resolves when the asset is completely loaded.
-         */
-        whenCompleteAsync(): Promise<void>;
-        /**
-         * The loader state or null if the loader is not active.
-         */
-        readonly loaderState: Nullable<GLTFLoaderState>;
-        private _loader;
-        /**
-         * Name of the loader ("gltf")
-         */
-        name: string;
-        /**
-         * Supported file extensions of the loader (.gltf, .glb)
-         */
-        extensions: ISceneLoaderPluginExtensions;
-        /**
-         * Disposes the loader, releases resources during load, and cancels any outstanding requests.
-         */
-        dispose(): void;
-        /**
-         * Imports one or more meshes from the loaded glTF data and adds them to the scene
-         * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
-         * @param scene the scene the meshes should be added to
-         * @param data the glTF data to load
-         * @param rootUrl root url to load from
-         * @param onProgress event that fires when loading progress has occured
-         * @returns a promise containg the loaded meshes, particles, skeletons and animations
-         */
-        importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: ParticleSystem[];
-            skeletons: Skeleton[];
-            animationGroups: AnimationGroup[];
-        }>;
-        /**
-         * Imports all objects from the loaded glTF data and adds them to the scene
-         * @param scene the scene the objects should be added to
-         * @param data the glTF data to load
-         * @param rootUrl root url to load from
-         * @param onProgress event that fires when loading progress has occured
-         * @returns a promise which completes when objects have been loaded to the scene
-         */
-        loadAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<void>;
-        /**
-         * 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 onProgress The callback when the load progresses
-         * @returns The loaded asset container
-         */
-        loadAssetContainerAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<AssetContainer>;
-        /**
-         * If the data string can be loaded directly.
-         * @param data string contianing the file data
-         * @returns if the data can be loaded directly
-         */
-        canDirectLoad(data: string): boolean;
-        /**
-         * Rewrites a url by combining a root url and response url.
-         */
-        rewriteRootURL: (rootUrl: string, responseURL?: string) => string;
-        /**
-         * Instantiates a glTF file loader plugin.
-         * @returns the created plugin
-         */
-        createPlugin(): ISceneLoaderPlugin | ISceneLoaderPluginAsync;
-        private _parse(data);
-        private _getLoader(loaderData);
-        private static _parseBinary(data);
-        private static _parseV1(binaryReader);
-        private static _parseV2(binaryReader);
-        private static _parseVersion(version);
-        private static _compareVersion(a, b);
-        private static _decodeBufferToText(buffer);
-    }
-}
-
-
-declare module BABYLON.GLTF1 {
-    /**
-    * Enums
-    */
-    enum EComponentType {
-        BYTE = 5120,
-        UNSIGNED_BYTE = 5121,
-        SHORT = 5122,
-        UNSIGNED_SHORT = 5123,
-        FLOAT = 5126,
-    }
-    enum EShaderType {
-        FRAGMENT = 35632,
-        VERTEX = 35633,
-    }
-    enum EParameterType {
-        BYTE = 5120,
-        UNSIGNED_BYTE = 5121,
-        SHORT = 5122,
-        UNSIGNED_SHORT = 5123,
-        INT = 5124,
-        UNSIGNED_INT = 5125,
-        FLOAT = 5126,
-        FLOAT_VEC2 = 35664,
-        FLOAT_VEC3 = 35665,
-        FLOAT_VEC4 = 35666,
-        INT_VEC2 = 35667,
-        INT_VEC3 = 35668,
-        INT_VEC4 = 35669,
-        BOOL = 35670,
-        BOOL_VEC2 = 35671,
-        BOOL_VEC3 = 35672,
-        BOOL_VEC4 = 35673,
-        FLOAT_MAT2 = 35674,
-        FLOAT_MAT3 = 35675,
-        FLOAT_MAT4 = 35676,
-        SAMPLER_2D = 35678,
-    }
-    enum ETextureWrapMode {
-        CLAMP_TO_EDGE = 33071,
-        MIRRORED_REPEAT = 33648,
-        REPEAT = 10497,
-    }
-    enum ETextureFilterType {
-        NEAREST = 9728,
-        LINEAR = 9728,
-        NEAREST_MIPMAP_NEAREST = 9984,
-        LINEAR_MIPMAP_NEAREST = 9985,
-        NEAREST_MIPMAP_LINEAR = 9986,
-        LINEAR_MIPMAP_LINEAR = 9987,
-    }
-    enum ETextureFormat {
-        ALPHA = 6406,
-        RGB = 6407,
-        RGBA = 6408,
-        LUMINANCE = 6409,
-        LUMINANCE_ALPHA = 6410,
-    }
-    enum ECullingType {
-        FRONT = 1028,
-        BACK = 1029,
-        FRONT_AND_BACK = 1032,
-    }
-    enum EBlendingFunction {
-        ZERO = 0,
-        ONE = 1,
-        SRC_COLOR = 768,
-        ONE_MINUS_SRC_COLOR = 769,
-        DST_COLOR = 774,
-        ONE_MINUS_DST_COLOR = 775,
-        SRC_ALPHA = 770,
-        ONE_MINUS_SRC_ALPHA = 771,
-        DST_ALPHA = 772,
-        ONE_MINUS_DST_ALPHA = 773,
-        CONSTANT_COLOR = 32769,
-        ONE_MINUS_CONSTANT_COLOR = 32770,
-        CONSTANT_ALPHA = 32771,
-        ONE_MINUS_CONSTANT_ALPHA = 32772,
-        SRC_ALPHA_SATURATE = 776,
-    }
-    /**
-    * Interfaces
-    */
-    interface IGLTFProperty {
-        extensions?: {
-            [key: string]: any;
-        };
-        extras?: Object;
-    }
-    interface IGLTFChildRootProperty extends IGLTFProperty {
-        name?: string;
-    }
-    interface IGLTFAccessor extends IGLTFChildRootProperty {
-        bufferView: string;
-        byteOffset: number;
-        byteStride: number;
-        count: number;
-        type: string;
-        componentType: EComponentType;
-        max?: number[];
-        min?: number[];
-        name?: string;
-    }
-    interface IGLTFBufferView extends IGLTFChildRootProperty {
-        buffer: string;
-        byteOffset: number;
-        byteLength: number;
-        byteStride: number;
-        target?: number;
-    }
-    interface IGLTFBuffer extends IGLTFChildRootProperty {
-        uri: string;
-        byteLength?: number;
-        type?: string;
-    }
-    interface IGLTFShader extends IGLTFChildRootProperty {
-        uri: string;
-        type: EShaderType;
-    }
-    interface IGLTFProgram extends IGLTFChildRootProperty {
-        attributes: string[];
-        fragmentShader: string;
-        vertexShader: string;
-    }
-    interface IGLTFTechniqueParameter {
-        type: number;
-        count?: number;
-        semantic?: string;
-        node?: string;
-        value?: number | boolean | string | Array<any>;
-        source?: string;
-        babylonValue?: any;
-    }
-    interface IGLTFTechniqueCommonProfile {
-        lightingModel: string;
-        texcoordBindings: Object;
-        parameters?: Array<any>;
-    }
-    interface IGLTFTechniqueStatesFunctions {
-        blendColor?: number[];
-        blendEquationSeparate?: number[];
-        blendFuncSeparate?: number[];
-        colorMask: boolean[];
-        cullFace: number[];
-    }
-    interface IGLTFTechniqueStates {
-        enable: number[];
-        functions: IGLTFTechniqueStatesFunctions;
-    }
-    interface IGLTFTechnique extends IGLTFChildRootProperty {
-        parameters: {
-            [key: string]: IGLTFTechniqueParameter;
-        };
-        program: string;
-        attributes: {
-            [key: string]: string;
-        };
-        uniforms: {
-            [key: string]: string;
-        };
-        states: IGLTFTechniqueStates;
-    }
-    interface IGLTFMaterial extends IGLTFChildRootProperty {
-        technique?: string;
-        values: string[];
-    }
-    interface IGLTFMeshPrimitive extends IGLTFProperty {
-        attributes: {
-            [key: string]: string;
-        };
-        indices: string;
-        material: string;
-        mode?: number;
-    }
-    interface IGLTFMesh extends IGLTFChildRootProperty {
-        primitives: IGLTFMeshPrimitive[];
-    }
-    interface IGLTFImage extends IGLTFChildRootProperty {
-        uri: string;
-    }
-    interface IGLTFSampler extends IGLTFChildRootProperty {
-        magFilter?: number;
-        minFilter?: number;
-        wrapS?: number;
-        wrapT?: number;
-    }
-    interface IGLTFTexture extends IGLTFChildRootProperty {
-        sampler: string;
-        source: string;
-        format?: ETextureFormat;
-        internalFormat?: ETextureFormat;
-        target?: number;
-        type?: number;
-        babylonTexture?: Texture;
-    }
-    interface IGLTFAmbienLight {
-        color?: number[];
-    }
-    interface IGLTFDirectionalLight {
-        color?: number[];
-    }
-    interface IGLTFPointLight {
-        color?: number[];
-        constantAttenuation?: number;
-        linearAttenuation?: number;
-        quadraticAttenuation?: number;
-    }
-    interface IGLTFSpotLight {
-        color?: number[];
-        constantAttenuation?: number;
-        fallOfAngle?: number;
-        fallOffExponent?: number;
-        linearAttenuation?: number;
-        quadraticAttenuation?: number;
-    }
-    interface IGLTFLight extends IGLTFChildRootProperty {
-        type: string;
-    }
-    interface IGLTFCameraOrthographic {
-        xmag: number;
-        ymag: number;
-        zfar: number;
-        znear: number;
-    }
-    interface IGLTFCameraPerspective {
-        aspectRatio: number;
-        yfov: number;
-        zfar: number;
-        znear: number;
-    }
-    interface IGLTFCamera extends IGLTFChildRootProperty {
-        type: string;
-    }
-    interface IGLTFAnimationChannelTarget {
-        id: string;
-        path: string;
-    }
-    interface IGLTFAnimationChannel {
-        sampler: string;
-        target: IGLTFAnimationChannelTarget;
-    }
-    interface IGLTFAnimationSampler {
-        input: string;
-        output: string;
-        interpolation?: string;
-    }
-    interface IGLTFAnimation extends IGLTFChildRootProperty {
-        channels?: IGLTFAnimationChannel[];
-        parameters?: {
-            [key: string]: string;
-        };
-        samplers?: {
-            [key: string]: IGLTFAnimationSampler;
-        };
-    }
-    interface IGLTFNodeInstanceSkin {
-        skeletons: string[];
-        skin: string;
-        meshes: string[];
-    }
-    interface IGLTFSkins extends IGLTFChildRootProperty {
-        bindShapeMatrix: number[];
-        inverseBindMatrices: string;
-        jointNames: string[];
-        babylonSkeleton?: Skeleton;
-    }
-    interface IGLTFNode extends IGLTFChildRootProperty {
-        camera?: string;
-        children: string[];
-        skin?: string;
-        jointName?: string;
-        light?: string;
-        matrix: number[];
-        mesh?: string;
-        meshes?: string[];
-        rotation?: number[];
-        scale?: number[];
-        translation?: number[];
-        babylonNode?: Node;
-    }
-    interface IGLTFScene extends IGLTFChildRootProperty {
-        nodes: string[];
-    }
-    /**
-    * Runtime
-    */
-    interface IGLTFRuntime {
-        extensions: {
-            [key: string]: any;
-        };
-        accessors: {
-            [key: string]: IGLTFAccessor;
-        };
-        buffers: {
-            [key: string]: IGLTFBuffer;
-        };
-        bufferViews: {
-            [key: string]: IGLTFBufferView;
-        };
-        meshes: {
-            [key: string]: IGLTFMesh;
-        };
-        lights: {
-            [key: string]: IGLTFLight;
-        };
-        cameras: {
-            [key: string]: IGLTFCamera;
-        };
-        nodes: {
-            [key: string]: IGLTFNode;
-        };
-        images: {
-            [key: string]: IGLTFImage;
-        };
-        textures: {
-            [key: string]: IGLTFTexture;
-        };
-        shaders: {
-            [key: string]: IGLTFShader;
-        };
-        programs: {
-            [key: string]: IGLTFProgram;
-        };
-        samplers: {
-            [key: string]: IGLTFSampler;
-        };
-        techniques: {
-            [key: string]: IGLTFTechnique;
-        };
-        materials: {
-            [key: string]: IGLTFMaterial;
-        };
-        animations: {
-            [key: string]: IGLTFAnimation;
-        };
-        skins: {
-            [key: string]: IGLTFSkins;
-        };
-        currentScene?: Object;
-        scenes: {
-            [key: string]: IGLTFScene;
-        };
-        extensionsUsed: string[];
-        extensionsRequired?: string[];
-        buffersCount: number;
-        shaderscount: number;
-        scene: Scene;
-        rootUrl: string;
-        loadedBufferCount: number;
-        loadedBufferViews: {
-            [name: string]: ArrayBufferView;
-        };
-        loadedShaderCount: number;
-        importOnlyMeshes: boolean;
-        importMeshesNames?: string[];
-        dummyNodes: Node[];
-    }
-    /**
-    * Bones
-    */
-    interface INodeToRoot {
-        bone: Bone;
-        node: IGLTFNode;
-        id: string;
-    }
-    interface IJointNode {
-        node: IGLTFNode;
-        id: string;
-    }
-}
-
-
-declare module BABYLON.GLTF1 {
-    /**
-    * Implementation of the base glTF spec
-    */
-    class GLTFLoaderBase {
-        static CreateRuntime(parsedData: any, scene: Scene, rootUrl: string): IGLTFRuntime;
-        static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
-        static LoadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: Nullable<ArrayBufferView>) => void, onError: (message: string) => void): void;
-        static CreateTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: Nullable<ArrayBufferView>, onSuccess: (texture: Texture) => void, onError: (message: string) => void): void;
-        static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string | ArrayBuffer) => void, onError?: (message: string) => void): void;
-        static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
-    }
-    /**
-    * glTF V1 Loader
-    */
-    class GLTFLoader implements IGLTFLoader {
-        static Extensions: {
-            [name: string]: GLTFLoaderExtension;
-        };
-        static RegisterExtension(extension: GLTFLoaderExtension): void;
-        coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
-        animationStartMode: GLTFLoaderAnimationStartMode;
-        compileMaterials: boolean;
-        useClipPlane: boolean;
-        compileShadowGenerators: boolean;
-        transparencyAsCoverage: boolean;
-        _normalizeAnimationGroupsToBeginAtZero: boolean;
-        preprocessUrlAsync: (url: string) => Promise<string>;
-        readonly onMeshLoadedObservable: Observable<AbstractMesh>;
-        readonly onTextureLoadedObservable: Observable<BaseTexture>;
-        readonly onMaterialLoadedObservable: Observable<Material>;
-        readonly onCameraLoadedObservable: Observable<Camera>;
-        readonly onCompleteObservable: Observable<IGLTFLoader>;
-        readonly onDisposeObservable: Observable<IGLTFLoader>;
-        readonly onExtensionLoadedObservable: Observable<IGLTFLoaderExtension>;
-        state: Nullable<GLTFLoaderState>;
-        dispose(): void;
-        private _importMeshAsync(meshesNames, scene, data, rootUrl, onSuccess, onProgress?, onError?);
-        /**
-        * Imports one or more meshes from a loaded gltf file and adds them to the scene
-        * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
-        * @param scene the scene the meshes should be added to
-        * @param data gltf data containing information of the meshes in a loaded file
-        * @param rootUrl root url to load from
-        * @param onProgress event that fires when loading progress has occured
-        * @returns a promise containg the loaded meshes, particles, skeletons and animations
-        */
-        importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: ParticleSystem[];
-            skeletons: Skeleton[];
-            animationGroups: AnimationGroup[];
-        }>;
-        private _loadAsync(scene, data, rootUrl, onSuccess, onProgress?, onError?);
-        /**
-        * Imports all objects from a loaded gltf file and adds them to the scene
-        * @param scene the scene the objects should be added to
-        * @param data gltf data containing information of the meshes in a loaded file
-        * @param rootUrl root url to load from
-        * @param onProgress event that fires when loading progress has occured
-        * @returns a promise which completes when objects have been loaded to the scene
-        */
-        loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<void>;
-        private _loadShadersAsync(gltfRuntime, onload);
-        private _loadBuffersAsync(gltfRuntime, onLoad, onProgress?);
-        private _createNodes(gltfRuntime);
-    }
-}
-
-
-declare module BABYLON.GLTF1 {
-    /**
-    * Utils functions for GLTF
-    */
-    class GLTFUtils {
-        /**
-         * Sets the given "parameter" matrix
-         * @param scene: the {BABYLON.Scene} object
-         * @param source: the source node where to pick the matrix
-         * @param parameter: the GLTF technique parameter
-         * @param uniformName: the name of the shader's uniform
-         * @param shaderMaterial: the shader material
-         */
-        static SetMatrix(scene: Scene, source: Node, parameter: IGLTFTechniqueParameter, uniformName: string, shaderMaterial: ShaderMaterial | Effect): void;
-        /**
-         * Sets the given "parameter" matrix
-         * @param shaderMaterial: the shader material
-         * @param uniform: the name of the shader's uniform
-         * @param value: the value of the uniform
-         * @param type: the uniform's type (EParameterType FLOAT, VEC2, VEC3 or VEC4)
-         */
-        static SetUniform(shaderMaterial: ShaderMaterial | Effect, uniform: string, value: any, type: number): boolean;
-        /**
-        * Returns the wrap mode of the texture
-        * @param mode: the mode value
-        */
-        static GetWrapMode(mode: number): number;
-        /**
-         * Returns the byte stride giving an accessor
-         * @param accessor: the GLTF accessor objet
-         */
-        static GetByteStrideFromType(accessor: IGLTFAccessor): number;
-        /**
-         * Returns the texture filter mode giving a mode value
-         * @param mode: the filter mode value
-         */
-        static GetTextureFilterMode(mode: number): ETextureFilterType;
-        static GetBufferFromBufferView(gltfRuntime: IGLTFRuntime, bufferView: IGLTFBufferView, byteOffset: number, byteLength: number, componentType: EComponentType): ArrayBufferView;
-        /**
-         * Returns a buffer from its accessor
-         * @param gltfRuntime: the GLTF runtime
-         * @param accessor: the GLTF accessor
-         */
-        static GetBufferFromAccessor(gltfRuntime: IGLTFRuntime, accessor: IGLTFAccessor): any;
-        /**
-         * Decodes a buffer view into a string
-         * @param view: the buffer view
-         */
-        static DecodeBufferToText(view: ArrayBufferView): string;
-        /**
-         * Returns the default material of gltf. Related to
-         * https://github.com/KhronosGroup/glTF/tree/master/specification/1.0#appendix-a-default-material
-         * @param scene: the Babylon.js scene
-         */
-        static GetDefaultMaterial(scene: Scene): ShaderMaterial;
-        private static _DefaultMaterial;
-    }
-}
-
-
-declare module BABYLON.GLTF1 {
-    abstract class GLTFLoaderExtension {
-        private _name;
-        constructor(name: string);
-        readonly name: string;
-        /**
-        * Defines an override for loading the runtime
-        * Return true to stop further extensions from loading the runtime
-        */
-        loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess?: (gltfRuntime: IGLTFRuntime) => void, onError?: (message: string) => void): boolean;
-        /**
-         * Defines an onverride for creating gltf runtime
-         * Return true to stop further extensions from creating the runtime
-         */
-        loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError?: (message: string) => void): boolean;
-        /**
-        * Defines an override for loading buffers
-        * Return true to stop further extensions from loading this buffer
-        */
-        loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): boolean;
-        /**
-        * Defines an override for loading texture buffers
-        * Return true to stop further extensions from loading this texture data
-        */
-        loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
-        /**
-        * Defines an override for creating textures
-        * Return true to stop further extensions from loading this texture
-        */
-        createTextureAsync(gltfRuntime: IGLTFRuntime, id: string, buffer: ArrayBufferView, onSuccess: (texture: Texture) => void, onError: (message: string) => void): boolean;
-        /**
-        * Defines an override for loading shader strings
-        * Return true to stop further extensions from loading this shader data
-        */
-        loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): boolean;
-        /**
-        * Defines an override for loading materials
-        * Return true to stop further extensions from loading this material
-        */
-        loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
-        static LoadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess?: (gltfRuntime: IGLTFRuntime) => void, onError?: (message: string) => void): void;
-        static LoadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError?: (message: string) => void): void;
-        static LoadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (bufferView: ArrayBufferView) => void, onError: (message: string) => void, onProgress?: () => void): void;
-        static LoadTextureAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (texture: Texture) => void, onError: (message: string) => void): void;
-        static LoadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderData: string | ArrayBuffer) => void, onError: (message: string) => void): void;
-        static LoadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): void;
-        private static LoadTextureBufferAsync(gltfRuntime, id, onSuccess, onError);
-        private static CreateTextureAsync(gltfRuntime, id, buffer, onSuccess, onError);
-        private static ApplyExtensions(func, defaultFunc);
-    }
-}
-
-
-declare module BABYLON.GLTF1 {
-    class GLTFBinaryExtension extends GLTFLoaderExtension {
-        private _bin;
-        constructor();
-        loadRuntimeAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onSuccess: (gltfRuntime: IGLTFRuntime) => void, onError: (message: string) => void): boolean;
-        loadBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
-        loadTextureBufferAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (buffer: ArrayBufferView) => void, onError: (message: string) => void): boolean;
-        loadShaderStringAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (shaderString: string) => void, onError: (message: string) => void): boolean;
-    }
-}
-
-
-declare module BABYLON.GLTF1 {
-    class GLTFMaterialsCommonExtension extends GLTFLoaderExtension {
-        constructor();
-        loadRuntimeExtensionsAsync(gltfRuntime: IGLTFRuntime, onSuccess: () => void, onError: (message: string) => void): boolean;
-        loadMaterialAsync(gltfRuntime: IGLTFRuntime, id: string, onSuccess: (material: Material) => void, onError: (message: string) => void): boolean;
-        private _loadTexture(gltfRuntime, id, material, propertyPath, onError);
-    }
-}

dist/preview release/loaders/babylon.glTF2FileLoader.d.ts

@@ -1,841 +0,0 @@
-
-declare module BABYLON {
-    /**
-     * Mode that determines the coordinate system to use.
-     */
-    enum GLTFLoaderCoordinateSystemMode {
-        /**
-         * Automatically convert the glTF right-handed data to the appropriate system based on the current coordinate system mode of the scene.
-         */
-        AUTO = 0,
-        /**
-         * Sets the useRightHandedSystem flag on the scene.
-         */
-        FORCE_RIGHT_HANDED = 1,
-    }
-    /**
-     * Mode that determines what animations will start.
-     */
-    enum GLTFLoaderAnimationStartMode {
-        /**
-         * No animation will start.
-         */
-        NONE = 0,
-        /**
-         * The first animation will start.
-         */
-        FIRST = 1,
-        /**
-         * All animations will start.
-         */
-        ALL = 2,
-    }
-    /**
-     * Interface that contains the data for the glTF asset.
-     */
-    interface IGLTFLoaderData {
-        /**
-         * JSON that represents the glTF.
-         */
-        json: Object;
-        /**
-         * The BIN chunk of a binary glTF
-         */
-        bin: Nullable<ArrayBufferView>;
-    }
-    /**
-     * Interface for extending the loader.
-     */
-    interface IGLTFLoaderExtension {
-        /**
-         * The name of this extension.
-         */
-        readonly name: string;
-        /**
-         * Defines whether this extension is enabled.
-         */
-        enabled: boolean;
-    }
-    /**
-     * Loader state.
-     */
-    enum GLTFLoaderState {
-        /**
-         * The asset is loading.
-         */
-        LOADING = 0,
-        /**
-         * The asset is ready for rendering.
-         */
-        READY = 1,
-        /**
-         * The asset is completely loaded.
-         */
-        COMPLETE = 2,
-    }
-    /**
-     * Loader interface.
-     */
-    interface IGLTFLoader extends IDisposable {
-        /**
-         * Mode that determines the coordinate system to use.
-         */
-        coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
-        /**
-         * Mode that determines what animations will start.
-         */
-        animationStartMode: GLTFLoaderAnimationStartMode;
-        /**
-         * Defines if the loader should compile materials.
-         */
-        compileMaterials: boolean;
-        /**
-         * Defines if the loader should also compile materials with clip planes.
-         */
-        useClipPlane: boolean;
-        /**
-         * Defines if the loader should compile shadow generators.
-         */
-        compileShadowGenerators: boolean;
-        /**
-         * Defines if the Alpha blended materials are only applied as coverage.
-         * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
-         * If true, no extra effects are applied to transparent pixels.
-         */
-        transparencyAsCoverage: boolean;
-        /** @hidden */
-        _normalizeAnimationGroupsToBeginAtZero: boolean;
-        /**
-         * Function called before loading a url referenced by the asset.
-         */
-        preprocessUrlAsync: (url: string) => Promise<string>;
-        /**
-         * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         */
-        onMeshLoadedObservable: Observable<AbstractMesh>;
-        /**
-         * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
-         */
-        onTextureLoadedObservable: Observable<BaseTexture>;
-        /**
-         * Observable raised when the loader creates a material after parsing the glTF properties of the material.
-         */
-        onMaterialLoadedObservable: Observable<Material>;
-        /**
-         * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
-         */
-        onCameraLoadedObservable: Observable<Camera>;
-        /**
-         * Observable raised when the asset is completely loaded, immediately before the loader is disposed.
-         * For assets with LODs, raised when all of the LODs are complete.
-         * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
-         */
-        onCompleteObservable: Observable<IGLTFLoader>;
-        /**
-         * Observable raised after the loader is disposed.
-         */
-        onDisposeObservable: Observable<IGLTFLoader>;
-        /**
-         * Observable raised after a loader extension is created.
-         * Set additional options for a loader extension in this event.
-         */
-        onExtensionLoadedObservable: Observable<IGLTFLoaderExtension>;
-        /**
-         * Loader state or null if the loader is not active.
-         */
-        state: Nullable<GLTFLoaderState>;
-        /**
-         * Imports meshes from the given data and adds them to the scene.
-         */
-        importMeshAsync: (meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: ParticleSystem[];
-            skeletons: Skeleton[];
-            animationGroups: AnimationGroup[];
-        }>;
-        /**
-         * Loads all objects from the given data and adds them to the scene.
-         */
-        loadAsync: (scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void) => Promise<void>;
-    }
-    /**
-     * File loader for loading glTF files into a scene.
-     */
-    class GLTFFileLoader implements IDisposable, ISceneLoaderPluginAsync, ISceneLoaderPluginFactory {
-        /**
-         * Factory function that creates a glTF 1.0 loader
-         */
-        static CreateGLTFLoaderV1: () => IGLTFLoader;
-        /**
-         * Factory function that creates a glTF 2.0 loader
-         */
-        static CreateGLTFLoaderV2: () => IGLTFLoader;
-        /**
-         * Raised when the asset has been parsed
-         */
-        onParsedObservable: Observable<IGLTFLoaderData>;
-        private _onParsedObserver;
-        /**
-         * Raised when the asset has been parsed
-         */
-        onParsed: (loaderData: IGLTFLoaderData) => void;
-        /**
-         * Set this property to false to disable incremental loading which delays the loader from calling the success callback until after loading the meshes and shaders.
-         * Textures always loads asynchronously. For example, the success callback can compute the bounding information of the loaded meshes when incremental loading is disabled.
-         * Defaults to true.
-         */
-        static IncrementalLoading: boolean;
-        /**
-         * Set this property to true in order to work with homogeneous coordinates, available with some converters and exporters.
-         * Defaults to false. See https://en.wikipedia.org/wiki/Homogeneous_coordinates.
-         */
-        static HomogeneousCoordinates: boolean;
-        /**
-         * The coordinate system mode. Defaults to AUTO.
-         */
-        coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
-        /**
-        * The animation start mode. Defaults to FIRST.
-        */
-        animationStartMode: GLTFLoaderAnimationStartMode;
-        /**
-         * Defines if the loader should compile materials before raising the success callback. Defaults to false.
-         */
-        compileMaterials: boolean;
-        /**
-         * Defines if the loader should also compile materials with clip planes. Defaults to false.
-         */
-        useClipPlane: boolean;
-        /**
-         * Defines if the loader should compile shadow generators before raising the success callback. Defaults to false.
-         */
-        compileShadowGenerators: boolean;
-        /**
-         * Defines if the Alpha blended materials are only applied as coverage.
-         * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
-         * If true, no extra effects are applied to transparent pixels.
-         */
-        transparencyAsCoverage: boolean;
-        /** @hidden */
-        _normalizeAnimationGroupsToBeginAtZero: boolean;
-        /**
-         * Function called before loading a url referenced by the asset.
-         */
-        preprocessUrlAsync: (url: string) => Promise<string>;
-        /**
-         * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         */
-        readonly onMeshLoadedObservable: Observable<AbstractMesh>;
-        private _onMeshLoadedObserver;
-        /**
-         * Callback raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         */
-        onMeshLoaded: (mesh: AbstractMesh) => void;
-        /**
-         * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
-         */
-        readonly onTextureLoadedObservable: Observable<BaseTexture>;
-        private _onTextureLoadedObserver;
-        /**
-         * Callback raised when the loader creates a texture after parsing the glTF properties of the texture.
-         */
-        onTextureLoaded: (texture: BaseTexture) => void;
-        /**
-         * Observable raised when the loader creates a material after parsing the glTF properties of the material.
-         */
-        readonly onMaterialLoadedObservable: Observable<Material>;
-        private _onMaterialLoadedObserver;
-        /**
-         * Callback raised when the loader creates a material after parsing the glTF properties of the material.
-         */
-        onMaterialLoaded: (material: Material) => void;
-        /**
-         * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
-         */
-        readonly onCameraLoadedObservable: Observable<Camera>;
-        private _onCameraLoadedObserver;
-        /**
-         * Callback raised when the loader creates a camera after parsing the glTF properties of the camera.
-         */
-        onCameraLoaded: (camera: Camera) => void;
-        /**
-         * Observable raised when the asset is completely loaded, immediately before the loader is disposed.
-         * For assets with LODs, raised when all of the LODs are complete.
-         * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
-         */
-        readonly onCompleteObservable: Observable<GLTFFileLoader>;
-        private _onCompleteObserver;
-        /**
-         * Callback raised when the asset is completely loaded, immediately before the loader is disposed.
-         */
-        onComplete: () => void;
-        /**
-         * Observable raised after the loader is disposed.
-         */
-        readonly onDisposeObservable: Observable<GLTFFileLoader>;
-        private _onDisposeObserver;
-        /**
-         * Callback raised after the loader is disposed.
-         */
-        onDispose: () => void;
-        /**
-         * Observable raised after a loader extension is created.
-         * Set additional options for a loader extension in this event.
-         */
-        readonly onExtensionLoadedObservable: Observable<IGLTFLoaderExtension>;
-        private _onExtensionLoadedObserver;
-        /**
-         * Callback raised after a loader extension is created.
-         */
-        onExtensionLoaded: (extension: IGLTFLoaderExtension) => void;
-        /**
-         * Returns a promise that resolves when the asset is completely loaded.
-         * @returns a promise that resolves when the asset is completely loaded.
-         */
-        whenCompleteAsync(): Promise<void>;
-        /**
-         * The loader state or null if the loader is not active.
-         */
-        readonly loaderState: Nullable<GLTFLoaderState>;
-        private _loader;
-        /**
-         * Name of the loader ("gltf")
-         */
-        name: string;
-        /**
-         * Supported file extensions of the loader (.gltf, .glb)
-         */
-        extensions: ISceneLoaderPluginExtensions;
-        /**
-         * Disposes the loader, releases resources during load, and cancels any outstanding requests.
-         */
-        dispose(): void;
-        /**
-         * Imports one or more meshes from the loaded glTF data and adds them to the scene
-         * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
-         * @param scene the scene the meshes should be added to
-         * @param data the glTF data to load
-         * @param rootUrl root url to load from
-         * @param onProgress event that fires when loading progress has occured
-         * @returns a promise containg the loaded meshes, particles, skeletons and animations
-         */
-        importMeshAsync(meshesNames: any, scene: Scene, data: any, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: ParticleSystem[];
-            skeletons: Skeleton[];
-            animationGroups: AnimationGroup[];
-        }>;
-        /**
-         * Imports all objects from the loaded glTF data and adds them to the scene
-         * @param scene the scene the objects should be added to
-         * @param data the glTF data to load
-         * @param rootUrl root url to load from
-         * @param onProgress event that fires when loading progress has occured
-         * @returns a promise which completes when objects have been loaded to the scene
-         */
-        loadAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<void>;
-        /**
-         * 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 onProgress The callback when the load progresses
-         * @returns The loaded asset container
-         */
-        loadAssetContainerAsync(scene: Scene, data: string | ArrayBuffer, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<AssetContainer>;
-        /**
-         * If the data string can be loaded directly.
-         * @param data string contianing the file data
-         * @returns if the data can be loaded directly
-         */
-        canDirectLoad(data: string): boolean;
-        /**
-         * Rewrites a url by combining a root url and response url.
-         */
-        rewriteRootURL: (rootUrl: string, responseURL?: string) => string;
-        /**
-         * Instantiates a glTF file loader plugin.
-         * @returns the created plugin
-         */
-        createPlugin(): ISceneLoaderPlugin | ISceneLoaderPluginAsync;
-        private _parse(data);
-        private _getLoader(loaderData);
-        private static _parseBinary(data);
-        private static _parseV1(binaryReader);
-        private static _parseV2(binaryReader);
-        private static _parseVersion(version);
-        private static _compareVersion(a, b);
-        private static _decodeBufferToText(buffer);
-    }
-}
-
-
-declare module BABYLON.GLTF2 {
-    /** @hidden */
-    interface _IArrayItem {
-        _index: number;
-    }
-    /** @hidden */
-    class _ArrayItem {
-        /** @hidden */
-        static Assign(values?: _IArrayItem[]): void;
-    }
-}
-
-
-
-declare module BABYLON.GLTF2 {
-    /** @hidden */
-    interface _ILoaderAccessor extends IAccessor, _IArrayItem {
-        _data?: Promise<ArrayBufferView>;
-        _babylonVertexBuffer?: Promise<VertexBuffer>;
-    }
-    /** @hidden */
-    interface _ILoaderAnimationChannel extends IAnimationChannel, _IArrayItem {
-    }
-    /** @hidden */
-    interface _ILoaderAnimationSamplerData {
-        input: Float32Array;
-        interpolation: AnimationSamplerInterpolation;
-        output: Float32Array;
-    }
-    /** @hidden */
-    interface _ILoaderAnimationSampler extends IAnimationSampler, _IArrayItem {
-        _data: Promise<_ILoaderAnimationSamplerData>;
-    }
-    /** @hidden */
-    interface _ILoaderAnimation extends IAnimation, _IArrayItem {
-        channels: _ILoaderAnimationChannel[];
-        samplers: _ILoaderAnimationSampler[];
-        _babylonAnimationGroup?: AnimationGroup;
-    }
-    /** @hidden */
-    interface _ILoaderBuffer extends IBuffer, _IArrayItem {
-        _data?: Promise<ArrayBufferView>;
-    }
-    /** @hidden */
-    interface _ILoaderBufferView extends IBufferView, _IArrayItem {
-        _data?: Promise<ArrayBufferView>;
-        _babylonBuffer?: Promise<Buffer>;
-    }
-    /** @hidden */
-    interface _ILoaderCamera extends ICamera, _IArrayItem {
-    }
-    /** @hidden */
-    interface _ILoaderImage extends IImage, _IArrayItem {
-        _objectURL?: Promise<string>;
-    }
-    /** @hidden */
-    interface _ILoaderMaterial extends IMaterial, _IArrayItem {
-        _babylonData?: {
-            [drawMode: number]: {
-                material: Material;
-                meshes: AbstractMesh[];
-                loaded: Promise<void>;
-            };
-        };
-    }
-    /** @hidden */
-    interface _ILoaderMesh extends IMesh, _IArrayItem {
-        primitives: _ILoaderMeshPrimitive[];
-    }
-    /** @hidden */
-    interface _ILoaderMeshPrimitive extends IMeshPrimitive, _IArrayItem {
-    }
-    /** @hidden */
-    interface _ILoaderNode extends INode, _IArrayItem {
-        _parent: _ILoaderNode;
-        _babylonMesh?: Mesh;
-        _primitiveBabylonMeshes?: Mesh[];
-        _babylonBones?: Bone[];
-        _numMorphTargets?: number;
-    }
-    /** @hidden */
-    interface _ILoaderSamplerData {
-        noMipMaps: boolean;
-        samplingMode: number;
-        wrapU: number;
-        wrapV: number;
-    }
-    /** @hidden */
-    interface _ILoaderSampler extends ISampler, _IArrayItem {
-        _data?: _ILoaderSamplerData;
-    }
-    /** @hidden */
-    interface _ILoaderScene extends IScene, _IArrayItem {
-    }
-    /** @hidden */
-    interface _ILoaderSkin extends ISkin, _IArrayItem {
-        _babylonSkeleton?: Skeleton;
-        _loaded?: Promise<void>;
-    }
-    /** @hidden */
-    interface _ILoaderTexture extends ITexture, _IArrayItem {
-    }
-    /** @hidden */
-    interface _ILoaderGLTF extends IGLTF {
-        accessors?: _ILoaderAccessor[];
-        animations?: _ILoaderAnimation[];
-        buffers?: _ILoaderBuffer[];
-        bufferViews?: _ILoaderBufferView[];
-        cameras?: _ILoaderCamera[];
-        images?: _ILoaderImage[];
-        materials?: _ILoaderMaterial[];
-        meshes?: _ILoaderMesh[];
-        nodes?: _ILoaderNode[];
-        samplers?: _ILoaderSampler[];
-        scenes?: _ILoaderScene[];
-        skins?: _ILoaderSkin[];
-        textures?: _ILoaderTexture[];
-    }
-}
-
-
-/**
- * Defines the module used to import/export glTF 2.0 assets
- */
-declare module BABYLON.GLTF2 {
-    /**
-     * Loader for loading a glTF 2.0 asset
-     */
-    class GLTFLoader implements IGLTFLoader {
-        /** @hidden */
-        _gltf: _ILoaderGLTF;
-        /** @hidden */
-        _babylonScene: Scene;
-        /** @hidden */
-        _completePromises: Promise<void>[];
-        private _disposed;
-        private _state;
-        private _extensions;
-        private _rootUrl;
-        private _rootBabylonMesh;
-        private _defaultSampler;
-        private _defaultBabylonMaterials;
-        private _progressCallback?;
-        private _requests;
-        private static _ExtensionNames;
-        private static _ExtensionFactories;
-        /** @hidden */
-        static _Register(name: string, factory: (loader: GLTFLoader) => GLTFLoaderExtension): void;
-        /**
-         * Mode that determines the coordinate system to use.
-         */
-        coordinateSystemMode: GLTFLoaderCoordinateSystemMode;
-        /**
-         * Mode that determines what animations will start.
-         */
-        animationStartMode: GLTFLoaderAnimationStartMode;
-        /**
-         * Defines if the loader should compile materials.
-         */
-        compileMaterials: boolean;
-        /**
-         * Defines if the loader should also compile materials with clip planes.
-         */
-        useClipPlane: boolean;
-        /**
-         * Defines if the loader should compile shadow generators.
-         */
-        compileShadowGenerators: boolean;
-        /**
-         * Defines if the Alpha blended materials are only applied as coverage.
-         * If false, (default) The luminance of each pixel will reduce its opacity to simulate the behaviour of most physical materials.
-         * If true, no extra effects are applied to transparent pixels.
-         */
-        transparencyAsCoverage: boolean;
-        /** @hidden */
-        _normalizeAnimationGroupsToBeginAtZero: boolean;
-        /**
-         * Function called before loading a url referenced by the asset.
-         */
-        preprocessUrlAsync: (url: string) => Promise<string>;
-        /**
-         * Observable raised when the loader creates a mesh after parsing the glTF properties of the mesh.
-         */
-        readonly onMeshLoadedObservable: Observable<AbstractMesh>;
-        /**
-         * Observable raised when the loader creates a texture after parsing the glTF properties of the texture.
-         */
-        readonly onTextureLoadedObservable: Observable<BaseTexture>;
-        /**
-         * Observable raised when the loader creates a material after parsing the glTF properties of the material.
-         */
-        readonly onMaterialLoadedObservable: Observable<Material>;
-        /**
-         * Observable raised when the loader creates a camera after parsing the glTF properties of the camera.
-         */
-        readonly onCameraLoadedObservable: Observable<Camera>;
-        /**
-         * Observable raised when the asset is completely loaded, immediately before the loader is disposed.
-         * For assets with LODs, raised when all of the LODs are complete.
-         * For assets without LODs, raised when the model is complete, immediately after the loader resolves the returned promise.
-         */
-        readonly onCompleteObservable: Observable<IGLTFLoader>;
-        /**
-         * Observable raised after the loader is disposed.
-         */
-        readonly onDisposeObservable: Observable<IGLTFLoader>;
-        /**
-         * Observable raised after a loader extension is created.
-         * Set additional options for a loader extension in this event.
-         */
-        readonly onExtensionLoadedObservable: Observable<IGLTFLoaderExtension>;
-        /**
-         * Loader state or null if the loader is not active.
-         */
-        readonly state: Nullable<GLTFLoaderState>;
-        /**
-         * Disposes the loader, releases resources during load, and cancels any outstanding requests.
-         */
-        dispose(): void;
-        /**
-         * Imports one or more meshes from the loaded glTF data and adds them to the scene
-         * @param meshesNames a string or array of strings of the mesh names that should be loaded from the file
-         * @param scene the scene the meshes should be added to
-         * @param data the glTF data to load
-         * @param rootUrl root url to load from
-         * @param onProgress event that fires when loading progress has occured
-         * @returns a promise containg the loaded meshes, particles, skeletons and animations
-         */
-        importMeshAsync(meshesNames: any, scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<{
-            meshes: AbstractMesh[];
-            particleSystems: ParticleSystem[];
-            skeletons: Skeleton[];
-            animationGroups: AnimationGroup[];
-        }>;
-        /**
-         * Imports all objects from the loaded glTF data and adds them to the scene
-         * @param scene the scene the objects should be added to
-         * @param data the glTF data to load
-         * @param rootUrl root url to load from
-         * @param onProgress event that fires when loading progress has occured
-         * @returns a promise which completes when objects have been loaded to the scene
-         */
-        loadAsync(scene: Scene, data: IGLTFLoaderData, rootUrl: string, onProgress?: (event: SceneLoaderProgressEvent) => void): Promise<void>;
-        private _loadAsync(nodes, scene, data, rootUrl, onProgress?);
-        private _loadData(data);
-        private _setupData();
-        private _loadExtensions();
-        private _checkExtensions();
-        private _createRootNode();
-        private _loadNodesAsync(nodes);
-        /** @hidden */
-        _loadSceneAsync(context: string, scene: _ILoaderScene): Promise<void>;
-        private _forEachPrimitive(node, callback);
-        private _getMeshes();
-        private _getSkeletons();
-        private _getAnimationGroups();
-        private _startAnimations();
-        /** @hidden */
-        _loadNodeAsync(context: string, node: _ILoaderNode): Promise<void>;
-        private _loadMeshAsync(context, node, mesh, babylonMesh);
-        private _loadPrimitiveAsync(context, node, mesh, primitive, babylonMesh);
-        private _loadVertexDataAsync(context, primitive, babylonMesh);
-        private _createMorphTargets(context, node, mesh, primitive, babylonMesh);
-        private _loadMorphTargetsAsync(context, primitive, babylonMesh, babylonGeometry);
-        private _loadMorphTargetVertexDataAsync(context, babylonGeometry, attributes, babylonMorphTarget);
-        private static _LoadTransform(node, babylonNode);
-        private _loadSkinAsync(context, node, mesh, skin);
-        private _loadBones(context, skin);
-        private _loadBone(node, skin, babylonBones);
-        private _loadSkinInverseBindMatricesDataAsync(context, skin);
-        private _updateBoneMatrices(babylonSkeleton, inverseBindMatricesData);
-        private _getNodeMatrix(node);
-        private _loadCamera(context, camera, babylonMesh);
-        private _loadAnimationsAsync();
-        private _loadAnimationAsync(context, animation);
-        private _loadAnimationChannelAsync(context, animationContext, animation, channel, babylonAnimationGroup);
-        private _loadAnimationSamplerAsync(context, sampler);
-        private _loadBufferAsync(context, buffer);
-        /** @hidden */
-        _loadBufferViewAsync(context: string, bufferView: _ILoaderBufferView): Promise<ArrayBufferView>;
-        private _loadIndicesAccessorAsync(context, accessor);
-        private _loadFloatAccessorAsync(context, accessor);
-        /** @hidden */
-        _loadVertexBufferViewAsync(context: string, bufferView: _ILoaderBufferView, kind: string): Promise<Buffer>;
-        private _loadVertexAccessorAsync(context, accessor, kind);
-        private _getDefaultMaterial(drawMode);
-        private _loadMaterialMetallicRoughnessPropertiesAsync(context, material, babylonMaterial);
-        /** @hidden */
-        _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Promise<void>;
-        /** @hidden */
-        _createMaterial(name: string, drawMode: number): PBRMaterial;
-        /** @hidden */
-        _loadMaterialBasePropertiesAsync(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): Promise<void>;
-        /** @hidden */
-        _loadMaterialAlphaProperties(context: string, material: _ILoaderMaterial, babylonMaterial: PBRMaterial): void;
-        /** @hidden */
-        _loadTextureAsync(context: string, textureInfo: ITextureInfo, assign: (texture: Texture) => void): Promise<void>;
-        private _loadSampler(context, sampler);
-        private _loadImageAsync(context, image);
-        /** @hidden */
-        _loadUriAsync(context: string, uri: string): Promise<ArrayBufferView>;
-        private _onProgress();
-        /** @hidden */
-        static _GetProperty<T>(context: string, array: ArrayLike<T> | undefined, index: number | undefined): T;
-        private static _GetTextureWrapMode(context, mode);
-        private static _GetTextureSamplingMode(context, magFilter?, minFilter?);
-        private static _GetTypedArray(context, componentType, bufferView, byteOffset, length);
-        private static _GetNumComponents(context, type);
-        private static _ValidateUri(uri);
-        private static _GetDrawMode(context, mode);
-        private _compileMaterialsAsync();
-        private _compileShadowGeneratorsAsync();
-        private _clear();
-        /** @hidden */
-        _applyExtensions<T>(actionAsync: (extension: GLTFLoaderExtension) => Nullable<Promise<T>>): Nullable<Promise<T>>;
-    }
-}
-
-
-declare module BABYLON.GLTF2 {
-    /**
-     * Abstract class that can be implemented to extend existing glTF loader behavior.
-     */
-    abstract class GLTFLoaderExtension implements IGLTFLoaderExtension, IDisposable {
-        enabled: boolean;
-        readonly abstract name: string;
-        protected _loader: GLTFLoader;
-        constructor(loader: GLTFLoader);
-        dispose(): void;
-        /** Override this method to modify the default behavior for loading scenes. */
-        protected _loadSceneAsync(context: string, node: _ILoaderScene): Nullable<Promise<void>>;
-        /** Override this method to modify the default behavior for loading nodes. */
-        protected _loadNodeAsync(context: string, node: _ILoaderNode): Nullable<Promise<void>>;
-        /** Override this method to modify the default behavior for loading mesh primitive vertex data. */
-        protected _loadVertexDataAsync(context: string, primitive: _ILoaderMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>>;
-        /** Override this method to modify the default behavior for loading materials. */
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
-        /** Override this method to modify the default behavior for loading textures. */
-        protected _loadTextureAsync(context: string, textureInfo: ITextureInfo, assign: (texture: Texture) => void): Nullable<Promise<void>>;
-        /** Override this method to modify the default behavior for loading uris. */
-        protected _loadUriAsync(context: string, uri: string): Nullable<Promise<ArrayBufferView>>;
-        /** Helper method called by a loader extension to load an glTF extension. */
-        protected _loadExtensionAsync<TProperty, TResult = void>(context: string, property: IProperty, actionAsync: (extensionContext: string, extension: TProperty) => Promise<TResult>): Nullable<Promise<TResult>>;
-        /** Helper method called by the loader to allow extensions to override loading scenes. */
-        static _LoadSceneAsync(loader: GLTFLoader, context: string, scene: _ILoaderScene): Nullable<Promise<void>>;
-        /** Helper method called by the loader to allow extensions to override loading nodes. */
-        static _LoadNodeAsync(loader: GLTFLoader, context: string, node: _ILoaderNode): Nullable<Promise<void>>;
-        /** Helper method called by the loader to allow extensions to override loading mesh primitive vertex data. */
-        static _LoadVertexDataAsync(loader: GLTFLoader, context: string, primitive: _ILoaderMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>>;
-        /** Helper method called by the loader to allow extensions to override loading materials. */
-        static _LoadMaterialAsync(loader: GLTFLoader, context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
-        /** Helper method called by the loader to allow extensions to override loading textures. */
-        static _LoadTextureAsync(loader: GLTFLoader, context: string, textureInfo: ITextureInfo, assign: (texture: Texture) => void): Nullable<Promise<void>>;
-        /** Helper method called by the loader to allow extensions to override loading uris. */
-        static _LoadUriAsync(loader: GLTFLoader, context: string, uri: string): Nullable<Promise<ArrayBufferView>>;
-    }
-}
-/**
- * Defines the module of the glTF 2.0 loader extensions.
- */
-declare module BABYLON.GLTF2.Extensions {
-}
-
-
-declare module BABYLON.GLTF2.Extensions {
-    /**
-     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Vendor/MSFT_lod)
-     */
-    class MSFT_lod extends GLTFLoaderExtension {
-        readonly name: string;
-        /**
-         * Maximum number of LODs to load, starting from the lowest LOD.
-         */
-        maxLODsToLoad: number;
-        private _loadingNodeLOD;
-        private _loadNodeSignals;
-        private _loadingMaterialLOD;
-        private _loadMaterialSignals;
-        protected _loadNodeAsync(context: string, node: _ILoaderNode): Nullable<Promise<void>>;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
-        protected _loadUriAsync(context: string, uri: string): Nullable<Promise<ArrayBufferView>>;
-        /**
-         * Gets an array of LOD properties from lowest to highest.
-         */
-        private _getLODs<T>(context, property, array, ids);
-    }
-}
-
-
-declare module BABYLON.GLTF2.Extensions {
-    /** @hidden */
-    class MSFT_minecraftMesh extends GLTFLoaderExtension {
-        readonly name: string;
-        constructor(loader: GLTFLoader);
-        private _onMaterialLoaded;
-    }
-}
-
-
-declare module BABYLON.GLTF2.Extensions {
-    /** @hidden */
-    class MSFT_sRGBFactors extends GLTFLoaderExtension {
-        readonly name: string;
-        constructor(loader: GLTFLoader);
-        private _onMaterialLoaded;
-    }
-}
-
-
-declare module BABYLON.GLTF2.Extensions {
-    /**
-     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_draco_mesh_compression)
-     */
-    class KHR_draco_mesh_compression extends GLTFLoaderExtension {
-        readonly name: string;
-        private _dracoCompression;
-        constructor(loader: GLTFLoader);
-        dispose(): void;
-        protected _loadVertexDataAsync(context: string, primitive: _ILoaderMeshPrimitive, babylonMesh: Mesh): Nullable<Promise<Geometry>>;
-    }
-}
-
-
-declare module BABYLON.GLTF2.Extensions {
-    /**
-     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_pbrSpecularGlossiness)
-     */
-    class KHR_materials_pbrSpecularGlossiness extends GLTFLoaderExtension {
-        readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
-        private _loadSpecularGlossinessPropertiesAsync(context, material, properties, babylonMaterial);
-    }
-}
-
-
-declare module BABYLON.GLTF2.Extensions {
-    /**
-     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
-     */
-    class KHR_materials_unlit extends GLTFLoaderExtension {
-        readonly name: string;
-        protected _loadMaterialAsync(context: string, material: _ILoaderMaterial, babylonMesh: Mesh, babylonDrawMode: number, assign: (babylonMaterial: Material) => void): Nullable<Promise<void>>;
-        private _loadUnlitPropertiesAsync(context, material, babylonMaterial);
-    }
-}
-
-
-declare module BABYLON.GLTF2.Extensions {
-    /**
-     * [Specification](https://github.com/MiiBond/glTF/tree/khr_lights_v1/extensions/Khronos/KHR_lights) (Experimental)
-     */
-    class KHR_lights extends GLTFLoaderExtension {
-        readonly name: string;
-        protected _loadSceneAsync(context: string, scene: _ILoaderScene): Nullable<Promise<void>>;
-        protected _loadNodeAsync(context: string, node: _ILoaderNode): Nullable<Promise<void>>;
-        private readonly _lights;
-    }
-}
-
-
-declare module BABYLON.GLTF2.Extensions {
-    /**
-     * [Specification](https://github.com/AltspaceVR/glTF/blob/avr-sampler-offset-tile/extensions/2.0/Khronos/KHR_texture_transform/README.md) (Experimental)
-     */
-    class KHR_texture_transform extends GLTFLoaderExtension {
-        readonly name: string;
-        protected _loadTextureAsync(context: string, textureInfo: ITextureInfo, assign: (texture: Texture) => void): Nullable<Promise<void>>;
-    }
-}

dist/preview release/loaders/babylon.objFileLoader.d.ts

@@ -1,77 +0,0 @@
-
-declare module BABYLON {
-    /**
-     * Class reading and parsing the MTL file bundled with the obj file.
-     */
-    class MTLFileLoader {
-        materials: BABYLON.StandardMaterial[];
-        /**
-         * This function will read the mtl file and create each material described inside
-         * This function could be improve by adding :
-         * -some component missing (Ni, Tf...)
-         * -including the specific options available
-         *
-         * @param scene
-         * @param data
-         * @param rootUrl
-         */
-        parseMTL(scene: BABYLON.Scene, data: string | ArrayBuffer, rootUrl: string): void;
-        /**
-         * Gets the texture for the material.
-         *
-         * If the material is imported from input file,
-         * We sanitize the url to ensure it takes the textre from aside the material.
-         *
-         * @param rootUrl The root url to load from
-         * @param value The value stored in the mtl
-         * @return The Texture
-         */
-        private static _getTexture(rootUrl, value, scene);
-    }
-    class OBJFileLoader implements ISceneLoaderPlugin {
-        static OPTIMIZE_WITH_UV: boolean;
-        static INVERT_Y: boolean;
-        name: string;
-        extensions: string;
-        obj: RegExp;
-        group: RegExp;
-        mtllib: RegExp;
-        usemtl: RegExp;
-        smooth: RegExp;
-        vertexPattern: RegExp;
-        normalPattern: RegExp;
-        uvPattern: RegExp;
-        facePattern1: RegExp;
-        facePattern2: RegExp;
-        facePattern3: RegExp;
-        facePattern4: RegExp;
-        /**
-         * Calls synchronously the MTL file attached to this obj.
-         * Load function or importMesh function don't enable to load 2 files in the same time asynchronously.
-         * Without this function materials are not displayed in the first frame (but displayed after).
-         * In consequence it is impossible to get material information in your HTML file
-         *
-         * @param url The URL of the MTL file
-         * @param rootUrl
-         * @param onSuccess Callback function to be called when the MTL file is loaded
-         * @private
-         */
-        private _loadMTL(url, rootUrl, onSuccess);
-        importMesh(meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: Nullable<AbstractMesh[]>, particleSystems: Nullable<ParticleSystem[]>, skeletons: Nullable<Skeleton[]>): boolean;
-        load(scene: Scene, data: string, rootUrl: string): boolean;
-        loadAssetContainer(scene: Scene, data: string, rootUrl: string, onError?: (message: string, exception?: any) => void): AssetContainer;
-        /**
-         * Read the OBJ file and create an Array of meshes.
-         * Each mesh contains all information given by the OBJ and the MTL file.
-         * i.e. vertices positions and indices, optional normals values, optional UV values, optional material
-         *
-         * @param meshesNames
-         * @param scene BABYLON.Scene The scene where are displayed the data
-         * @param data String The content of the obj file
-         * @param rootUrl String The path to the folder
-         * @returns Array<AbstractMesh>
-         * @private
-         */
-        private _parseSolid(meshesNames, scene, data, rootUrl);
-    }
-}

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

@@ -1,803 +0,0 @@
-/// <reference path="../../../dist/preview release/babylon.d.ts"/>
-var BABYLON;
-(function (BABYLON) {
-    /**
-     * Class reading and parsing the MTL file bundled with the obj file.
-     */
-    var MTLFileLoader = /** @class */ (function () {
-        function MTLFileLoader() {
-            // All material loaded from the mtl will be set here
-            this.materials = [];
-        }
-        /**
-         * This function will read the mtl file and create each material described inside
-         * This function could be improve by adding :
-         * -some component missing (Ni, Tf...)
-         * -including the specific options available
-         *
-         * @param scene
-         * @param data
-         * @param rootUrl
-         */
-        MTLFileLoader.prototype.parseMTL = function (scene, data, rootUrl) {
-            if (data instanceof ArrayBuffer) {
-                return;
-            }
-            //Split the lines from the file
-            var lines = data.split('\n');
-            //Space char
-            var delimiter_pattern = /\s+/;
-            //Array with RGB colors
-            var color;
-            //New material
-            var material = null;
-            //Look at each line
-            for (var i = 0; i < lines.length; i++) {
-                var line = lines[i].trim();
-                // Blank line or comment
-                if (line.length === 0 || line.charAt(0) === '#') {
-                    continue;
-                }
-                //Get the first parameter (keyword)
-                var pos = line.indexOf(' ');
-                var key = (pos >= 0) ? line.substring(0, pos) : line;
-                key = key.toLowerCase();
-                //Get the data following the key
-                var value = (pos >= 0) ? line.substring(pos + 1).trim() : "";
-                //This mtl keyword will create the new material
-                if (key === "newmtl") {
-                    //Check if it is the first material.
-                    // Materials specifications are described after this keyword.
-                    if (material) {
-                        //Add the previous material in the material array.
-                        this.materials.push(material);
-                    }
-                    //Create a new material.
-                    // value is the name of the material read in the mtl file
-                    material = new BABYLON.StandardMaterial(value, scene);
-                }
-                else if (key === "kd" && material) {
-                    // Diffuse color (color under white light) using RGB values
-                    //value  = "r g b"
-                    color = value.split(delimiter_pattern, 3).map(parseFloat);
-                    //color = [r,g,b]
-                    //Set tghe color into the material
-                    material.diffuseColor = BABYLON.Color3.FromArray(color);
-                }
-                else if (key === "ka" && material) {
-                    // Ambient color (color under shadow) using RGB values
-                    //value = "r g b"
-                    color = value.split(delimiter_pattern, 3).map(parseFloat);
-                    //color = [r,g,b]
-                    //Set tghe color into the material
-                    material.ambientColor = BABYLON.Color3.FromArray(color);
-                }
-                else if (key === "ks" && material) {
-                    // Specular color (color when light is reflected from shiny surface) using RGB values
-                    //value = "r g b"
-                    color = value.split(delimiter_pattern, 3).map(parseFloat);
-                    //color = [r,g,b]
-                    //Set the color into the material
-                    material.specularColor = BABYLON.Color3.FromArray(color);
-                }
-                else if (key === "ke" && material) {
-                    // Emissive color using RGB values
-                    color = value.split(delimiter_pattern, 3).map(parseFloat);
-                    material.emissiveColor = BABYLON.Color3.FromArray(color);
-                }
-                else if (key === "ns" && material) {
-                    //value = "Integer"
-                    material.specularPower = parseFloat(value);
-                }
-                else if (key === "d" && material) {
-                    //d is dissolve for current material. It mean alpha for BABYLON
-                    material.alpha = parseFloat(value);
-                    //Texture
-                    //This part can be improved by adding the possible options of texture
-                }
-                else if (key === "map_ka" && material) {
-                    // ambient texture map with a loaded image
-                    //We must first get the folder of the image
-                    material.ambientTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
-                }
-                else if (key === "map_kd" && material) {
-                    // Diffuse texture map with a loaded image
-                    material.diffuseTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
-                }
-                else if (key === "map_ks" && material) {
-                    // Specular texture map with a loaded image
-                    //We must first get the folder of the image
-                    material.specularTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
-                }
-                else if (key === "map_ns") {
-                    //Specular
-                    //Specular highlight component
-                    //We must first get the folder of the image
-                    //
-                    //Not supported by BABYLON
-                    //
-                    //    continue;
-                }
-                else if (key === "map_bump" && material) {
-                    //The bump texture
-                    material.bumpTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
-                }
-                else if (key === "map_d" && material) {
-                    // The dissolve of the material
-                    material.opacityTexture = MTLFileLoader._getTexture(rootUrl, value, scene);
-                    //Options for illumination
-                }
-                else if (key === "illum") {
-                    //Illumination
-                    if (value === "0") {
-                        //That mean Kd == Kd
-                    }
-                    else if (value === "1") {
-                        //Color on and Ambient on
-                    }
-                    else if (value === "2") {
-                        //Highlight on
-                    }
-                    else if (value === "3") {
-                        //Reflection on and Ray trace on
-                    }
-                    else if (value === "4") {
-                        //Transparency: Glass on, Reflection: Ray trace on
-                    }
-                    else if (value === "5") {
-                        //Reflection: Fresnel on and Ray trace on
-                    }
-                    else if (value === "6") {
-                        //Transparency: Refraction on, Reflection: Fresnel off and Ray trace on
-                    }
-                    else if (value === "7") {
-                        //Transparency: Refraction on, Reflection: Fresnel on and Ray trace on
-                    }
-                    else if (value === "8") {
-                        //Reflection on and Ray trace off
-                    }
-                    else if (value === "9") {
-                        //Transparency: Glass on, Reflection: Ray trace off
-                    }
-                    else if (value === "10") {
-                        //Casts shadows onto invisible surfaces
-                    }
-                }
-                else {
-                    // console.log("Unhandled expression at line : " + i +'\n' + "with value : " + line);
-                }
-            }
-            //At the end of the file, add the last material
-            if (material) {
-                this.materials.push(material);
-            }
-        };
-        /**
-         * Gets the texture for the material.
-         *
-         * If the material is imported from input file,
-         * We sanitize the url to ensure it takes the textre from aside the material.
-         *
-         * @param rootUrl The root url to load from
-         * @param value The value stored in the mtl
-         * @return The Texture
-         */
-        MTLFileLoader._getTexture = function (rootUrl, value, scene) {
-            if (!value) {
-                return null;
-            }
-            var url = rootUrl;
-            // Load from input file.
-            if (rootUrl === "file:") {
-                var lastDelimiter = value.lastIndexOf("\\");
-                if (lastDelimiter === -1) {
-                    lastDelimiter = value.lastIndexOf("/");
-                }
-                if (lastDelimiter > -1) {
-                    url += value.substr(lastDelimiter + 1);
-                }
-                else {
-                    url += value;
-                }
-            }
-            // Not from input file.
-            else {
-                url += value;
-            }
-            return new BABYLON.Texture(url, scene);
-        };
-        return MTLFileLoader;
-    }());
-    BABYLON.MTLFileLoader = MTLFileLoader;
-    var OBJFileLoader = /** @class */ (function () {
-        function OBJFileLoader() {
-            this.name = "obj";
-            this.extensions = ".obj";
-            this.obj = /^o/;
-            this.group = /^g/;
-            this.mtllib = /^mtllib /;
-            this.usemtl = /^usemtl /;
-            this.smooth = /^s /;
-            this.vertexPattern = /v( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
-            // vn float float float
-            this.normalPattern = /vn( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
-            // vt float float
-            this.uvPattern = /vt( +[\d|\.|\+|\-|e|E]+)( +[\d|\.|\+|\-|e|E]+)/;
-            // f vertex vertex vertex ...
-            this.facePattern1 = /f\s+(([\d]{1,}[\s]?){3,})+/;
-            // f vertex/uvs vertex/uvs vertex/uvs ...
-            this.facePattern2 = /f\s+((([\d]{1,}\/[\d]{1,}[\s]?){3,})+)/;
-            // f vertex/uvs/normal vertex/uvs/normal vertex/uvs/normal ...
-            this.facePattern3 = /f\s+((([\d]{1,}\/[\d]{1,}\/[\d]{1,}[\s]?){3,})+)/;
-            // f vertex//normal vertex//normal vertex//normal ...
-            this.facePattern4 = /f\s+((([\d]{1,}\/\/[\d]{1,}[\s]?){3,})+)/;
-        }
-        /**
-         * Calls synchronously the MTL file attached to this obj.
-         * Load function or importMesh function don't enable to load 2 files in the same time asynchronously.
-         * Without this function materials are not displayed in the first frame (but displayed after).
-         * In consequence it is impossible to get material information in your HTML file
-         *
-         * @param url The URL of the MTL file
-         * @param rootUrl
-         * @param onSuccess Callback function to be called when the MTL file is loaded
-         * @private
-         */
-        OBJFileLoader.prototype._loadMTL = function (url, rootUrl, onSuccess) {
-            //The complete path to the mtl file
-            var pathOfFile = BABYLON.Tools.BaseUrl + rootUrl + url;
-            // Loads through the babylon tools to allow fileInput search.
-            BABYLON.Tools.LoadFile(pathOfFile, onSuccess, undefined, undefined, false, function () { console.warn("Error - Unable to load " + pathOfFile); });
-        };
-        OBJFileLoader.prototype.importMesh = function (meshesNames, scene, data, rootUrl, meshes, particleSystems, skeletons) {
-            //get the meshes from OBJ file
-            var loadedMeshes = this._parseSolid(meshesNames, scene, data, rootUrl);
-            //Push meshes from OBJ file into the variable mesh of this function
-            if (meshes) {
-                loadedMeshes.forEach(function (mesh) {
-                    meshes.push(mesh);
-                });
-            }
-            return true;
-        };
-        OBJFileLoader.prototype.load = function (scene, data, rootUrl) {
-            //Get the 3D model
-            return this.importMesh(null, scene, data, rootUrl, null, null, null);
-        };
-        OBJFileLoader.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;
-        };
-        /**
-         * Read the OBJ file and create an Array of meshes.
-         * Each mesh contains all information given by the OBJ and the MTL file.
-         * i.e. vertices positions and indices, optional normals values, optional UV values, optional material
-         *
-         * @param meshesNames
-         * @param scene BABYLON.Scene The scene where are displayed the data
-         * @param data String The content of the obj file
-         * @param rootUrl String The path to the folder
-         * @returns Array<AbstractMesh>
-         * @private
-         */
-        OBJFileLoader.prototype._parseSolid = function (meshesNames, scene, data, rootUrl) {
-            var positions = []; //values for the positions of vertices
-            var normals = []; //Values for the normals
-            var uvs = []; //Values for the textures
-            var meshesFromObj = []; //[mesh] Contains all the obj meshes
-            var handledMesh; //The current mesh of meshes array
-            var indicesForBabylon = []; //The list of indices for VertexData
-            var wrappedPositionForBabylon = []; //The list of position in vectors
-            var wrappedUvsForBabylon = []; //Array with all value of uvs to match with the indices
-            var wrappedNormalsForBabylon = []; //Array with all value of normals to match with the indices
-            var tuplePosNorm = []; //Create a tuple with indice of Position, Normal, UV  [pos, norm, uvs]
-            var curPositionInIndices = 0;
-            var hasMeshes = false; //Meshes are defined in the file
-            var unwrappedPositionsForBabylon = []; //Value of positionForBabylon w/o Vector3() [x,y,z]
-            var unwrappedNormalsForBabylon = []; //Value of normalsForBabylon w/o Vector3()  [x,y,z]
-            var unwrappedUVForBabylon = []; //Value of uvsForBabylon w/o Vector3()      [x,y,z]
-            var triangles = []; //Indices from new triangles coming from polygons
-            var materialNameFromObj = ""; //The name of the current material
-            var fileToLoad = ""; //The name of the mtlFile to load
-            var materialsFromMTLFile = new MTLFileLoader();
-            var objMeshName = ""; //The name of the current obj mesh
-            var increment = 1; //Id for meshes created by the multimaterial
-            var isFirstMaterial = true;
-            /**
-             * Search for obj in the given array.
-             * This function is called to check if a couple of data already exists in an array.
-             *
-             * If found, returns the index of the founded tuple index. Returns -1 if not found
-             * @param arr Array<{ normals: Array<number>, idx: Array<number> }>
-             * @param obj Array<number>
-             * @returns {boolean}
-             */
-            var isInArray = function (arr, obj) {
-                if (!arr[obj[0]])
-                    arr[obj[0]] = { normals: [], idx: [] };
-                var idx = arr[obj[0]].normals.indexOf(obj[1]);
-                return idx === -1 ? -1 : arr[obj[0]].idx[idx];
-            };
-            var isInArrayUV = function (arr, obj) {
-                if (!arr[obj[0]])
-                    arr[obj[0]] = { normals: [], idx: [], uv: [] };
-                var idx = arr[obj[0]].normals.indexOf(obj[1]);
-                if (idx != 1 && (obj[2] == arr[obj[0]].uv[idx])) {
-                    return arr[obj[0]].idx[idx];
-                }
-                return -1;
-            };
-            /**
-             * This function set the data for each triangle.
-             * Data are position, normals and uvs
-             * If a tuple of (position, normal) is not set, add the data into the corresponding array
-             * If the tuple already exist, add only their indice
-             *
-             * @param indicePositionFromObj Integer The index in positions array
-             * @param indiceUvsFromObj Integer The index in uvs array
-             * @param indiceNormalFromObj Integer The index in normals array
-             * @param positionVectorFromOBJ Vector3 The value of position at index objIndice
-             * @param textureVectorFromOBJ Vector3 The value of uvs
-             * @param normalsVectorFromOBJ Vector3 The value of normals at index objNormale
-             */
-            var setData = function (indicePositionFromObj, indiceUvsFromObj, indiceNormalFromObj, positionVectorFromOBJ, textureVectorFromOBJ, normalsVectorFromOBJ) {
-                //Check if this tuple already exists in the list of tuples
-                var _index;
-                if (OBJFileLoader.OPTIMIZE_WITH_UV) {
-                    _index = isInArrayUV(tuplePosNorm, [
-                        indicePositionFromObj,
-                        indiceNormalFromObj,
-                        indiceUvsFromObj
-                    ]);
-                }
-                else {
-                    _index = isInArray(tuplePosNorm, [
-                        indicePositionFromObj,
-                        indiceNormalFromObj
-                    ]);
-                }
-                //If it not exists
-                if (_index == -1) {
-                    //Add an new indice.
-                    //The array of indices is only an array with his length equal to the number of triangles - 1.
-                    //We add vertices data in this order
-                    indicesForBabylon.push(wrappedPositionForBabylon.length);
-                    //Push the position of vertice for Babylon
-                    //Each element is a BABYLON.Vector3(x,y,z)
-                    wrappedPositionForBabylon.push(positionVectorFromOBJ);
-                    //Push the uvs for Babylon
-                    //Each element is a BABYLON.Vector3(u,v)
-                    wrappedUvsForBabylon.push(textureVectorFromOBJ);
-                    //Push the normals for Babylon
-                    //Each element is a BABYLON.Vector3(x,y,z)
-                    wrappedNormalsForBabylon.push(normalsVectorFromOBJ);
-                    //Add the tuple in the comparison list
-                    tuplePosNorm[indicePositionFromObj].normals.push(indiceNormalFromObj);
-                    tuplePosNorm[indicePositionFromObj].idx.push(curPositionInIndices++);
-                    if (OBJFileLoader.OPTIMIZE_WITH_UV)
-                        tuplePosNorm[indicePositionFromObj].uv.push(indiceUvsFromObj);
-                }
-                else {
-                    //The tuple already exists
-                    //Add the index of the already existing tuple
-                    //At this index we can get the value of position, normal and uvs of vertex
-                    indicesForBabylon.push(_index);
-                }
-            };
-            /**
-             * Transform BABYLON.Vector() object onto 3 digits in an array
-             */
-            var unwrapData = function () {
-                //Every array has the same length
-                for (var l = 0; l < wrappedPositionForBabylon.length; l++) {
-                    //Push the x, y, z values of each element in the unwrapped array
-                    unwrappedPositionsForBabylon.push(wrappedPositionForBabylon[l].x, wrappedPositionForBabylon[l].y, wrappedPositionForBabylon[l].z);
-                    unwrappedNormalsForBabylon.push(wrappedNormalsForBabylon[l].x, wrappedNormalsForBabylon[l].y, wrappedNormalsForBabylon[l].z);
-                    unwrappedUVForBabylon.push(wrappedUvsForBabylon[l].x, wrappedUvsForBabylon[l].y); //z is an optional value not supported by BABYLON
-                }
-                // Reset arrays for the next new meshes
-                wrappedPositionForBabylon = [];
-                wrappedNormalsForBabylon = [];
-                wrappedUvsForBabylon = [];
-                tuplePosNorm = [];
-                curPositionInIndices = 0;
-            };
-            /**
-             * Create triangles from polygons by recursion
-             * The best to understand how it works is to draw it in the same time you get the recursion.
-             * It is important to notice that a triangle is a polygon
-             * We get 4 patterns of face defined in OBJ File :
-             * facePattern1 = ["1","2","3","4","5","6"]
-             * facePattern2 = ["1/1","2/2","3/3","4/4","5/5","6/6"]
-             * facePattern3 = ["1/1/1","2/2/2","3/3/3","4/4/4","5/5/5","6/6/6"]
-             * facePattern4 = ["1//1","2//2","3//3","4//4","5//5","6//6"]
-             * Each pattern is divided by the same method
-             * @param face Array[String] The indices of elements
-             * @param v Integer The variable to increment
-             */
-            var getTriangles = function (face, v) {
-                //Work for each element of the array
-                if (v + 1 < face.length) {
-                    //Add on the triangle variable the indexes to obtain triangles
-                    triangles.push(face[0], face[v], face[v + 1]);
-                    //Incrementation for recursion
-                    v += 1;
-                    //Recursion
-                    getTriangles(face, v);
-                }
-                //Result obtained after 2 iterations:
-                //Pattern1 => triangle = ["1","2","3","1","3","4"];
-                //Pattern2 => triangle = ["1/1","2/2","3/3","1/1","3/3","4/4"];
-                //Pattern3 => triangle = ["1/1/1","2/2/2","3/3/3","1/1/1","3/3/3","4/4/4"];
-                //Pattern4 => triangle = ["1//1","2//2","3//3","1//1","3//3","4//4"];
-            };
-            /**
-             * Create triangles and push the data for each polygon for the pattern 1
-             * In this pattern we get vertice positions
-             * @param face
-             * @param v
-             */
-            var setDataForCurrentFaceWithPattern1 = function (face, v) {
-                //Get the indices of triangles for each polygon
-                getTriangles(face, v);
-                //For each element in the triangles array.
-                //This var could contains 1 to an infinity of triangles
-                for (var k = 0; k < triangles.length; k++) {
-                    // Set position indice
-                    var indicePositionFromObj = parseInt(triangles[k]) - 1;
-                    setData(indicePositionFromObj, 0, 0, //In the pattern 1, normals and uvs are not defined
-                    positions[indicePositionFromObj], //Get the vectors data
-                    BABYLON.Vector2.Zero(), BABYLON.Vector3.Up() //Create default vectors
-                    );
-                }
-                //Reset variable for the next line
-                triangles = [];
-            };
-            /**
-             * Create triangles and push the data for each polygon for the pattern 2
-             * In this pattern we get vertice positions and uvsu
-             * @param face
-             * @param v
-             */
-            var setDataForCurrentFaceWithPattern2 = function (face, v) {
-                //Get the indices of triangles for each polygon
-                getTriangles(face, v);
-                for (var k = 0; k < triangles.length; k++) {
-                    //triangle[k] = "1/1"
-                    //Split the data for getting position and uv
-                    var point = triangles[k].split("/"); // ["1", "1"]
-                    //Set position indice
-                    var indicePositionFromObj = parseInt(point[0]) - 1;
-                    //Set uv indice
-                    var indiceUvsFromObj = parseInt(point[1]) - 1;
-                    setData(indicePositionFromObj, indiceUvsFromObj, 0, //Default value for normals
-                    positions[indicePositionFromObj], //Get the values for each element
-                    uvs[indiceUvsFromObj], BABYLON.Vector3.Up() //Default value for normals
-                    );
-                }
-                //Reset variable for the next line
-                triangles = [];
-            };
-            /**
-             * Create triangles and push the data for each polygon for the pattern 3
-             * In this pattern we get vertice positions, uvs and normals
-             * @param face
-             * @param v
-             */
-            var setDataForCurrentFaceWithPattern3 = function (face, v) {
-                //Get the indices of triangles for each polygon
-                getTriangles(face, v);
-                for (var k = 0; k < triangles.length; k++) {
-                    //triangle[k] = "1/1/1"
-                    //Split the data for getting position, uv, and normals
-                    var point = triangles[k].split("/"); // ["1", "1", "1"]
-                    // Set position indice
-                    var indicePositionFromObj = parseInt(point[0]) - 1;
-                    // Set uv indice
-                    var indiceUvsFromObj = parseInt(point[1]) - 1;
-                    // Set normal indice
-                    var indiceNormalFromObj = parseInt(point[2]) - 1;
-                    setData(indicePositionFromObj, indiceUvsFromObj, indiceNormalFromObj, positions[indicePositionFromObj], uvs[indiceUvsFromObj], normals[indiceNormalFromObj] //Set the vector for each component
-                    );
-                }
-                //Reset variable for the next line
-                triangles = [];
-            };
-            /**
-             * Create triangles and push the data for each polygon for the pattern 4
-             * In this pattern we get vertice positions and normals
-             * @param face
-             * @param v
-             */
-            var setDataForCurrentFaceWithPattern4 = function (face, v) {
-                getTriangles(face, v);
-                for (var k = 0; k < triangles.length; k++) {
-                    //triangle[k] = "1//1"
-                    //Split the data for getting position and normals
-                    var point = triangles[k].split("//"); // ["1", "1"]
-                    // We check indices, and normals
-                    var indicePositionFromObj = parseInt(point[0]) - 1;
-                    var indiceNormalFromObj = parseInt(point[1]) - 1;
-                    setData(indicePositionFromObj, 1, //Default value for uv
-                    indiceNormalFromObj, positions[indicePositionFromObj], //Get each vector of data
-                    BABYLON.Vector2.Zero(), normals[indiceNormalFromObj]);
-                }
-                //Reset variable for the next line
-                triangles = [];
-            };
-            var addPreviousObjMesh = function () {
-                //Check if it is not the first mesh. Otherwise we don't have data.
-                if (meshesFromObj.length > 0) {
-                    //Get the previous mesh for applying the data about the faces
-                    //=> in obj file, faces definition append after the name of the mesh
-                    handledMesh = meshesFromObj[meshesFromObj.length - 1];
-                    //Set the data into Array for the mesh
-                    unwrapData();
-                    // Reverse tab. Otherwise face are displayed in the wrong sens
-                    indicesForBabylon.reverse();
-                    //Set the information for the mesh
-                    //Slice the array to avoid rewriting because of the fact this is the same var which be rewrited
-                    handledMesh.indices = indicesForBabylon.slice();
-                    handledMesh.positions = unwrappedPositionsForBabylon.slice();
-                    handledMesh.normals = unwrappedNormalsForBabylon.slice();
-                    handledMesh.uvs = unwrappedUVForBabylon.slice();
-                    //Reset the array for the next mesh
-                    indicesForBabylon = [];
-                    unwrappedPositionsForBabylon = [];
-                    unwrappedNormalsForBabylon = [];
-                    unwrappedUVForBabylon = [];
-                }
-            };
-            //Main function
-            //Split the file into lines
-            var lines = data.split('\n');
-            //Look at each line
-            for (var i = 0; i < lines.length; i++) {
-                var line = lines[i].trim();
-                var result;
-                //Comment or newLine
-                if (line.length === 0 || line.charAt(0) === '#') {
-                    continue;
-                    //Get information about one position possible for the vertices
-                }
-                else if ((result = this.vertexPattern.exec(line)) !== null) {
-                    //Create a Vector3 with the position x, y, z
-                    //Value of result:
-                    // ["v 1.0 2.0 3.0", "1.0", "2.0", "3.0"]
-                    //Add the Vector in the list of positions
-                    positions.push(new BABYLON.Vector3(parseFloat(result[1]), parseFloat(result[2]), parseFloat(result[3])));
-                }
-                else if ((result = this.normalPattern.exec(line)) !== null) {
-                    //Create a Vector3 with the normals x, y, z
-                    //Value of result
-                    // ["vn 1.0 2.0 3.0", "1.0", "2.0", "3.0"]
-                    //Add the Vector in the list of normals
-                    normals.push(new BABYLON.Vector3(parseFloat(result[1]), parseFloat(result[2]), parseFloat(result[3])));
-                }
-                else if ((result = this.uvPattern.exec(line)) !== null) {
-                    //Create a Vector2 with the normals u, v
-                    //Value of result
-                    // ["vt 0.1 0.2 0.3", "0.1", "0.2"]
-                    //Add the Vector in the list of uvs
-                    uvs.push(new BABYLON.Vector2(parseFloat(result[1]), parseFloat(result[2])));
-                    //Identify patterns of faces
-                    //Face could be defined in different type of pattern
-                }
-                else if ((result = this.facePattern3.exec(line)) !== null) {
-                    //Value of result:
-                    //["f 1/1/1 2/2/2 3/3/3", "1/1/1 2/2/2 3/3/3"...]
-                    //Set the data for this face
-                    setDataForCurrentFaceWithPattern3(result[1].trim().split(" "), // ["1/1/1", "2/2/2", "3/3/3"]
-                    1);
-                }
-                else if ((result = this.facePattern4.exec(line)) !== null) {
-                    //Value of result:
-                    //["f 1//1 2//2 3//3", "1//1 2//2 3//3"...]
-                    //Set the data for this face
-                    setDataForCurrentFaceWithPattern4(result[1].trim().split(" "), // ["1//1", "2//2", "3//3"]
-                    1);
-                }
-                else if ((result = this.facePattern2.exec(line)) !== null) {
-                    //Value of result:
-                    //["f 1/1 2/2 3/3", "1/1 2/2 3/3"...]
-                    //Set the data for this face
-                    setDataForCurrentFaceWithPattern2(result[1].trim().split(" "), // ["1/1", "2/2", "3/3"]
-                    1);
-                }
-                else if ((result = this.facePattern1.exec(line)) !== null) {
-                    //Value of result
-                    //["f 1 2 3", "1 2 3"...]
-                    //Set the data for this face
-                    setDataForCurrentFaceWithPattern1(result[1].trim().split(" "), // ["1", "2", "3"]
-                    1);
-                    //Define a mesh or an object
-                    //Each time this keyword is analysed, create a new Object with all data for creating a babylonMesh
-                }
-                else if (this.group.test(line) || this.obj.test(line)) {
-                    //Create a new mesh corresponding to the name of the group.
-                    //Definition of the mesh
-                    var objMesh = 
-                    //Set the name of the current obj mesh
-                    {
-                        name: line.substring(2).trim(),
-                        indices: undefined,
-                        positions: undefined,
-                        normals: undefined,
-                        uvs: undefined,
-                        materialName: ""
-                    };
-                    addPreviousObjMesh();
-                    //Push the last mesh created with only the name
-                    meshesFromObj.push(objMesh);
-                    //Set this variable to indicate that now meshesFromObj has objects defined inside
-                    hasMeshes = true;
-                    isFirstMaterial = true;
-                    increment = 1;
-                    //Keyword for applying a material
-                }
-                else if (this.usemtl.test(line)) {
-                    //Get the name of the material
-                    materialNameFromObj = line.substring(7).trim();
-                    //If this new material is in the same mesh
-                    if (!isFirstMaterial) {
-                        //Set the data for the previous mesh
-                        addPreviousObjMesh();
-                        //Create a new mesh
-                        var objMesh = 
-                        //Set the name of the current obj mesh
-                        {
-                            name: objMeshName + "_mm" + increment.toString(),
-                            indices: undefined,
-                            positions: undefined,
-                            normals: undefined,
-                            uvs: undefined,
-                            materialName: materialNameFromObj
-                        };
-                        increment++;
-                        //If meshes are already defined
-                        meshesFromObj.push(objMesh);
-                    }
-                    //Set the material name if the previous line define a mesh
-                    if (hasMeshes && isFirstMaterial) {
-                        //Set the material name to the previous mesh (1 material per mesh)
-                        meshesFromObj[meshesFromObj.length - 1].materialName = materialNameFromObj;
-                        isFirstMaterial = false;
-                    }
-                    //Keyword for loading the mtl file
-                }
-                else if (this.mtllib.test(line)) {
-                    //Get the name of mtl file
-                    fileToLoad = line.substring(7).trim();
-                    //Apply smoothing
-                }
-                else if (this.smooth.test(line)) {
-                    // smooth shading => apply smoothing
-                    //Toda  y I don't know it work with babylon and with obj.
-                    //With the obj file  an integer is set
-                }
-                else {
-                    //If there is another possibility
-                    console.log("Unhandled expression at line : " + line);
-                }
-            }
-            //At the end of the file, add the last mesh into the meshesFromObj array
-            if (hasMeshes) {
-                //Set the data for the last mesh
-                handledMesh = meshesFromObj[meshesFromObj.length - 1];
-                //Reverse indices for displaying faces in the good sens
-                indicesForBabylon.reverse();
-                //Get the good array
-                unwrapData();
-                //Set array
-                handledMesh.indices = indicesForBabylon;
-                handledMesh.positions = unwrappedPositionsForBabylon;
-                handledMesh.normals = unwrappedNormalsForBabylon;
-                handledMesh.uvs = unwrappedUVForBabylon;
-            }
-            //If any o or g keyword found, create a mesj with a random id
-            if (!hasMeshes) {
-                // reverse tab of indices
-                indicesForBabylon.reverse();
-                //Get positions normals uvs
-                unwrapData();
-                //Set data for one mesh
-                meshesFromObj.push({
-                    name: BABYLON.Geometry.RandomId(),
-                    indices: indicesForBabylon,
-                    positions: unwrappedPositionsForBabylon,
-                    normals: unwrappedNormalsForBabylon,
-                    uvs: unwrappedUVForBabylon,
-                    materialName: materialNameFromObj
-                });
-            }
-            //Create a BABYLON.Mesh list
-            var babylonMeshesArray = []; //The mesh for babylon
-            var materialToUse = new Array();
-            //Set data for each mesh
-            for (var j = 0; j < meshesFromObj.length; j++) {
-                //check meshesNames (stlFileLoader)
-                if (meshesNames && meshesFromObj[j].name) {
-                    if (meshesNames instanceof Array) {
-                        if (meshesNames.indexOf(meshesFromObj[j].name) == -1) {
-                            continue;
-                        }
-                    }
-                    else {
-                        if (meshesFromObj[j].name !== meshesNames) {
-                            continue;
-                        }
-                    }
-                }
-                //Get the current mesh
-                //Set the data with VertexBuffer for each mesh
-                handledMesh = meshesFromObj[j];
-                //Create a BABYLON.Mesh with the name of the obj mesh
-                var babylonMesh = new BABYLON.Mesh(meshesFromObj[j].name, scene);
-                //Push the name of the material to an array
-                //This is indispensable for the importMesh function
-                materialToUse.push(meshesFromObj[j].materialName);
-                var vertexData = new BABYLON.VertexData(); //The container for the values
-                //Set the data for the babylonMesh
-                vertexData.positions = handledMesh.positions;
-                vertexData.normals = handledMesh.normals;
-                vertexData.uvs = handledMesh.uvs;
-                vertexData.indices = handledMesh.indices;
-                //Set the data from the VertexBuffer to the current BABYLON.Mesh
-                vertexData.applyToMesh(babylonMesh);
-                if (OBJFileLoader.INVERT_Y) {
-                    babylonMesh.scaling.y *= -1;
-                }
-                //Push the mesh into an array
-                babylonMeshesArray.push(babylonMesh);
-            }
-            //load the materials
-            //Check if we have a file to load
-            if (fileToLoad !== "") {
-                //Load the file synchronously
-                this._loadMTL(fileToLoad, rootUrl, function (dataLoaded) {
-                    //Create materials thanks MTLLoader function
-                    materialsFromMTLFile.parseMTL(scene, dataLoaded, rootUrl);
-                    //Look at each material loaded in the mtl file
-                    for (var n = 0; n < materialsFromMTLFile.materials.length; n++) {
-                        //Three variables to get all meshes with the same material
-                        var startIndex = 0;
-                        var _indices = [];
-                        var _index;
-                        //The material from MTL file is used in the meshes loaded
-                        //Push the indice in an array
-                        //Check if the material is not used for another mesh
-                        while ((_index = materialToUse.indexOf(materialsFromMTLFile.materials[n].name, startIndex)) > -1) {
-                            _indices.push(_index);
-                            startIndex = _index + 1;
-                        }
-                        //If the material is not used dispose it
-                        if (_index == -1 && _indices.length == 0) {
-                            //If the material is not needed, remove it
-                            materialsFromMTLFile.materials[n].dispose();
-                        }
-                        else {
-                            for (var o = 0; o < _indices.length; o++) {
-                                //Apply the material to the BABYLON.Mesh for each mesh with the material
-                                babylonMeshesArray[_indices[o]].material = materialsFromMTLFile.materials[n];
-                            }
-                        }
-                    }
-                });
-            }
-            //Return an array with all BABYLON.Mesh
-            return babylonMeshesArray;
-        };
-        OBJFileLoader.OPTIMIZE_WITH_UV = false;
-        OBJFileLoader.INVERT_Y = false;
-        return OBJFileLoader;
-    }());
-    BABYLON.OBJFileLoader = OBJFileLoader;
-    if (BABYLON.SceneLoader) {
-        //Add this loader into the register plugin
-        BABYLON.SceneLoader.RegisterPlugin(new OBJFileLoader());
-    }
-})(BABYLON || (BABYLON = {}));
-
-//# sourceMappingURL=babylon.objFileLoader.js.map

dist/preview release/loaders/babylon.stlFileLoader.d.ts

@@ -1,17 +0,0 @@
-
-declare module BABYLON {
-    class STLFileLoader implements ISceneLoaderPlugin {
-        solidPattern: RegExp;
-        facetsPattern: RegExp;
-        normalPattern: RegExp;
-        vertexPattern: RegExp;
-        name: string;
-        extensions: ISceneLoaderPluginExtensions;
-        importMesh(meshesNames: any, scene: Scene, data: any, rootUrl: string, meshes: Nullable<AbstractMesh[]>, particleSystems: Nullable<ParticleSystem[]>, skeletons: Nullable<Skeleton[]>): boolean;
-        load(scene: Scene, data: any, rootUrl: string): boolean;
-        loadAssetContainer(scene: Scene, data: string, rootUrl: string, onError?: (message: string, exception?: any) => void): AssetContainer;
-        private isBinary(data);
-        private parseBinary(mesh, data);
-        private parseASCII(mesh, solidData);
-    }
-}

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

@@ -1,170 +0,0 @@
-/// <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 (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;
-            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

dist/preview release/loaders/package.json

@@ -1,38 +0,0 @@
-{
-    "author": {
-        "name": "David CATUHE"
-    },
-    "name": "babylonjs-loaders",
-    "description": "The Babylon.js file loaders library is an extension you can use to load different 3D file types into a Babylon scene.",
-    "version": "3.2.0",
-    "repository": {
-        "type": "git",
-        "url": "https://github.com/BabylonJS/Babylon.js.git"
-    },
-    "main": "babylonjs.loaders.min.js",
-    "files": [
-        "babylonjs.loaders.js",
-        "babylonjs.loaders.min.js",
-        "babylonjs.loaders.module.d.ts",
-        "readme.md",
-        "package.json"
-    ],
-    "typings": "babylonjs.loaders.module.d.ts",
-    "keywords": [
-        "3D",
-        "javascript",
-        "html5",
-        "webgl",
-        "loaders"
-    ],
-    "license": "Apache-2.0",
-    "dependencies": {
-        "babylonjs-gltf2interface": "3.2.0"
-    },
-    "peerDependencies": {
-        "babylonjs": ">=3.2.0-alpha"
-    },
-    "engines": {
-        "node": "*"
-    }
-}

dist/preview release/loaders/readme.md

@@ -1,44 +0,0 @@
-Babylon.js Loaders module
-=====================
-
-For usage documentation please visit http://doc.babylonjs.com/extensions and choose "loaders".
-
-# Installation instructions
-
-## CDN
-
-Compiled js files (minified and source) are offered on our public CDN here:
-
-* https://preview.babylonjs.com/loaders/babylonjs.loaders.js
-* https://preview.babylonjs.com/loaders/babylonjs.loaders.min.js
-
-## NPM
-
-To install using npm :
-
-```
-npm install --save babylonjs babylonjs-loaders
-```
-
-If using TypeScript, the typing needs to be added to tsconfig.json:
-
-```
-    ....
-    "types": [
-        "babylonjs",
-        "babylonjs-loaders",
-        ""
-    ],
-    ....
-```
-
-Afterwards it can be imported to the project using:
-
-```
-import * as BABYLON from 'babylonjs';
-import 'babylonjs-loaders';
-```
-
-This will extend Babylon's namespace with the loaders available.
-
-Using webpack to package your project will use the minified js file.

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

@@ -1,280 +0,0 @@
-
-declare namespace BABYLON {
-    /**
-     * Background material
-     */
-    class BackgroundMaterial extends BABYLON.PushMaterial {
-        /**
-         * Key light Color (multiply against the R channel of the environement texture)
-         */
-        protected _primaryColor: Color3;
-        primaryColor: Color3;
-        /**
-         * Key light Level (allowing HDR output of the background)
-         */
-        protected _primaryLevel: float;
-        primaryLevel: float;
-        /**
-         * Secondary light Color (multiply against the G channel of the environement texture)
-         */
-        protected _secondaryColor: Color3;
-        secondaryColor: Color3;
-        /**
-         * Secondary light Level (allowing HDR output of the background)
-         */
-        protected _secondaryLevel: float;
-        secondaryLevel: float;
-        /**
-         * Tertiary light Color (multiply against the B channel of the environement texture)
-         */
-        protected _tertiaryColor: Color3;
-        tertiaryColor: Color3;
-        /**
-         * Tertiary light Level (allowing HDR output of the background)
-         */
-        protected _tertiaryLevel: float;
-        tertiaryLevel: float;
-        /**
-         * Reflection Texture used in the material.
-         * Should be author in a specific way for the best result (refer to the documentation).
-         */
-        protected _reflectionTexture: Nullable<BaseTexture>;
-        reflectionTexture: Nullable<BaseTexture>;
-        /**
-         * Reflection Texture level of blur.
-         *
-         * Can be use to reuse an existing HDR Texture and target a specific LOD to prevent authoring the
-         * texture twice.
-         */
-        protected _reflectionBlur: float;
-        reflectionBlur: float;
-        /**
-         * Diffuse Texture used in the material.
-         * Should be author in a specific way for the best result (refer to the documentation).
-         */
-        protected _diffuseTexture: Nullable<BaseTexture>;
-        diffuseTexture: Nullable<BaseTexture>;
-        /**
-         * Specify the list of lights casting shadow on the material.
-         * All scene shadow lights will be included if null.
-         */
-        protected _shadowLights: Nullable<IShadowLight[]>;
-        shadowLights: Nullable<IShadowLight[]>;
-        /**
-         * For the lights having a blurred shadow generator, this can add a second blur pass in order to reach
-         * soft lighting on the background.
-         */
-        protected _shadowBlurScale: int;
-        shadowBlurScale: int;
-        /**
-         * Helps adjusting the shadow to a softer level if required.
-         * 0 means black shadows and 1 means no shadows.
-         */
-        protected _shadowLevel: float;
-        shadowLevel: float;
-        /**
-         * In case of opacity Fresnel or reflection falloff, this is use as a scene center.
-         * It is usually zero but might be interesting to modify according to your setup.
-         */
-        protected _sceneCenter: Vector3;
-        sceneCenter: Vector3;
-        /**
-         * This helps specifying that the material is falling off to the sky box at grazing angle.
-         * This helps ensuring a nice transition when the camera goes under the ground.
-         */
-        protected _opacityFresnel: boolean;
-        opacityFresnel: boolean;
-        /**
-         * This helps specifying that the material is falling off from diffuse to the reflection texture at grazing angle.
-         * This helps adding a mirror texture on the ground.
-         */
-        protected _reflectionFresnel: boolean;
-        reflectionFresnel: boolean;
-        /**
-         * This helps specifying the falloff radius off the reflection texture from the sceneCenter.
-         * This helps adding a nice falloff effect to the reflection if used as a mirror for instance.
-         */
-        protected _reflectionFalloffDistance: number;
-        reflectionFalloffDistance: number;
-        /**
-         * This specifies the weight of the reflection against the background in case of reflection Fresnel.
-         */
-        protected _reflectionAmount: number;
-        reflectionAmount: number;
-        /**
-         * This specifies the weight of the reflection at grazing angle.
-         */
-        protected _reflectionReflectance0: number;
-        reflectionReflectance0: number;
-        /**
-         * This specifies the weight of the reflection at a perpendicular point of view.
-         */
-        protected _reflectionReflectance90: number;
-        reflectionReflectance90: number;
-        /**
-         * Helps to directly use the maps channels instead of their level.
-         */
-        protected _useRGBColor: boolean;
-        useRGBColor: boolean;
-        /**
-         * Number of Simultaneous lights allowed on the material.
-         */
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: int;
-        /**
-         * Default configuration related to image processing available in the Background Material.
-         */
-        protected _imageProcessingConfiguration: ImageProcessingConfiguration;
-        /**
-         * Keep track of the image processing observer to allow dispose and replace.
-         */
-        private _imageProcessingObserver;
-        /**
-         * Attaches a new image processing configuration to the PBR Material.
-         * @param configuration (if null the scene configuration will be use)
-         */
-        protected _attachImageProcessingConfiguration(configuration: Nullable<ImageProcessingConfiguration>): void;
-        /**
-         * Gets the image processing configuration used either in this material.
-         */
-        /**
-         * Sets the Default image processing configuration used either in the this material.
-         *
-         * If sets to null, the scene one is in use.
-         */
-        imageProcessingConfiguration: Nullable<ImageProcessingConfiguration>;
-        /**
-         * Gets wether the color curves effect is enabled.
-         */
-        /**
-         * Sets wether the color curves effect is enabled.
-         */
-        cameraColorCurvesEnabled: boolean;
-        /**
-         * Gets wether the color grading effect is enabled.
-         */
-        /**
-         * Gets wether the color grading effect is enabled.
-         */
-        cameraColorGradingEnabled: boolean;
-        /**
-         * Gets wether tonemapping is enabled or not.
-         */
-        /**
-         * Sets wether tonemapping is enabled or not
-         */
-        cameraToneMappingEnabled: boolean;
-        /**
-         * The camera exposure used on this material.
-         * This property is here and not in the camera to allow controlling exposure without full screen post process.
-         * This corresponds to a photographic exposure.
-         */
-        /**
-         * The camera exposure used on this material.
-         * This property is here and not in the camera to allow controlling exposure without full screen post process.
-         * This corresponds to a photographic exposure.
-         */
-        cameraExposure: float;
-        /**
-         * Gets The camera contrast used on this material.
-         */
-        /**
-         * Sets The camera contrast used on this material.
-         */
-        cameraContrast: float;
-        /**
-         * Gets the Color Grading 2D Lookup Texture.
-         */
-        /**
-         * Sets the Color Grading 2D Lookup Texture.
-         */
-        cameraColorGradingTexture: Nullable<BaseTexture>;
-        /**
-         * The color grading curves provide additional color adjustmnent that is applied after any color grading transform (3D LUT).
-         * They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
-         * These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image;
-         * corresponding to low luminance, medium luminance, and high luminance areas respectively.
-         */
-        /**
-         * The color grading curves provide additional color adjustmnent that is applied after any color grading transform (3D LUT).
-         * They allow basic adjustment of saturation and small exposure adjustments, along with color filter tinting to provide white balance adjustment or more stylistic effects.
-         * These are similar to controls found in many professional imaging or colorist software. The global controls are applied to the entire image. For advanced tuning, extra controls are provided to adjust the shadow, midtone and highlight areas of the image;
-         * corresponding to low luminance, medium luminance, and high luminance areas respectively.
-         */
-        cameraColorCurves: Nullable<ColorCurves>;
-        private _renderTargets;
-        private _reflectionControls;
-        /**
-         * constructor
-         * @param name The name of the material
-         * @param scene The scene to add the material to
-         */
-        constructor(name: string, scene: BABYLON.Scene);
-        /**
-         * The entire material has been created in order to prevent overdraw.
-         * @returns false
-         */
-        needAlphaTesting(): boolean;
-        /**
-         * The entire material has been created in order to prevent overdraw.
-         * @returns true if blending is enable
-         */
-        needAlphaBlending(): boolean;
-        /**
-         * Checks wether the material is ready to be rendered for a given mesh.
-         * @param mesh The mesh to render
-         * @param subMesh The submesh to check against
-         * @param useInstances Specify wether or not the material is used with instances
-         */
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        /**
-         * Build the uniform buffer used in the material.
-         */
-        buildUniformLayout(): void;
-        /**
-         * Unbind the material.
-         */
-        unbind(): void;
-        /**
-         * Bind only the world matrix to the material.
-         * @param world The world matrix to bind.
-         */
-        bindOnlyWorldMatrix(world: Matrix): void;
-        /**
-         * Bind the material for a dedicated submeh (every used meshes will be considered opaque).
-         * @param world The world matrix to bind.
-         * @param subMesh The submesh to bind for.
-         */
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        /**
-         * Dispose the material.
-         * @forceDisposeEffect Force disposal of the associated effect.
-         * @forceDisposeTextures Force disposal of the associated textures.
-         */
-        dispose(forceDisposeEffect?: boolean, forceDisposeTextures?: boolean): void;
-        /**
-         * Clones the material.
-         * @name The cloned name.
-         * @returns The cloned material.
-         */
-        clone(name: string): BackgroundMaterial;
-        /**
-         * Serializes the current material to its JSON representation.
-         * @returns The JSON representation.
-         */
-        serialize(): any;
-        /**
-         * Gets the class name of the material
-         * @returns "BackgroundMaterial"
-         */
-        getClassName(): string;
-        /**
-         * Parse a JSON input to create back a background material.
-         * @param source
-         * @param scene
-         * @param rootUrl
-         * @returns the instantiated BackgroundMaterial.
-         */
-        static Parse(source: any, scene: Scene, rootUrl: string): BackgroundMaterial;
-    }
-}

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

@@ -1,29 +0,0 @@
-
-declare module BABYLON {
-    class CellMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        _computeHighLevel: boolean;
-        computeHighLevel: boolean;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        getClassName(): string;
-        clone(name: string): CellMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): CellMaterial;
-    }
-}

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

@@ -1,50 +0,0 @@
-
-declare module BABYLON {
-    class CustomShaderStructure {
-        FragmentStore: string;
-        VertexStore: string;
-        constructor();
-    }
-    class ShaderSpecialParts {
-        constructor();
-        Fragment_Begin: string;
-        Fragment_Definitions: string;
-        Fragment_MainBegin: string;
-        Fragment_Custom_Diffuse: string;
-        Fragment_Custom_Alpha: string;
-        Fragment_Before_FragColor: string;
-        Vertex_Begin: string;
-        Vertex_Definitions: string;
-        Vertex_MainBegin: string;
-        Vertex_Before_PositionUpdated: string;
-        Vertex_Before_NormalUpdated: string;
-    }
-    class CustomMaterial extends StandardMaterial {
-        static ShaderIndexer: number;
-        CustomParts: ShaderSpecialParts;
-        _isCreatedShader: boolean;
-        _createdShaderName: string;
-        _customUniform: string[];
-        _newUniforms: string[];
-        _newUniformInstances: any[];
-        _newSamplerInstances: Texture[];
-        FragmentShader: string;
-        VertexShader: string;
-        AttachAfterBind(mesh: Mesh, effect: Effect): void;
-        ReviewUniform(name: string, arr: string[]): string[];
-        Builder(shaderName: string, uniforms: string[], uniformBuffers: string[], samplers: string[], defines: StandardMaterialDefines): string;
-        constructor(name: string, scene: Scene);
-        AddUniform(name: string, kind: string, param: any): CustomMaterial;
-        Fragment_Begin(shaderPart: string): CustomMaterial;
-        Fragment_Definitions(shaderPart: string): CustomMaterial;
-        Fragment_MainBegin(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Diffuse(shaderPart: string): CustomMaterial;
-        Fragment_Custom_Alpha(shaderPart: string): CustomMaterial;
-        Fragment_Before_FragColor(shaderPart: string): CustomMaterial;
-        Vertex_Begin(shaderPart: string): CustomMaterial;
-        Vertex_Definitions(shaderPart: string): CustomMaterial;
-        Vertex_MainBegin(shaderPart: string): CustomMaterial;
-        Vertex_Before_PositionUpdated(shaderPart: string): CustomMaterial;
-        Vertex_Before_NormalUpdated(shaderPart: string): CustomMaterial;
-    }
-}

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

@@ -1,189 +0,0 @@
-/// <reference path="../../../dist/preview release/babylon.d.ts"/>
-var __extends = (this && this.__extends) || (function () {
-    var extendStatics = Object.setPrototypeOf ||
-        ({ __proto__: [] } instanceof Array && function (d, b) { d.__proto__ = b; }) ||
-        function (d, b) { for (var p in b) if (b.hasOwnProperty(p)) d[p] = b[p]; };
-    return function (d, b) {
-        extendStatics(d, b);
-        function __() { this.constructor = d; }
-        d.prototype = b === null ? Object.create(b) : (__.prototype = b.prototype, new __());
-    };
-})();
-var BABYLON;
-(function (BABYLON) {
-    var CustomShaderStructure = /** @class */ (function () {
-        function CustomShaderStructure() {
-        }
-        return CustomShaderStructure;
-    }());
-    BABYLON.CustomShaderStructure = CustomShaderStructure;
-    var ShaderSpecialParts = /** @class */ (function () {
-        function ShaderSpecialParts() {
-        }
-        return ShaderSpecialParts;
-    }());
-    BABYLON.ShaderSpecialParts = ShaderSpecialParts;
-    var CustomMaterial = /** @class */ (function (_super) {
-        __extends(CustomMaterial, _super);
-        function CustomMaterial(name, scene) {
-            var _this = _super.call(this, name, scene) || this;
-            _this.CustomParts = new ShaderSpecialParts();
-            _this.customShaderNameResolve = _this.Builder;
-            _this.FragmentShader = BABYLON.Effect.ShadersStore["defaultPixelShader"];
-            _this.VertexShader = BABYLON.Effect.ShadersStore["defaultVertexShader"];
-            return _this;
-        }
-        CustomMaterial.prototype.AttachAfterBind = function (mesh, effect) {
-            for (var el in this._newUniformInstances) {
-                var ea = el.toString().split('-');
-                if (ea[0] == 'vec2') {
-                    effect.setVector2(ea[1], this._newUniformInstances[el]);
-                }
-                else if (ea[0] == 'vec3') {
-                    effect.setVector3(ea[1], this._newUniformInstances[el]);
-                }
-                else if (ea[0] == 'vec4') {
-                    effect.setVector4(ea[1], this._newUniformInstances[el]);
-                }
-                else if (ea[0] == 'mat4') {
-                    effect.setMatrix(ea[1], this._newUniformInstances[el]);
-                }
-                else if (ea[0] == 'float') {
-                    effect.setFloat(ea[1], this._newUniformInstances[el]);
-                }
-            }
-            for (var el in this._newSamplerInstances) {
-                var ea = el.toString().split('-');
-                if (ea[0] == 'sampler2D' && this._newSamplerInstances[el].isReady && this._newSamplerInstances[el].isReady()) {
-                    effect.setTexture(ea[1], this._newSamplerInstances[el]);
-                }
-            }
-        };
-        CustomMaterial.prototype.ReviewUniform = function (name, arr) {
-            if (name == "uniform") {
-                for (var ind in this._newUniforms) {
-                    if (this._customUniform[ind].indexOf('sampler') == -1) {
-                        arr.push(this._newUniforms[ind]);
-                    }
-                }
-            }
-            if (name == "sampler") {
-                for (var ind in this._newUniforms) {
-                    if (this._customUniform[ind].indexOf('sampler') != -1) {
-                        arr.push(this._newUniforms[ind]);
-                    }
-                }
-            }
-            return arr;
-        };
-        CustomMaterial.prototype.Builder = function (shaderName, uniforms, uniformBuffers, samplers, defines) {
-            var _this = this;
-            if (this._isCreatedShader) {
-                return this._createdShaderName;
-            }
-            this._isCreatedShader = false;
-            CustomMaterial.ShaderIndexer++;
-            var name = "custom_" + CustomMaterial.ShaderIndexer;
-            this.ReviewUniform("uniform", uniforms);
-            this.ReviewUniform("sampler", samplers);
-            var fn_afterBind = this._afterBind.bind(this);
-            this._afterBind = function (m, e) {
-                if (!e) {
-                    return;
-                }
-                _this.AttachAfterBind(m, e);
-                try {
-                    fn_afterBind(m, e);
-                }
-                catch (e) { }
-            };
-            BABYLON.Effect.ShadersStore[name + "VertexShader"] = this.VertexShader
-                .replace('#define CUSTOM_VERTEX_BEGIN', (this.CustomParts.Vertex_Begin ? this.CustomParts.Vertex_Begin : ""))
-                .replace('#define CUSTOM_VERTEX_DEFINITIONS', (this._customUniform ? this._customUniform.join("\n") : "") + (this.CustomParts.Vertex_Definitions ? this.CustomParts.Vertex_Definitions : ""))
-                .replace('#define CUSTOM_VERTEX_MAIN_BEGIN', (this.CustomParts.Vertex_MainBegin ? this.CustomParts.Vertex_MainBegin : ""))
-                .replace('#define CUSTOM_VERTEX_UPDATE_POSITION', (this.CustomParts.Vertex_Before_PositionUpdated ? this.CustomParts.Vertex_Before_PositionUpdated : ""))
-                .replace('#define CUSTOM_VERTEX_UPDATE_NORMAL', (this.CustomParts.Vertex_Before_NormalUpdated ? this.CustomParts.Vertex_Before_NormalUpdated : ""));
-            // #define CUSTOM_VERTEX_MAIN_END
-            BABYLON.Effect.ShadersStore[name + "PixelShader"] = this.FragmentShader
-                .replace('#define CUSTOM_FRAGMENT_BEGIN', (this.CustomParts.Fragment_Begin ? this.CustomParts.Fragment_Begin : ""))
-                .replace('#define CUSTOM_FRAGMENT_MAIN_BEGIN', (this.CustomParts.Fragment_MainBegin ? this.CustomParts.Fragment_MainBegin : ""))
-                .replace('#define CUSTOM_FRAGMENT_DEFINITIONS', (this._customUniform ? this._customUniform.join("\n") : "") + (this.CustomParts.Fragment_Definitions ? this.CustomParts.Fragment_Definitions : ""))
-                .replace('#define CUSTOM_FRAGMENT_UPDATE_DIFFUSE', (this.CustomParts.Fragment_Custom_Diffuse ? this.CustomParts.Fragment_Custom_Diffuse : ""))
-                .replace('#define CUSTOM_FRAGMENT_UPDATE_ALPHA', (this.CustomParts.Fragment_Custom_Alpha ? this.CustomParts.Fragment_Custom_Alpha : ""))
-                .replace('#define CUSTOM_FRAGMENT_BEFORE_FRAGCOLOR', (this.CustomParts.Fragment_Before_FragColor ? this.CustomParts.Fragment_Before_FragColor : ""));
-            // #define CUSTOM_FRAGMENT_BEFORE_LIGHTS
-            // #define CUSTOM_FRAGMENT_BEFORE_FOG
-            this._isCreatedShader = true;
-            this._createdShaderName = name;
-            return name;
-        };
-        CustomMaterial.prototype.AddUniform = function (name, kind, param) {
-            if (!this._customUniform) {
-                this._customUniform = new Array();
-                this._newUniforms = new Array();
-                this._newSamplerInstances = new Array();
-                this._newUniformInstances = new Array();
-            }
-            if (param) {
-                if (kind.indexOf("sampler") == -1) {
-                    this._newUniformInstances[kind + "-" + name] = param;
-                }
-                else {
-                    this._newUniformInstances[kind + "-" + name] = param;
-                }
-            }
-            this._customUniform.push("uniform " + kind + " " + name + ";");
-            this._newUniforms.push(name);
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Begin = function (shaderPart) {
-            this.CustomParts.Fragment_Begin = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Definitions = function (shaderPart) {
-            this.CustomParts.Fragment_Definitions = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_MainBegin = function (shaderPart) {
-            this.CustomParts.Fragment_MainBegin = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Custom_Diffuse = function (shaderPart) {
-            this.CustomParts.Fragment_Custom_Diffuse = shaderPart.replace("result", "diffuseColor");
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Custom_Alpha = function (shaderPart) {
-            this.CustomParts.Fragment_Custom_Alpha = shaderPart.replace("result", "alpha");
-            return this;
-        };
-        CustomMaterial.prototype.Fragment_Before_FragColor = function (shaderPart) {
-            this.CustomParts.Fragment_Before_FragColor = shaderPart.replace("result", "color");
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_Begin = function (shaderPart) {
-            this.CustomParts.Vertex_Begin = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_Definitions = function (shaderPart) {
-            this.CustomParts.Vertex_Definitions = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_MainBegin = function (shaderPart) {
-            this.CustomParts.Vertex_MainBegin = shaderPart;
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_Before_PositionUpdated = function (shaderPart) {
-            this.CustomParts.Vertex_Before_PositionUpdated = shaderPart.replace("result", "positionUpdated");
-            return this;
-        };
-        CustomMaterial.prototype.Vertex_Before_NormalUpdated = function (shaderPart) {
-            this.CustomParts.Vertex_Before_NormalUpdated = shaderPart.replace("result", "normalUpdated");
-            return this;
-        };
-        CustomMaterial.ShaderIndexer = 1;
-        return CustomMaterial;
-    }(BABYLON.StandardMaterial));
-    BABYLON.CustomMaterial = CustomMaterial;
-})(BABYLON || (BABYLON = {}));
-
-//# sourceMappingURL=babylon.customMaterial.js.map

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

@@ -1,30 +0,0 @@
-
-declare module BABYLON {
-    class FireMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: Nullable<BaseTexture>;
-        private _distortionTexture;
-        distortionTexture: Nullable<BaseTexture>;
-        private _opacityTexture;
-        opacityTexture: Nullable<BaseTexture>;
-        diffuseColor: Color3;
-        speed: number;
-        private _scaledDiffuse;
-        private _renderId;
-        private _lastTime;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        getClassName(): string;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): FireMaterial;
-        serialize(): any;
-        static Parse(source: any, scene: Scene, rootUrl: string): FireMaterial;
-    }
-}

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

@@ -1,46 +0,0 @@
-
-declare module BABYLON {
-    class FurMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        private _heightTexture;
-        heightTexture: BaseTexture;
-        diffuseColor: Color3;
-        furLength: number;
-        furAngle: number;
-        furColor: Color3;
-        furOffset: number;
-        furSpacing: number;
-        furGravity: Vector3;
-        furSpeed: number;
-        furDensity: number;
-        furOcclusion: number;
-        furTexture: DynamicTexture;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        highLevelFur: boolean;
-        _meshes: AbstractMesh[];
-        private _renderId;
-        private _furTime;
-        constructor(name: string, scene: Scene);
-        furTime: number;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        updateFur(): void;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): FurMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): FurMaterial;
-        static GenerateTexture(name: string, scene: Scene): DynamicTexture;
-        static FurifyMesh(sourceMesh: Mesh, quality: number): Mesh[];
-    }
-}

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

@@ -1,28 +0,0 @@
-
-declare module BABYLON {
-    class GradientMaterial extends PushMaterial {
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        topColor: Color3;
-        topColorAlpha: number;
-        bottomColor: Color3;
-        bottomColorAlpha: number;
-        offset: number;
-        smoothness: number;
-        disableLighting: boolean;
-        private _scaledDiffuse;
-        private _renderId;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GradientMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): GradientMaterial;
-    }
-}

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

@@ -1,61 +0,0 @@
-
-declare module BABYLON {
-    /**
-     * The grid materials allows you to wrap any shape with a grid.
-     * Colors are customizable.
-     */
-    class GridMaterial extends BABYLON.PushMaterial {
-        /**
-         * Main color of the grid (e.g. between lines)
-         */
-        mainColor: Color3;
-        /**
-         * Color of the grid lines.
-         */
-        lineColor: Color3;
-        /**
-         * The scale of the grid compared to unit.
-         */
-        gridRatio: number;
-        /**
-         * Allows setting an offset for the grid lines.
-         */
-        gridOffset: Vector3;
-        /**
-         * The frequency of thicker lines.
-         */
-        majorUnitFrequency: number;
-        /**
-         * The visibility of minor units in the grid.
-         */
-        minorUnitVisibility: number;
-        /**
-         * The grid opacity outside of the lines.
-         */
-        opacity: number;
-        /**
-         * Determine RBG output is premultiplied by alpha value.
-         */
-        preMultiplyAlpha: boolean;
-        private _gridControl;
-        private _renderId;
-        /**
-         * constructor
-         * @param name The name given to the material in order to identify it afterwards.
-         * @param scene The scene the material is used in.
-         */
-        constructor(name: string, scene: Scene);
-        /**
-         * Returns wehter or not the grid requires alpha blending.
-         */
-        needAlphaBlending(): boolean;
-        needAlphaBlendingForMesh(mesh: AbstractMesh): boolean;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): GridMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): GridMaterial;
-    }
-}

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

@@ -1,35 +0,0 @@
-
-declare module BABYLON {
-    class LavaMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        noiseTexture: BaseTexture;
-        fogColor: Color3;
-        speed: number;
-        movingSpeed: number;
-        lowFrequencySpeed: number;
-        fogDensity: number;
-        private _lastTime;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _scaledDiffuse;
-        private _renderId;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): LavaMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): LavaMaterial;
-    }
-}

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

@@ -1,27 +0,0 @@
-
-declare module BABYLON {
-    class NormalMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): NormalMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): NormalMaterial;
-    }
-}

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

@@ -1,18 +0,0 @@
-
-declare module BABYLON {
-    class ShadowOnlyMaterial extends PushMaterial {
-        private _renderId;
-        private _activeLight;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        activeLight: IShadowLight;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        clone(name: string): ShadowOnlyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): ShadowOnlyMaterial;
-    }
-}

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

@@ -1,27 +0,0 @@
-
-declare module BABYLON {
-    class SimpleMaterial extends PushMaterial {
-        private _diffuseTexture;
-        diffuseTexture: BaseTexture;
-        diffuseColor: Color3;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): SimpleMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): SimpleMaterial;
-    }
-}

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

@@ -1,29 +0,0 @@
-
-declare module BABYLON {
-    class SkyMaterial extends PushMaterial {
-        luminance: number;
-        turbidity: number;
-        rayleigh: number;
-        mieCoefficient: number;
-        mieDirectionalG: number;
-        distance: number;
-        inclination: number;
-        azimuth: number;
-        sunPosition: Vector3;
-        useSunPosition: boolean;
-        private _cameraPosition;
-        private _renderId;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): SkyMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): SkyMaterial;
-    }
-}

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

@@ -1,41 +0,0 @@
-
-declare module BABYLON {
-    class TerrainMaterial extends PushMaterial {
-        private _mixTexture;
-        mixTexture: BaseTexture;
-        private _diffuseTexture1;
-        diffuseTexture1: Texture;
-        private _diffuseTexture2;
-        diffuseTexture2: Texture;
-        private _diffuseTexture3;
-        diffuseTexture3: Texture;
-        private _bumpTexture1;
-        bumpTexture1: Texture;
-        private _bumpTexture2;
-        bumpTexture2: Texture;
-        private _bumpTexture3;
-        bumpTexture3: Texture;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): TerrainMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): TerrainMaterial;
-    }
-}

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

@@ -1,41 +0,0 @@
-
-declare module BABYLON {
-    class TriPlanarMaterial extends PushMaterial {
-        mixTexture: BaseTexture;
-        private _diffuseTextureX;
-        diffuseTextureX: BaseTexture;
-        private _diffuseTextureY;
-        diffuseTextureY: BaseTexture;
-        private _diffuseTextureZ;
-        diffuseTextureZ: BaseTexture;
-        private _normalTextureX;
-        normalTextureX: BaseTexture;
-        private _normalTextureY;
-        normalTextureY: BaseTexture;
-        private _normalTextureZ;
-        normalTextureZ: BaseTexture;
-        tileSize: number;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        private _renderId;
-        constructor(name: string, scene: Scene);
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): TriPlanarMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): TriPlanarMaterial;
-    }
-}

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

@@ -1,106 +0,0 @@
-
-declare module BABYLON {
-    class WaterMaterial extends PushMaterial {
-        renderTargetSize: Vector2;
-        private _bumpTexture;
-        bumpTexture: BaseTexture;
-        diffuseColor: Color3;
-        specularColor: Color3;
-        specularPower: number;
-        private _disableLighting;
-        disableLighting: boolean;
-        private _maxSimultaneousLights;
-        maxSimultaneousLights: number;
-        /**
-        * @param {number}: Represents the wind force
-        */
-        windForce: number;
-        /**
-        * @param {Vector2}: The direction of the wind in the plane (X, Z)
-        */
-        windDirection: Vector2;
-        /**
-        * @param {number}: Wave height, represents the height of the waves
-        */
-        waveHeight: number;
-        /**
-        * @param {number}: Bump height, represents the bump height related to the bump map
-        */
-        bumpHeight: number;
-        /**
-         * @param {boolean}: Add a smaller moving bump to less steady waves.
-         */
-        private _bumpSuperimpose;
-        bumpSuperimpose: boolean;
-        /**
-         * @param {boolean}: Color refraction and reflection differently with .waterColor2 and .colorBlendFactor2. Non-linear (physically correct) fresnel.
-         */
-        private _fresnelSeparate;
-        fresnelSeparate: boolean;
-        /**
-         * @param {boolean}: bump Waves modify the reflection.
-         */
-        private _bumpAffectsReflection;
-        bumpAffectsReflection: boolean;
-        /**
-        * @param {number}: The water color blended with the refraction (near)
-        */
-        waterColor: Color3;
-        /**
-        * @param {number}: The blend factor related to the water color
-        */
-        colorBlendFactor: number;
-        /**
-         * @param {number}: The water color blended with the reflection (far)
-         */
-        waterColor2: Color3;
-        /**
-         * @param {number}: The blend factor related to the water color (reflection, far)
-         */
-        colorBlendFactor2: number;
-        /**
-        * @param {number}: Represents the maximum length of a wave
-        */
-        waveLength: number;
-        /**
-        * @param {number}: Defines the waves speed
-        */
-        waveSpeed: number;
-        protected _renderTargets: SmartArray<RenderTargetTexture>;
-        private _mesh;
-        private _refractionRTT;
-        private _reflectionRTT;
-        private _reflectionTransform;
-        private _lastTime;
-        private _lastDeltaTime;
-        private _renderId;
-        private _useLogarithmicDepth;
-        private _waitingRenderList;
-        /**
-        * Constructor
-        */
-        constructor(name: string, scene: Scene, renderTargetSize?: Vector2);
-        useLogarithmicDepth: boolean;
-        readonly refractionTexture: Nullable<RenderTargetTexture>;
-        readonly reflectionTexture: Nullable<RenderTargetTexture>;
-        addToRenderList(node: any): void;
-        enableRenderTargets(enable: boolean): void;
-        getRenderList(): Nullable<AbstractMesh[]>;
-        readonly renderTargetsEnabled: boolean;
-        needAlphaBlending(): boolean;
-        needAlphaTesting(): boolean;
-        getAlphaTestTexture(): Nullable<BaseTexture>;
-        isReadyForSubMesh(mesh: AbstractMesh, subMesh: SubMesh, useInstances?: boolean): boolean;
-        bindForSubMesh(world: Matrix, mesh: Mesh, subMesh: SubMesh): void;
-        private _createRenderTargets(scene, renderTargetSize);
-        getAnimatables(): IAnimatable[];
-        getActiveTextures(): BaseTexture[];
-        hasTexture(texture: BaseTexture): boolean;
-        dispose(forceDisposeEffect?: boolean): void;
-        clone(name: string): WaterMaterial;
-        serialize(): any;
-        getClassName(): string;
-        static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial;
-        static CreateDefaultMesh(name: string, scene: Scene): Mesh;
-    }
-}