Merge branch 'master' of https://github.com/BabylonJS/Babylon.js

# Conflicts:
#	dist/preview release/babylon.d.ts
#	dist/preview release/babylon.js
#	dist/preview release/babylon.module.d.ts
#	dist/preview release/babylon.worker.js

Exporters/3ds Max/readme.md

@@ -1,78 +1,7 @@
 3DS Max to Babylon.js exporter
 ==============================
 
-This exporter is designed for 3ds Max 2013, 2015 and 2016 (Use 2015 version for 3dsMax 2016). You just have to unzip the content of the archive to [3ds max folder\bin\assemblies]
-
-**Before extracting, please go to downloaded .zip properties and click Unblock button**
-
-If you right click on the scene, on a light, on a camera or on a mesh you fill have a [Babylon...] menu. 
-
-To export you can use the [Babylon] menu in the main menu bar.
-
-## Exported features
-- *Scene*
- - Clear color
- - Ambient color
- - Fog
-- *Cameras*
- - Fov
- - MinZ
- - MaxZ
- - Speed (*)
- - Inertia (*)
- - Collisions (*)
- - Position
- - Target / Rotation
- - Animations: Position, Fov
-- *Lights*
- - Omni / spot / directional / Ambient(Hemispheric)
- - Shadows maps for directional lights (Variance shadow maps can be actived by checking [Absolute Map Bias] in light properties)
- - Inclusion / exclusion lists
- - Position / direction
- - Intensity
- - Diffuse
- - Specular
- - Animations: Position, Direction, intensity, diffuse
- - Range 
-- *Meshes*
- - Visibility
- - Renderable
- - Shadows
- - Collisions (*)
- - Pickable (*)
- - Position / rotation / scaling
- - Smoothing groups
- - Skin
- - Geometry (position, normal, texture coordinates (2 channels))
- - Show Bounding box and submeshes bounding boxes (*)
- - Animations: Position, scaling, rotation, visibility, bones
-- *Materials*
- - Multi-materials
- - Alpha
- - Diffuse color and texture
- - Ambient color and texture
- - Specular color and texture
- - Bump
- - Emissive color and texture
- - Opacity texture
- - Reflection texture
- - Fresnel for diffuse, emissive, opacity and reflection
-- *Textures*
- - UV offset / scaling / angle
- - Level
- - Coordinates mode (Spherical, planar, explicit)
- - Wrapping (Clamp, mirror, wrap)
-- Hierarchies are exported
-
-(*): Through custom UI
-
-## Animations
-Cameras, lights and meshes have custom properties (Right-click and select "Babylon properties" menu) to automatically launch animations at startup.
-
-Animations are exported by sampling keyframes which can generate a lot of data. To reduce file size, you can opt to use linear interpolation instead of bezier or TCB.
-
-## Consideration about bones
-To ensure that bones are correctly exported, you have to use the Skin modifier. Skin should be positioned at origin.
+Documentation: http://doc.babylonjs.com/exporters/3dsmax
 
 ## Apache License 2.0 (Apache)
 

Playground/js/index.js

@@ -458,13 +458,13 @@
                 return;
             }
 
-            if (textures[index].isRenderTarget || textures[index] instanceof BABYLON.DynamicTexture) {
+            if (textures[index].isRenderTarget || textures[index] instanceof BABYLON.DynamicTexture || textures[index].name.indexOf("data:") !== -1) {
                 addTexturesToZip(zip, index + 1, textures, folder, then);
                 return;
             }
 
             if (textures[index].isCube) {
-                if (textures[index]._extensions) {
+                if (textures[index]._extensions && textures[index].name.indexOf("dds") === -1) {
                     for (var i = 0; i < 6; i++) {
                         textures.push({ name: textures[index].name + textures[index]._extensions[i] });
                     }
@@ -486,10 +486,10 @@
                 url = textures[index].video.currentSrc;
             } else {
                 // url = textures[index].name;
-                url = textures[index].url;
+                url = textures[index].url ? textures[index].url : textures[index].name;
             }
 
-            var name = textures[index].name;
+            var name = textures[index].name.replace("textures/", "");
             // var name = url.substr(url.lastIndexOf("/") + 1);
 
             if (url != null) {
@@ -965,7 +965,8 @@
                         automaticLayout: true,
                         readOnly: false,
                         theme: "vs",
-                        contextmenu: false
+                        contextmenu: false,
+                        folding: true
                     });
 
                     run();

Tools/Gulp/package.json

@@ -10,8 +10,8 @@
     "gulp": "^3.8.11",
     "gulp-uglify": "^2.1.2",
     "gulp-sourcemaps": "~1.9.1",
-    "typescript": "~2.2.2",
-    "gulp-typescript": "^3.1.6",
+    "typescript": "~2.4.2",
+    "gulp-typescript": "^3.2.1",
     "through2": "~0.6.5",
     "gulp-util": "~3.0.4",
     "gulp-concat": "~2.5.2",

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

@@ -242,7 +242,8 @@ var BABYLON;
                 this._rootContainer._draw(measure, context);
             };
             AdvancedDynamicTexture.prototype._doPicking = function (x, y, type) {
-                var engine = this.getScene().getEngine();
+                var scene = this.getScene();
+                var engine = scene.getEngine();
                 var textureSize = this.getSize();
                 if (this._isFullscreen) {
                     x = x * (textureSize.width / engine.getRenderWidth());
@@ -270,8 +271,13 @@ var BABYLON;
                         && pi.type !== BABYLON.PointerEventTypes.POINTERDOWN) {
                         return;
                     }
+                    var camera = scene.activeCamera;
+                    var engine = scene.getEngine();
+                    var viewport = camera.viewport;
+                    var x = (scene.pointerX - viewport.x * engine.getRenderWidth()) / viewport.width;
+                    var y = (scene.pointerY - viewport.y * engine.getRenderHeight()) / viewport.height;
                     _this._shouldBlockPointer = false;
-                    _this._doPicking(scene.pointerX, scene.pointerY, pi.type);
+                    _this._doPicking(x, y, pi.type);
                     pi.skipOnPointerObservable = _this._shouldBlockPointer && pi.type !== BABYLON.PointerEventTypes.POINTERUP;
                 });
                 this._attachToOnBlur(scene);
@@ -507,15 +513,15 @@ var BABYLON;
                     Matrix2D._TempCompose1.multiplyToRef(Matrix2D._TempPostTranslationMatrix, result);
                 }
             };
+            Matrix2D._TempPreTranslationMatrix = Matrix2D.Identity();
+            Matrix2D._TempPostTranslationMatrix = Matrix2D.Identity();
+            Matrix2D._TempRotationMatrix = Matrix2D.Identity();
+            Matrix2D._TempScalingMatrix = Matrix2D.Identity();
+            Matrix2D._TempCompose0 = Matrix2D.Identity();
+            Matrix2D._TempCompose1 = Matrix2D.Identity();
+            Matrix2D._TempCompose2 = Matrix2D.Identity();
             return Matrix2D;
         }());
-        Matrix2D._TempPreTranslationMatrix = Matrix2D.Identity();
-        Matrix2D._TempPostTranslationMatrix = Matrix2D.Identity();
-        Matrix2D._TempRotationMatrix = Matrix2D.Identity();
-        Matrix2D._TempScalingMatrix = Matrix2D.Identity();
-        Matrix2D._TempCompose0 = Matrix2D.Identity();
-        Matrix2D._TempCompose1 = Matrix2D.Identity();
-        Matrix2D._TempCompose2 = Matrix2D.Identity();
         GUI.Matrix2D = Matrix2D;
     })(GUI = BABYLON.GUI || (BABYLON.GUI = {}));
 })(BABYLON || (BABYLON = {}));
@@ -628,12 +634,12 @@ var BABYLON;
                 enumerable: true,
                 configurable: true
             });
+            // Static
+            ValueAndUnit._Regex = /(^-?\d*(\.\d+)?)(%|px)?/;
+            ValueAndUnit._UNITMODE_PERCENTAGE = 0;
+            ValueAndUnit._UNITMODE_PIXEL = 1;
             return ValueAndUnit;
         }());
-        // Static
-        ValueAndUnit._Regex = /(^-?\d*(\.\d+)?)(%|px)?/;
-        ValueAndUnit._UNITMODE_PERCENTAGE = 0;
-        ValueAndUnit._UNITMODE_PIXEL = 1;
         GUI.ValueAndUnit = ValueAndUnit;
     })(GUI = BABYLON.GUI || (BABYLON.GUI = {}));
 })(BABYLON || (BABYLON = {}));
@@ -1548,16 +1554,16 @@ var BABYLON;
                 context.scale(1 / width, 1 / height);
                 context.translate(-x, -y);
             };
+            // Statics
+            Control._HORIZONTAL_ALIGNMENT_LEFT = 0;
+            Control._HORIZONTAL_ALIGNMENT_RIGHT = 1;
+            Control._HORIZONTAL_ALIGNMENT_CENTER = 2;
+            Control._VERTICAL_ALIGNMENT_TOP = 0;
+            Control._VERTICAL_ALIGNMENT_BOTTOM = 1;
+            Control._VERTICAL_ALIGNMENT_CENTER = 2;
+            Control._FontHeightSizes = {};
             return Control;
         }());
-        // Statics
-        Control._HORIZONTAL_ALIGNMENT_LEFT = 0;
-        Control._HORIZONTAL_ALIGNMENT_RIGHT = 1;
-        Control._HORIZONTAL_ALIGNMENT_CENTER = 2;
-        Control._VERTICAL_ALIGNMENT_TOP = 0;
-        Control._VERTICAL_ALIGNMENT_BOTTOM = 1;
-        Control._VERTICAL_ALIGNMENT_CENTER = 2;
-        Control._FontHeightSizes = {};
         GUI.Control = Control;
     })(GUI = BABYLON.GUI || (BABYLON.GUI = {}));
 })(BABYLON || (BABYLON = {}));
@@ -3200,13 +3206,13 @@ var BABYLON;
                 enumerable: true,
                 configurable: true
             });
+            // Static
+            Image._STRETCH_NONE = 0;
+            Image._STRETCH_FILL = 1;
+            Image._STRETCH_UNIFORM = 2;
+            Image._STRETCH_EXTEND = 3;
             return Image;
         }(GUI.Control));
-        // Static
-        Image._STRETCH_NONE = 0;
-        Image._STRETCH_FILL = 1;
-        Image._STRETCH_UNIFORM = 2;
-        Image._STRETCH_EXTEND = 3;
         GUI.Image = Image;
     })(GUI = BABYLON.GUI || (BABYLON.GUI = {}));
 })(BABYLON || (BABYLON = {}));

dist/preview release/inspector/babylon.inspector.js

@@ -927,10 +927,10 @@ var INSPECTOR;
         /** Should be overriden in subclasses */
         Adapter.prototype.highlight = function (b) { };
         ;
+        // a unique name for this adapter, to retrieve its own key in the local storage
+        Adapter._name = BABYLON.Geometry.RandomId();
         return Adapter;
     }());
-    // a unique name for this adapter, to retrieve its own key in the local storage
-    Adapter._name = BABYLON.Geometry.RandomId();
     INSPECTOR.Adapter = Adapter;
 })(INSPECTOR || (INSPECTOR = {}));
 
@@ -1378,16 +1378,16 @@ var INSPECTOR;
             this.actualObject.outlineWidth = 0.25;
             this.actualObject.outlineColor = BABYLON.Color3.Yellow();
         };
+        LightAdapter._PROPERTIES = [
+            'position',
+            'diffuse',
+            'intensity',
+            'radius',
+            'range',
+            'specular'
+        ];
         return LightAdapter;
     }(INSPECTOR.Adapter));
-    LightAdapter._PROPERTIES = [
-        'position',
-        'diffuse',
-        'intensity',
-        'radius',
-        'range',
-        'specular'
-    ];
     INSPECTOR.LightAdapter = LightAdapter;
 })(INSPECTOR || (INSPECTOR = {}));
 
@@ -2136,12 +2136,12 @@ var INSPECTOR;
                 }
             }
         };
+        // Array representing the simple type. All others are considered 'complex'
+        PropertyLine._SIMPLE_TYPE = ['number', 'string', 'boolean'];
+        // The number of pixel at each children step
+        PropertyLine._MARGIN_LEFT = 15;
         return PropertyLine;
     }());
-    // Array representing the simple type. All others are considered 'complex'
-    PropertyLine._SIMPLE_TYPE = ['number', 'string', 'boolean'];
-    // The number of pixel at each children step
-    PropertyLine._MARGIN_LEFT = 15;
     INSPECTOR.PropertyLine = PropertyLine;
 })(INSPECTOR || (INSPECTOR = {}));
 
@@ -2668,10 +2668,10 @@ var INSPECTOR;
                 }
             }
         };
+        /** All properties are refreshed every 250ms */
+        Scheduler.REFRESH_TIME = 250;
         return Scheduler;
     }());
-    /** All properties are refreshed every 250ms */
-    Scheduler.REFRESH_TIME = 250;
     INSPECTOR.Scheduler = Scheduler;
 })(INSPECTOR || (INSPECTOR = {}));
 

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

@@ -217,11 +217,11 @@ var BABYLON;
             }
             return result;
         };
+        // V1 options
+        GLTFFileLoader.HomogeneousCoordinates = false;
+        GLTFFileLoader.IncrementalLoading = true;
         return GLTFFileLoader;
     }());
-    // V1 options
-    GLTFFileLoader.HomogeneousCoordinates = false;
-    GLTFFileLoader.IncrementalLoading = true;
     BABYLON.GLTFFileLoader = GLTFFileLoader;
     var BinaryReader = (function () {
         function BinaryReader(arrayBuffer) {
@@ -1783,9 +1783,9 @@ var BABYLON;
                     }
                 }
             };
+            GLTFLoader.Extensions = {};
             return GLTFLoader;
         }());
-        GLTFLoader.Extensions = {};
         GLTF1.GLTFLoader = GLTFLoader;
         ;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV1 = function () { return new GLTFLoader(); };
@@ -2037,10 +2037,10 @@ var BABYLON;
                 }
                 return GLTFUtils._DefaultMaterial;
             };
+            // The GLTF default material
+            GLTFUtils._DefaultMaterial = null;
             return GLTFUtils;
         }());
-        // The GLTF default material
-        GLTFUtils._DefaultMaterial = null;
         GLTF1.GLTFUtils = GLTFUtils;
     })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
 })(BABYLON || (BABYLON = {}));

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

@@ -217,11 +217,11 @@ var BABYLON;
             }
             return result;
         };
+        // V1 options
+        GLTFFileLoader.HomogeneousCoordinates = false;
+        GLTFFileLoader.IncrementalLoading = true;
         return GLTFFileLoader;
     }());
-    // V1 options
-    GLTFFileLoader.HomogeneousCoordinates = false;
-    GLTFFileLoader.IncrementalLoading = true;
     BABYLON.GLTFFileLoader = GLTFFileLoader;
     var BinaryReader = (function () {
         function BinaryReader(arrayBuffer) {
@@ -1291,9 +1291,9 @@ var BABYLON;
                 }
                 return babylonTexture;
             };
+            GLTFLoader.Extensions = {};
             return GLTFLoader;
         }());
-        GLTFLoader.Extensions = {};
         GLTF2.GLTFLoader = GLTFLoader;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV2 = function (parent) { return new GLTFLoader(parent); };
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
@@ -1429,12 +1429,12 @@ var BABYLON;
                 }
                 return false;
             };
+            //
+            // Utilities
+            //
+            GLTFLoaderExtension._Extensions = [];
             return GLTFLoaderExtension;
         }());
-        //
-        // Utilities
-        //
-        GLTFLoaderExtension._Extensions = [];
         GLTF2.GLTFLoaderExtension = GLTFLoaderExtension;
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
 })(BABYLON || (BABYLON = {}));
@@ -1518,12 +1518,12 @@ var BABYLON;
                         });
                     });
                 };
+                /**
+                 * Specify the minimal delay between LODs in ms (default = 250)
+                 */
+                MSFTLOD.MinimalLODDelay = 250;
                 return MSFTLOD;
             }(GLTF2.GLTFLoaderExtension));
-            /**
-             * Specify the minimal delay between LODs in ms (default = 250)
-             */
-            MSFTLOD.MinimalLODDelay = 250;
             Extensions.MSFTLOD = MSFTLOD;
             GLTF2.GLTFLoader.RegisterExtension(new MSFTLOD());
         })(Extensions = GLTF2.Extensions || (GLTF2.Extensions = {}));

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

@@ -217,11 +217,11 @@ var BABYLON;
             }
             return result;
         };
+        // V1 options
+        GLTFFileLoader.HomogeneousCoordinates = false;
+        GLTFFileLoader.IncrementalLoading = true;
         return GLTFFileLoader;
     }());
-    // V1 options
-    GLTFFileLoader.HomogeneousCoordinates = false;
-    GLTFFileLoader.IncrementalLoading = true;
     BABYLON.GLTFFileLoader = GLTFFileLoader;
     var BinaryReader = (function () {
         function BinaryReader(arrayBuffer) {
@@ -1783,9 +1783,9 @@ var BABYLON;
                     }
                 }
             };
+            GLTFLoader.Extensions = {};
             return GLTFLoader;
         }());
-        GLTFLoader.Extensions = {};
         GLTF1.GLTFLoader = GLTFLoader;
         ;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV1 = function () { return new GLTFLoader(); };
@@ -2037,10 +2037,10 @@ var BABYLON;
                 }
                 return GLTFUtils._DefaultMaterial;
             };
+            // The GLTF default material
+            GLTFUtils._DefaultMaterial = null;
             return GLTFUtils;
         }());
-        // The GLTF default material
-        GLTFUtils._DefaultMaterial = null;
         GLTF1.GLTFUtils = GLTFUtils;
     })(GLTF1 = BABYLON.GLTF1 || (BABYLON.GLTF1 = {}));
 })(BABYLON || (BABYLON = {}));
@@ -3449,9 +3449,9 @@ var BABYLON;
                 }
                 return babylonTexture;
             };
+            GLTFLoader.Extensions = {};
             return GLTFLoader;
         }());
-        GLTFLoader.Extensions = {};
         GLTF2.GLTFLoader = GLTFLoader;
         BABYLON.GLTFFileLoader.CreateGLTFLoaderV2 = function (parent) { return new GLTFLoader(parent); };
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
@@ -3587,12 +3587,12 @@ var BABYLON;
                 }
                 return false;
             };
+            //
+            // Utilities
+            //
+            GLTFLoaderExtension._Extensions = [];
             return GLTFLoaderExtension;
         }());
-        //
-        // Utilities
-        //
-        GLTFLoaderExtension._Extensions = [];
         GLTF2.GLTFLoaderExtension = GLTFLoaderExtension;
     })(GLTF2 = BABYLON.GLTF2 || (BABYLON.GLTF2 = {}));
 })(BABYLON || (BABYLON = {}));
@@ -3676,12 +3676,12 @@ var BABYLON;
                         });
                     });
                 };
+                /**
+                 * Specify the minimal delay between LODs in ms (default = 250)
+                 */
+                MSFTLOD.MinimalLODDelay = 250;
                 return MSFTLOD;
             }(GLTF2.GLTFLoaderExtension));
-            /**
-             * Specify the minimal delay between LODs in ms (default = 250)
-             */
-            MSFTLOD.MinimalLODDelay = 250;
             Extensions.MSFTLOD = MSFTLOD;
             GLTF2.GLTFLoader.RegisterExtension(new MSFTLOD());
         })(Extensions = GLTF2.Extensions || (GLTF2.Extensions = {}));

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

@@ -766,9 +766,9 @@ var BABYLON;
             //Return an array with all BABYLON.Mesh
             return babylonMeshesArray;
         };
+        OBJFileLoader.OPTIMIZE_WITH_UV = false;
         return OBJFileLoader;
     }());
-    OBJFileLoader.OPTIMIZE_WITH_UV = false;
     BABYLON.OBJFileLoader = OBJFileLoader;
     if (BABYLON.SceneLoader) {
         //Add this loader into the register plugin

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

@@ -255,35 +255,35 @@ var BABYLON;
         CellMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new CellMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture")
+        ], CellMaterial.prototype, "_diffuseTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], CellMaterial.prototype, "diffuseTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("diffuseColor")
+        ], CellMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serialize("computeHighLevel")
+        ], CellMaterial.prototype, "_computeHighLevel", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], CellMaterial.prototype, "computeHighLevel", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], CellMaterial.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], CellMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], CellMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], CellMaterial.prototype, "maxSimultaneousLights", void 0);
         return CellMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture")
-    ], CellMaterial.prototype, "_diffuseTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], CellMaterial.prototype, "diffuseTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("diffuseColor")
-    ], CellMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serialize("computeHighLevel")
-    ], CellMaterial.prototype, "_computeHighLevel", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], CellMaterial.prototype, "computeHighLevel", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], CellMaterial.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], CellMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], CellMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], CellMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.CellMaterial = CellMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -1161,227 +1161,227 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        // Flags used to enable or disable a type of texture for all Standard Materials
+        StandardMaterial_OldVer._DiffuseTextureEnabled = true;
+        StandardMaterial_OldVer._AmbientTextureEnabled = true;
+        StandardMaterial_OldVer._OpacityTextureEnabled = true;
+        StandardMaterial_OldVer._ReflectionTextureEnabled = true;
+        StandardMaterial_OldVer._EmissiveTextureEnabled = true;
+        StandardMaterial_OldVer._SpecularTextureEnabled = true;
+        StandardMaterial_OldVer._BumpTextureEnabled = true;
+        StandardMaterial_OldVer._LightmapTextureEnabled = true;
+        StandardMaterial_OldVer._RefractionTextureEnabled = true;
+        StandardMaterial_OldVer._ColorGradingTextureEnabled = true;
+        StandardMaterial_OldVer._FresnelEnabled = true;
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture")
+        ], StandardMaterial_OldVer.prototype, "_diffuseTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "diffuseTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("ambientTexture")
+        ], StandardMaterial_OldVer.prototype, "_ambientTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "ambientTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("opacityTexture")
+        ], StandardMaterial_OldVer.prototype, "_opacityTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "opacityTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("reflectionTexture")
+        ], StandardMaterial_OldVer.prototype, "_reflectionTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "reflectionTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("emissiveTexture")
+        ], StandardMaterial_OldVer.prototype, "_emissiveTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "emissiveTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("specularTexture")
+        ], StandardMaterial_OldVer.prototype, "_specularTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "specularTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("bumpTexture")
+        ], StandardMaterial_OldVer.prototype, "_bumpTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "bumpTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("lightmapTexture")
+        ], StandardMaterial_OldVer.prototype, "_lightmapTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "lightmapTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("refractionTexture")
+        ], StandardMaterial_OldVer.prototype, "_refractionTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "refractionTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("ambient")
+        ], StandardMaterial_OldVer.prototype, "ambientColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("diffuse")
+        ], StandardMaterial_OldVer.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("specular")
+        ], StandardMaterial_OldVer.prototype, "specularColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("emissive")
+        ], StandardMaterial_OldVer.prototype, "emissiveColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], StandardMaterial_OldVer.prototype, "specularPower", void 0);
+        __decorate([
+            BABYLON.serialize("useAlphaFromDiffuseTexture")
+        ], StandardMaterial_OldVer.prototype, "_useAlphaFromDiffuseTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "useAlphaFromDiffuseTexture", void 0);
+        __decorate([
+            BABYLON.serialize("useEmissiveAsIllumination")
+        ], StandardMaterial_OldVer.prototype, "_useEmissiveAsIllumination", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "useEmissiveAsIllumination", void 0);
+        __decorate([
+            BABYLON.serialize("linkEmissiveWithDiffuse")
+        ], StandardMaterial_OldVer.prototype, "_linkEmissiveWithDiffuse", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "linkEmissiveWithDiffuse", void 0);
+        __decorate([
+            BABYLON.serialize("useSpecularOverAlpha")
+        ], StandardMaterial_OldVer.prototype, "_useSpecularOverAlpha", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "useSpecularOverAlpha", void 0);
+        __decorate([
+            BABYLON.serialize("useReflectionOverAlpha")
+        ], StandardMaterial_OldVer.prototype, "_useReflectionOverAlpha", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "useReflectionOverAlpha", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], StandardMaterial_OldVer.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], StandardMaterial_OldVer.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("useParallax")
+        ], StandardMaterial_OldVer.prototype, "_useParallax", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "useParallax", void 0);
+        __decorate([
+            BABYLON.serialize("useParallaxOcclusion")
+        ], StandardMaterial_OldVer.prototype, "_useParallaxOcclusion", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "useParallaxOcclusion", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], StandardMaterial_OldVer.prototype, "parallaxScaleBias", void 0);
+        __decorate([
+            BABYLON.serialize("roughness")
+        ], StandardMaterial_OldVer.prototype, "_roughness", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "roughness", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], StandardMaterial_OldVer.prototype, "indexOfRefraction", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], StandardMaterial_OldVer.prototype, "invertRefractionY", void 0);
+        __decorate([
+            BABYLON.serialize("useLightmapAsShadowmap")
+        ], StandardMaterial_OldVer.prototype, "_useLightmapAsShadowmap", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "useLightmapAsShadowmap", void 0);
+        __decorate([
+            BABYLON.serializeAsFresnelParameters("diffuseFresnelParameters")
+        ], StandardMaterial_OldVer.prototype, "_diffuseFresnelParameters", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+        ], StandardMaterial_OldVer.prototype, "diffuseFresnelParameters", void 0);
+        __decorate([
+            BABYLON.serializeAsFresnelParameters("opacityFresnelParameters")
+        ], StandardMaterial_OldVer.prototype, "_opacityFresnelParameters", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+        ], StandardMaterial_OldVer.prototype, "opacityFresnelParameters", void 0);
+        __decorate([
+            BABYLON.serializeAsFresnelParameters("reflectionFresnelParameters")
+        ], StandardMaterial_OldVer.prototype, "_reflectionFresnelParameters", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+        ], StandardMaterial_OldVer.prototype, "reflectionFresnelParameters", void 0);
+        __decorate([
+            BABYLON.serializeAsFresnelParameters("refractionFresnelParameters")
+        ], StandardMaterial_OldVer.prototype, "_refractionFresnelParameters", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+        ], StandardMaterial_OldVer.prototype, "refractionFresnelParameters", void 0);
+        __decorate([
+            BABYLON.serializeAsFresnelParameters("emissiveFresnelParameters")
+        ], StandardMaterial_OldVer.prototype, "_emissiveFresnelParameters", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+        ], StandardMaterial_OldVer.prototype, "emissiveFresnelParameters", void 0);
+        __decorate([
+            BABYLON.serialize("useReflectionFresnelFromSpecular")
+        ], StandardMaterial_OldVer.prototype, "_useReflectionFresnelFromSpecular", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
+        ], StandardMaterial_OldVer.prototype, "useReflectionFresnelFromSpecular", void 0);
+        __decorate([
+            BABYLON.serialize("useGlossinessFromSpecularMapAlpha")
+        ], StandardMaterial_OldVer.prototype, "_useGlossinessFromSpecularMapAlpha", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "useGlossinessFromSpecularMapAlpha", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], StandardMaterial_OldVer.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], StandardMaterial_OldVer.prototype, "maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.serialize("invertNormalMapX")
+        ], StandardMaterial_OldVer.prototype, "_invertNormalMapX", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "invertNormalMapX", void 0);
+        __decorate([
+            BABYLON.serialize("invertNormalMapY")
+        ], StandardMaterial_OldVer.prototype, "_invertNormalMapY", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "invertNormalMapY", void 0);
+        __decorate([
+            BABYLON.serialize("twoSidedLighting")
+        ], StandardMaterial_OldVer.prototype, "_twoSidedLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], StandardMaterial_OldVer.prototype, "twoSidedLighting", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], StandardMaterial_OldVer.prototype, "useLogarithmicDepth", null);
         return StandardMaterial_OldVer;
     }(BABYLON.PushMaterial));
-    // Flags used to enable or disable a type of texture for all Standard Materials
-    StandardMaterial_OldVer._DiffuseTextureEnabled = true;
-    StandardMaterial_OldVer._AmbientTextureEnabled = true;
-    StandardMaterial_OldVer._OpacityTextureEnabled = true;
-    StandardMaterial_OldVer._ReflectionTextureEnabled = true;
-    StandardMaterial_OldVer._EmissiveTextureEnabled = true;
-    StandardMaterial_OldVer._SpecularTextureEnabled = true;
-    StandardMaterial_OldVer._BumpTextureEnabled = true;
-    StandardMaterial_OldVer._LightmapTextureEnabled = true;
-    StandardMaterial_OldVer._RefractionTextureEnabled = true;
-    StandardMaterial_OldVer._ColorGradingTextureEnabled = true;
-    StandardMaterial_OldVer._FresnelEnabled = true;
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture")
-    ], StandardMaterial_OldVer.prototype, "_diffuseTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "diffuseTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("ambientTexture")
-    ], StandardMaterial_OldVer.prototype, "_ambientTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "ambientTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("opacityTexture")
-    ], StandardMaterial_OldVer.prototype, "_opacityTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "opacityTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("reflectionTexture")
-    ], StandardMaterial_OldVer.prototype, "_reflectionTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "reflectionTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("emissiveTexture")
-    ], StandardMaterial_OldVer.prototype, "_emissiveTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "emissiveTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("specularTexture")
-    ], StandardMaterial_OldVer.prototype, "_specularTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "specularTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("bumpTexture")
-    ], StandardMaterial_OldVer.prototype, "_bumpTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "bumpTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("lightmapTexture")
-    ], StandardMaterial_OldVer.prototype, "_lightmapTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "lightmapTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("refractionTexture")
-    ], StandardMaterial_OldVer.prototype, "_refractionTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "refractionTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("ambient")
-    ], StandardMaterial_OldVer.prototype, "ambientColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("diffuse")
-    ], StandardMaterial_OldVer.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("specular")
-    ], StandardMaterial_OldVer.prototype, "specularColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("emissive")
-    ], StandardMaterial_OldVer.prototype, "emissiveColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], StandardMaterial_OldVer.prototype, "specularPower", void 0);
-    __decorate([
-        BABYLON.serialize("useAlphaFromDiffuseTexture")
-    ], StandardMaterial_OldVer.prototype, "_useAlphaFromDiffuseTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "useAlphaFromDiffuseTexture", void 0);
-    __decorate([
-        BABYLON.serialize("useEmissiveAsIllumination")
-    ], StandardMaterial_OldVer.prototype, "_useEmissiveAsIllumination", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "useEmissiveAsIllumination", void 0);
-    __decorate([
-        BABYLON.serialize("linkEmissiveWithDiffuse")
-    ], StandardMaterial_OldVer.prototype, "_linkEmissiveWithDiffuse", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "linkEmissiveWithDiffuse", void 0);
-    __decorate([
-        BABYLON.serialize("useSpecularOverAlpha")
-    ], StandardMaterial_OldVer.prototype, "_useSpecularOverAlpha", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "useSpecularOverAlpha", void 0);
-    __decorate([
-        BABYLON.serialize("useReflectionOverAlpha")
-    ], StandardMaterial_OldVer.prototype, "_useReflectionOverAlpha", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "useReflectionOverAlpha", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], StandardMaterial_OldVer.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], StandardMaterial_OldVer.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("useParallax")
-    ], StandardMaterial_OldVer.prototype, "_useParallax", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "useParallax", void 0);
-    __decorate([
-        BABYLON.serialize("useParallaxOcclusion")
-    ], StandardMaterial_OldVer.prototype, "_useParallaxOcclusion", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "useParallaxOcclusion", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], StandardMaterial_OldVer.prototype, "parallaxScaleBias", void 0);
-    __decorate([
-        BABYLON.serialize("roughness")
-    ], StandardMaterial_OldVer.prototype, "_roughness", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "roughness", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], StandardMaterial_OldVer.prototype, "indexOfRefraction", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], StandardMaterial_OldVer.prototype, "invertRefractionY", void 0);
-    __decorate([
-        BABYLON.serialize("useLightmapAsShadowmap")
-    ], StandardMaterial_OldVer.prototype, "_useLightmapAsShadowmap", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "useLightmapAsShadowmap", void 0);
-    __decorate([
-        BABYLON.serializeAsFresnelParameters("diffuseFresnelParameters")
-    ], StandardMaterial_OldVer.prototype, "_diffuseFresnelParameters", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-    ], StandardMaterial_OldVer.prototype, "diffuseFresnelParameters", void 0);
-    __decorate([
-        BABYLON.serializeAsFresnelParameters("opacityFresnelParameters")
-    ], StandardMaterial_OldVer.prototype, "_opacityFresnelParameters", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-    ], StandardMaterial_OldVer.prototype, "opacityFresnelParameters", void 0);
-    __decorate([
-        BABYLON.serializeAsFresnelParameters("reflectionFresnelParameters")
-    ], StandardMaterial_OldVer.prototype, "_reflectionFresnelParameters", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-    ], StandardMaterial_OldVer.prototype, "reflectionFresnelParameters", void 0);
-    __decorate([
-        BABYLON.serializeAsFresnelParameters("refractionFresnelParameters")
-    ], StandardMaterial_OldVer.prototype, "_refractionFresnelParameters", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-    ], StandardMaterial_OldVer.prototype, "refractionFresnelParameters", void 0);
-    __decorate([
-        BABYLON.serializeAsFresnelParameters("emissiveFresnelParameters")
-    ], StandardMaterial_OldVer.prototype, "_emissiveFresnelParameters", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-    ], StandardMaterial_OldVer.prototype, "emissiveFresnelParameters", void 0);
-    __decorate([
-        BABYLON.serialize("useReflectionFresnelFromSpecular")
-    ], StandardMaterial_OldVer.prototype, "_useReflectionFresnelFromSpecular", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsFresnelDirty")
-    ], StandardMaterial_OldVer.prototype, "useReflectionFresnelFromSpecular", void 0);
-    __decorate([
-        BABYLON.serialize("useGlossinessFromSpecularMapAlpha")
-    ], StandardMaterial_OldVer.prototype, "_useGlossinessFromSpecularMapAlpha", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "useGlossinessFromSpecularMapAlpha", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], StandardMaterial_OldVer.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], StandardMaterial_OldVer.prototype, "maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.serialize("invertNormalMapX")
-    ], StandardMaterial_OldVer.prototype, "_invertNormalMapX", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "invertNormalMapX", void 0);
-    __decorate([
-        BABYLON.serialize("invertNormalMapY")
-    ], StandardMaterial_OldVer.prototype, "_invertNormalMapY", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "invertNormalMapY", void 0);
-    __decorate([
-        BABYLON.serialize("twoSidedLighting")
-    ], StandardMaterial_OldVer.prototype, "_twoSidedLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], StandardMaterial_OldVer.prototype, "twoSidedLighting", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], StandardMaterial_OldVer.prototype, "useLogarithmicDepth", null);
     BABYLON.StandardMaterial_OldVer = StandardMaterial_OldVer;
     var CustomShaderStructure = (function () {
         function CustomShaderStructure() {
@@ -2048,9 +2048,9 @@ vColor=color;\n\
             this.CustomParts.Vertex_Before_NormalUpdated = shaderPart.replace("result", "normalUpdated");
             return this;
         };
+        CustomMaterial.ShaderIndexer = 1;
         return CustomMaterial;
     }(StandardMaterial_OldVer));
-    CustomMaterial.ShaderIndexer = 1;
     BABYLON.CustomMaterial = CustomMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -292,32 +292,32 @@ var BABYLON;
             }
             return material;
         };
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture")
+        ], FireMaterial.prototype, "_diffuseTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], FireMaterial.prototype, "diffuseTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("distortionTexture")
+        ], FireMaterial.prototype, "_distortionTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], FireMaterial.prototype, "distortionTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("opacityTexture")
+        ], FireMaterial.prototype, "_opacityTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], FireMaterial.prototype, "opacityTexture", void 0);
+        __decorate([
+            BABYLON.serialize("diffuseColor")
+        ], FireMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FireMaterial.prototype, "speed", void 0);
         return FireMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture")
-    ], FireMaterial.prototype, "_diffuseTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], FireMaterial.prototype, "diffuseTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("distortionTexture")
-    ], FireMaterial.prototype, "_distortionTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], FireMaterial.prototype, "distortionTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("opacityTexture")
-    ], FireMaterial.prototype, "_opacityTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], FireMaterial.prototype, "opacityTexture", void 0);
-    __decorate([
-        BABYLON.serialize("diffuseColor")
-    ], FireMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FireMaterial.prototype, "speed", void 0);
     BABYLON.FireMaterial = FireMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -402,65 +402,65 @@ var BABYLON;
             sourceMesh.material._meshes = meshes;
             return meshes;
         };
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture")
+        ], FurMaterial.prototype, "_diffuseTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], FurMaterial.prototype, "diffuseTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("heightTexture")
+        ], FurMaterial.prototype, "_heightTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], FurMaterial.prototype, "heightTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], FurMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furLength", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furAngle", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], FurMaterial.prototype, "furColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furOffset", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furSpacing", void 0);
+        __decorate([
+            BABYLON.serializeAsVector3()
+        ], FurMaterial.prototype, "furGravity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furSpeed", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furDensity", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], FurMaterial.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], FurMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], FurMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], FurMaterial.prototype, "maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "highLevelFur", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], FurMaterial.prototype, "furTime", null);
         return FurMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture")
-    ], FurMaterial.prototype, "_diffuseTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], FurMaterial.prototype, "diffuseTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("heightTexture")
-    ], FurMaterial.prototype, "_heightTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], FurMaterial.prototype, "heightTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], FurMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FurMaterial.prototype, "furLength", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FurMaterial.prototype, "furAngle", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], FurMaterial.prototype, "furColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FurMaterial.prototype, "furOffset", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FurMaterial.prototype, "furSpacing", void 0);
-    __decorate([
-        BABYLON.serializeAsVector3()
-    ], FurMaterial.prototype, "furGravity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FurMaterial.prototype, "furSpeed", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FurMaterial.prototype, "furDensity", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], FurMaterial.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], FurMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], FurMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], FurMaterial.prototype, "maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FurMaterial.prototype, "highLevelFur", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], FurMaterial.prototype, "furTime", null);
     BABYLON.FurMaterial = FurMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -251,35 +251,35 @@ var BABYLON;
         GradientMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new GradientMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], GradientMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], GradientMaterial.prototype, "maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], GradientMaterial.prototype, "topColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "topColorAlpha", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], GradientMaterial.prototype, "bottomColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "bottomColorAlpha", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "offset", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "smoothness", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GradientMaterial.prototype, "disableLighting", void 0);
         return GradientMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], GradientMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], GradientMaterial.prototype, "maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], GradientMaterial.prototype, "topColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GradientMaterial.prototype, "topColorAlpha", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], GradientMaterial.prototype, "bottomColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GradientMaterial.prototype, "bottomColorAlpha", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GradientMaterial.prototype, "offset", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GradientMaterial.prototype, "smoothness", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GradientMaterial.prototype, "disableLighting", void 0);
     BABYLON.GradientMaterial = GradientMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -167,29 +167,29 @@ var BABYLON;
         GridMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new GridMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], GridMaterial.prototype, "mainColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], GridMaterial.prototype, "lineColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GridMaterial.prototype, "gridRatio", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GridMaterial.prototype, "majorUnitFrequency", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GridMaterial.prototype, "minorUnitVisibility", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GridMaterial.prototype, "opacity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], GridMaterial.prototype, "preMultiplyAlpha", void 0);
         return GridMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], GridMaterial.prototype, "mainColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], GridMaterial.prototype, "lineColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GridMaterial.prototype, "gridRatio", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GridMaterial.prototype, "majorUnitFrequency", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GridMaterial.prototype, "minorUnitVisibility", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GridMaterial.prototype, "opacity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], GridMaterial.prototype, "preMultiplyAlpha", void 0);
     BABYLON.GridMaterial = GridMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -312,47 +312,47 @@ var BABYLON;
         LavaMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new LavaMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture")
+        ], LavaMaterial.prototype, "_diffuseTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], LavaMaterial.prototype, "diffuseTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LavaMaterial.prototype, "noiseTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LavaMaterial.prototype, "fogColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "speed", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "movingSpeed", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "lowFrequencySpeed", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LavaMaterial.prototype, "fogDensity", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LavaMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], LavaMaterial.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], LavaMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], LavaMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], LavaMaterial.prototype, "maxSimultaneousLights", void 0);
         return LavaMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture")
-    ], LavaMaterial.prototype, "_diffuseTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], LavaMaterial.prototype, "diffuseTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LavaMaterial.prototype, "noiseTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], LavaMaterial.prototype, "fogColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LavaMaterial.prototype, "speed", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LavaMaterial.prototype, "movingSpeed", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LavaMaterial.prototype, "lowFrequencySpeed", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LavaMaterial.prototype, "fogDensity", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], LavaMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], LavaMaterial.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], LavaMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], LavaMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], LavaMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.LavaMaterial = LavaMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -1284,228 +1284,228 @@ var BABYLON;
         LegacyPBRMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new LegacyPBRMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        LegacyPBRMaterial._scaledAlbedo = new BABYLON.Color3();
+        LegacyPBRMaterial._scaledReflectivity = new BABYLON.Color3();
+        LegacyPBRMaterial._scaledEmissive = new BABYLON.Color3();
+        LegacyPBRMaterial._scaledReflection = new BABYLON.Color3();
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "directIntensity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "emissiveIntensity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "environmentIntensity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "specularIntensity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "disableBumpMap", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedShadowIntensity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedShadeIntensity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "cameraExposure", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "cameraContrast", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "cameraColorGradingTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColorCurves()
+        ], LegacyPBRMaterial.prototype, "cameraColorCurves", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LegacyPBRMaterial.prototype, "overloadedAmbient", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedAmbientIntensity", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LegacyPBRMaterial.prototype, "overloadedAlbedo", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedAlbedoIntensity", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LegacyPBRMaterial.prototype, "overloadedReflectivity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedReflectivityIntensity", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LegacyPBRMaterial.prototype, "overloadedEmissive", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedEmissiveIntensity", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], LegacyPBRMaterial.prototype, "overloadedReflection", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedReflectionIntensity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedMicroSurface", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "overloadedMicroSurfaceIntensity", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "albedoTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "ambientTexture", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "ambientTextureStrength", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "opacityTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "reflectionTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "emissiveTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "reflectivityTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "metallicTexture", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "metallic", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "roughness", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "microSurfaceTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "bumpTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "lightmapTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], LegacyPBRMaterial.prototype, "refractionTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("ambient")
+        ], LegacyPBRMaterial.prototype, "ambientColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("albedo")
+        ], LegacyPBRMaterial.prototype, "albedoColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("reflectivity")
+        ], LegacyPBRMaterial.prototype, "reflectivityColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("reflection")
+        ], LegacyPBRMaterial.prototype, "reflectionColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("emissive")
+        ], LegacyPBRMaterial.prototype, "emissiveColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "microSurface", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "indexOfRefraction", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "invertRefractionY", void 0);
+        __decorate([
+            BABYLON.serializeAsFresnelParameters()
+        ], LegacyPBRMaterial.prototype, "opacityFresnelParameters", void 0);
+        __decorate([
+            BABYLON.serializeAsFresnelParameters()
+        ], LegacyPBRMaterial.prototype, "emissiveFresnelParameters", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "linkRefractionWithTransparency", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "linkEmissiveWithAlbedo", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useLightmapAsShadowmap", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useEmissiveAsIllumination", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useAlphaFromAlbedoTexture", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useSpecularOverAlpha", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useMicroSurfaceFromReflectivityMapAlpha", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useRoughnessFromMetallicTextureAlpha", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useRoughnessFromMetallicTextureGreen", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useMetallnessFromMetallicTextureBlue", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useAmbientOcclusionFromMetallicTextureRed", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useAmbientInGrayScale", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useAutoMicroSurfaceFromReflectivityMap", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useScalarInLinearSpace", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "usePhysicalLightFalloff", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useRadianceOverAlpha", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useParallax", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useParallaxOcclusion", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "parallaxScaleBias", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "invertNormalMapX", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "invertNormalMapY", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "twoSidedLighting", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], LegacyPBRMaterial.prototype, "useLogarithmicDepth", null);
         return LegacyPBRMaterial;
     }(BABYLON.Material));
-    LegacyPBRMaterial._scaledAlbedo = new BABYLON.Color3();
-    LegacyPBRMaterial._scaledReflectivity = new BABYLON.Color3();
-    LegacyPBRMaterial._scaledEmissive = new BABYLON.Color3();
-    LegacyPBRMaterial._scaledReflection = new BABYLON.Color3();
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "directIntensity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "emissiveIntensity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "environmentIntensity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "specularIntensity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "disableBumpMap", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedShadowIntensity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedShadeIntensity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "cameraExposure", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "cameraContrast", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "cameraColorGradingTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColorCurves()
-    ], LegacyPBRMaterial.prototype, "cameraColorCurves", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], LegacyPBRMaterial.prototype, "overloadedAmbient", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedAmbientIntensity", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], LegacyPBRMaterial.prototype, "overloadedAlbedo", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedAlbedoIntensity", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], LegacyPBRMaterial.prototype, "overloadedReflectivity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedReflectivityIntensity", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], LegacyPBRMaterial.prototype, "overloadedEmissive", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedEmissiveIntensity", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], LegacyPBRMaterial.prototype, "overloadedReflection", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedReflectionIntensity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedMicroSurface", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "overloadedMicroSurfaceIntensity", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "albedoTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "ambientTexture", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "ambientTextureStrength", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "opacityTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "reflectionTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "emissiveTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "reflectivityTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "metallicTexture", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "metallic", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "roughness", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "microSurfaceTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "bumpTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "lightmapTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], LegacyPBRMaterial.prototype, "refractionTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("ambient")
-    ], LegacyPBRMaterial.prototype, "ambientColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("albedo")
-    ], LegacyPBRMaterial.prototype, "albedoColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("reflectivity")
-    ], LegacyPBRMaterial.prototype, "reflectivityColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("reflection")
-    ], LegacyPBRMaterial.prototype, "reflectionColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("emissive")
-    ], LegacyPBRMaterial.prototype, "emissiveColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "microSurface", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "indexOfRefraction", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "invertRefractionY", void 0);
-    __decorate([
-        BABYLON.serializeAsFresnelParameters()
-    ], LegacyPBRMaterial.prototype, "opacityFresnelParameters", void 0);
-    __decorate([
-        BABYLON.serializeAsFresnelParameters()
-    ], LegacyPBRMaterial.prototype, "emissiveFresnelParameters", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "linkRefractionWithTransparency", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "linkEmissiveWithAlbedo", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useLightmapAsShadowmap", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useEmissiveAsIllumination", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useAlphaFromAlbedoTexture", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useSpecularOverAlpha", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useMicroSurfaceFromReflectivityMapAlpha", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useRoughnessFromMetallicTextureAlpha", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useRoughnessFromMetallicTextureGreen", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useMetallnessFromMetallicTextureBlue", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useAmbientOcclusionFromMetallicTextureRed", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useAmbientInGrayScale", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useAutoMicroSurfaceFromReflectivityMap", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useScalarInLinearSpace", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "usePhysicalLightFalloff", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useRadianceOverAlpha", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useParallax", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useParallaxOcclusion", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "parallaxScaleBias", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "invertNormalMapX", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "invertNormalMapY", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "twoSidedLighting", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], LegacyPBRMaterial.prototype, "useLogarithmicDepth", null);
     BABYLON.LegacyPBRMaterial = LegacyPBRMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -285,29 +285,29 @@ var BABYLON;
         NormalMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new NormalMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture")
+        ], NormalMaterial.prototype, "_diffuseTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], NormalMaterial.prototype, "diffuseTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], NormalMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], NormalMaterial.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], NormalMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], NormalMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], NormalMaterial.prototype, "maxSimultaneousLights", void 0);
         return NormalMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture")
-    ], NormalMaterial.prototype, "_diffuseTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], NormalMaterial.prototype, "diffuseTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], NormalMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], NormalMaterial.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], NormalMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], NormalMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], NormalMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.NormalMaterial = NormalMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -179,11 +179,11 @@ var BABYLON;
         ShadowOnlyMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new ShadowOnlyMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serialize()
+        ], ShadowOnlyMaterial.prototype, "_worldViewProjectionMatrix", void 0);
         return ShadowOnlyMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serialize()
-    ], ShadowOnlyMaterial.prototype, "_worldViewProjectionMatrix", void 0);
     BABYLON.ShadowOnlyMaterial = ShadowOnlyMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -252,29 +252,29 @@ var BABYLON;
         SimpleMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new SimpleMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture")
+        ], SimpleMaterial.prototype, "_diffuseTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], SimpleMaterial.prototype, "diffuseTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3("diffuseColor")
+        ], SimpleMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], SimpleMaterial.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], SimpleMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], SimpleMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], SimpleMaterial.prototype, "maxSimultaneousLights", void 0);
         return SimpleMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture")
-    ], SimpleMaterial.prototype, "_diffuseTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], SimpleMaterial.prototype, "diffuseTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3("diffuseColor")
-    ], SimpleMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], SimpleMaterial.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], SimpleMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], SimpleMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], SimpleMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.SimpleMaterial = SimpleMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -186,38 +186,38 @@ var BABYLON;
         SkyMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new SkyMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "luminance", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "turbidity", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "rayleigh", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "mieCoefficient", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "mieDirectionalG", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "distance", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "inclination", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "azimuth", void 0);
+        __decorate([
+            BABYLON.serializeAsVector3()
+        ], SkyMaterial.prototype, "sunPosition", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], SkyMaterial.prototype, "useSunPosition", void 0);
         return SkyMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "luminance", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "turbidity", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "rayleigh", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "mieCoefficient", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "mieDirectionalG", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "distance", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "inclination", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "azimuth", void 0);
-    __decorate([
-        BABYLON.serializeAsVector3()
-    ], SkyMaterial.prototype, "sunPosition", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], SkyMaterial.prototype, "useSunPosition", void 0);
     BABYLON.SkyMaterial = SkyMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -324,71 +324,71 @@ var BABYLON;
         TerrainMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new TerrainMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture("mixTexture")
+        ], TerrainMaterial.prototype, "_mixTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TerrainMaterial.prototype, "mixTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture1")
+        ], TerrainMaterial.prototype, "_diffuseTexture1", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TerrainMaterial.prototype, "diffuseTexture1", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture2")
+        ], TerrainMaterial.prototype, "_diffuseTexture2", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TerrainMaterial.prototype, "diffuseTexture2", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexture3")
+        ], TerrainMaterial.prototype, "_diffuseTexture3", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TerrainMaterial.prototype, "diffuseTexture3", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("bumpTexture1")
+        ], TerrainMaterial.prototype, "_bumpTexture1", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TerrainMaterial.prototype, "bumpTexture1", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("bumpTexture2")
+        ], TerrainMaterial.prototype, "_bumpTexture2", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TerrainMaterial.prototype, "bumpTexture2", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("bumpTexture3")
+        ], TerrainMaterial.prototype, "_bumpTexture3", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TerrainMaterial.prototype, "bumpTexture3", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], TerrainMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], TerrainMaterial.prototype, "specularColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], TerrainMaterial.prototype, "specularPower", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], TerrainMaterial.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], TerrainMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], TerrainMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], TerrainMaterial.prototype, "maxSimultaneousLights", void 0);
         return TerrainMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture("mixTexture")
-    ], TerrainMaterial.prototype, "_mixTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TerrainMaterial.prototype, "mixTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture1")
-    ], TerrainMaterial.prototype, "_diffuseTexture1", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TerrainMaterial.prototype, "diffuseTexture1", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture2")
-    ], TerrainMaterial.prototype, "_diffuseTexture2", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TerrainMaterial.prototype, "diffuseTexture2", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexture3")
-    ], TerrainMaterial.prototype, "_diffuseTexture3", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TerrainMaterial.prototype, "diffuseTexture3", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("bumpTexture1")
-    ], TerrainMaterial.prototype, "_bumpTexture1", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TerrainMaterial.prototype, "bumpTexture1", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("bumpTexture2")
-    ], TerrainMaterial.prototype, "_bumpTexture2", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TerrainMaterial.prototype, "bumpTexture2", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("bumpTexture3")
-    ], TerrainMaterial.prototype, "_bumpTexture3", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TerrainMaterial.prototype, "bumpTexture3", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], TerrainMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], TerrainMaterial.prototype, "specularColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], TerrainMaterial.prototype, "specularPower", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], TerrainMaterial.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], TerrainMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], TerrainMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], TerrainMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.TerrainMaterial = TerrainMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -319,71 +319,71 @@ var BABYLON;
         TriPlanarMaterial.Parse = function (source, scene, rootUrl) {
             return BABYLON.SerializationHelper.Parse(function () { return new TriPlanarMaterial(source.name, scene); }, source, scene, rootUrl);
         };
+        __decorate([
+            BABYLON.serializeAsTexture()
+        ], TriPlanarMaterial.prototype, "mixTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTextureX")
+        ], TriPlanarMaterial.prototype, "_diffuseTextureX", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TriPlanarMaterial.prototype, "diffuseTextureX", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTexturY")
+        ], TriPlanarMaterial.prototype, "_diffuseTextureY", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TriPlanarMaterial.prototype, "diffuseTextureY", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("diffuseTextureZ")
+        ], TriPlanarMaterial.prototype, "_diffuseTextureZ", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TriPlanarMaterial.prototype, "diffuseTextureZ", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("normalTextureX")
+        ], TriPlanarMaterial.prototype, "_normalTextureX", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TriPlanarMaterial.prototype, "normalTextureX", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("normalTextureY")
+        ], TriPlanarMaterial.prototype, "_normalTextureY", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TriPlanarMaterial.prototype, "normalTextureY", void 0);
+        __decorate([
+            BABYLON.serializeAsTexture("normalTextureZ")
+        ], TriPlanarMaterial.prototype, "_normalTextureZ", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], TriPlanarMaterial.prototype, "normalTextureZ", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], TriPlanarMaterial.prototype, "tileSize", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], TriPlanarMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], TriPlanarMaterial.prototype, "specularColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], TriPlanarMaterial.prototype, "specularPower", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], TriPlanarMaterial.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], TriPlanarMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], TriPlanarMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], TriPlanarMaterial.prototype, "maxSimultaneousLights", void 0);
         return TriPlanarMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture()
-    ], TriPlanarMaterial.prototype, "mixTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTextureX")
-    ], TriPlanarMaterial.prototype, "_diffuseTextureX", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TriPlanarMaterial.prototype, "diffuseTextureX", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTexturY")
-    ], TriPlanarMaterial.prototype, "_diffuseTextureY", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TriPlanarMaterial.prototype, "diffuseTextureY", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("diffuseTextureZ")
-    ], TriPlanarMaterial.prototype, "_diffuseTextureZ", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TriPlanarMaterial.prototype, "diffuseTextureZ", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("normalTextureX")
-    ], TriPlanarMaterial.prototype, "_normalTextureX", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TriPlanarMaterial.prototype, "normalTextureX", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("normalTextureY")
-    ], TriPlanarMaterial.prototype, "_normalTextureY", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TriPlanarMaterial.prototype, "normalTextureY", void 0);
-    __decorate([
-        BABYLON.serializeAsTexture("normalTextureZ")
-    ], TriPlanarMaterial.prototype, "_normalTextureZ", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], TriPlanarMaterial.prototype, "normalTextureZ", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], TriPlanarMaterial.prototype, "tileSize", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], TriPlanarMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], TriPlanarMaterial.prototype, "specularColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], TriPlanarMaterial.prototype, "specularPower", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], TriPlanarMaterial.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], TriPlanarMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], TriPlanarMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], TriPlanarMaterial.prototype, "maxSimultaneousLights", void 0);
     BABYLON.TriPlanarMaterial = TriPlanarMaterial;
 })(BABYLON || (BABYLON = {}));
 

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

@@ -66,6 +66,7 @@ declare module BABYLON {
         * @param {number}: Defines the waves speed
         */
         waveSpeed: number;
+        protected _renderTargets: SmartArray<RenderTargetTexture>;
         private _mesh;
         private _refractionRTT;
         private _reflectionRTT;

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

@@ -112,6 +112,7 @@ var BABYLON;
             * @param {number}: Defines the waves speed
             */
             _this.waveSpeed = 1.0;
+            _this._renderTargets = new BABYLON.SmartArray(16);
             /*
             * Private members
             */
@@ -119,8 +120,14 @@ var BABYLON;
             _this._reflectionTransform = BABYLON.Matrix.Zero();
             _this._lastTime = 0;
             _this._lastDeltaTime = 0;
-            // Create render targets
             _this._createRenderTargets(scene, renderTargetSize);
+            // Create render targets
+            _this.getRenderTargetTextures = function () {
+                _this._renderTargets.reset();
+                _this._renderTargets.push(_this._reflectionRTT);
+                _this._renderTargets.push(_this._refractionRTT);
+                return _this._renderTargets;
+            };
             return _this;
         }
         Object.defineProperty(WaterMaterial.prototype, "useLogarithmicDepth", {
@@ -382,11 +389,11 @@ var BABYLON;
             this._refractionRTT = new BABYLON.RenderTargetTexture(name + "_refraction", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
             this._refractionRTT.wrapU = BABYLON.Texture.MIRROR_ADDRESSMODE;
             this._refractionRTT.wrapV = BABYLON.Texture.MIRROR_ADDRESSMODE;
+            this._refractionRTT.ignoreCameraViewport = true;
             this._reflectionRTT = new BABYLON.RenderTargetTexture(name + "_reflection", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
             this._reflectionRTT.wrapU = BABYLON.Texture.MIRROR_ADDRESSMODE;
             this._reflectionRTT.wrapV = BABYLON.Texture.MIRROR_ADDRESSMODE;
-            scene.customRenderTargets.push(this._refractionRTT);
-            scene.customRenderTargets.push(this._reflectionRTT);
+            this._reflectionRTT.ignoreCameraViewport = true;
             var isVisible;
             var clipPlane = null;
             var savedViewMatrix;
@@ -405,7 +412,7 @@ var BABYLON;
                 if (_this._mesh) {
                     _this._mesh.isVisible = isVisible;
                 }
-                // Clip plane
+                // Clip plane 
                 scene.clipPlane = clipPlane;
             };
             this._reflectionRTT.onBeforeRender = function () {
@@ -509,86 +516,86 @@ var BABYLON;
             var mesh = BABYLON.Mesh.CreateGround(name, 512, 512, 32, scene, false);
             return mesh;
         };
+        __decorate([
+            BABYLON.serializeAsTexture("bumpTexture")
+        ], WaterMaterial.prototype, "_bumpTexture", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
+        ], WaterMaterial.prototype, "bumpTexture", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], WaterMaterial.prototype, "diffuseColor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], WaterMaterial.prototype, "specularColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "specularPower", void 0);
+        __decorate([
+            BABYLON.serialize("disableLighting")
+        ], WaterMaterial.prototype, "_disableLighting", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], WaterMaterial.prototype, "disableLighting", void 0);
+        __decorate([
+            BABYLON.serialize("maxSimultaneousLights")
+        ], WaterMaterial.prototype, "_maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
+        ], WaterMaterial.prototype, "maxSimultaneousLights", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "windForce", void 0);
+        __decorate([
+            BABYLON.serializeAsVector2()
+        ], WaterMaterial.prototype, "windDirection", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "waveHeight", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "bumpHeight", void 0);
+        __decorate([
+            BABYLON.serialize("bumpSuperimpose")
+        ], WaterMaterial.prototype, "_bumpSuperimpose", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
+        ], WaterMaterial.prototype, "bumpSuperimpose", void 0);
+        __decorate([
+            BABYLON.serialize("fresnelSeparate")
+        ], WaterMaterial.prototype, "_fresnelSeparate", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
+        ], WaterMaterial.prototype, "fresnelSeparate", void 0);
+        __decorate([
+            BABYLON.serialize("bumpAffectsReflection")
+        ], WaterMaterial.prototype, "_bumpAffectsReflection", void 0);
+        __decorate([
+            BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
+        ], WaterMaterial.prototype, "bumpAffectsReflection", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], WaterMaterial.prototype, "waterColor", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "colorBlendFactor", void 0);
+        __decorate([
+            BABYLON.serializeAsColor3()
+        ], WaterMaterial.prototype, "waterColor2", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "colorBlendFactor2", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "waveLength", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "waveSpeed", void 0);
+        __decorate([
+            BABYLON.serialize()
+        ], WaterMaterial.prototype, "useLogarithmicDepth", null);
         return WaterMaterial;
     }(BABYLON.PushMaterial));
-    __decorate([
-        BABYLON.serializeAsTexture("bumpTexture")
-    ], WaterMaterial.prototype, "_bumpTexture", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsTexturesDirty")
-    ], WaterMaterial.prototype, "bumpTexture", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], WaterMaterial.prototype, "diffuseColor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], WaterMaterial.prototype, "specularColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "specularPower", void 0);
-    __decorate([
-        BABYLON.serialize("disableLighting")
-    ], WaterMaterial.prototype, "_disableLighting", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], WaterMaterial.prototype, "disableLighting", void 0);
-    __decorate([
-        BABYLON.serialize("maxSimultaneousLights")
-    ], WaterMaterial.prototype, "_maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsLightsDirty")
-    ], WaterMaterial.prototype, "maxSimultaneousLights", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "windForce", void 0);
-    __decorate([
-        BABYLON.serializeAsVector2()
-    ], WaterMaterial.prototype, "windDirection", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "waveHeight", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "bumpHeight", void 0);
-    __decorate([
-        BABYLON.serialize("bumpSuperimpose")
-    ], WaterMaterial.prototype, "_bumpSuperimpose", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
-    ], WaterMaterial.prototype, "bumpSuperimpose", void 0);
-    __decorate([
-        BABYLON.serialize("fresnelSeparate")
-    ], WaterMaterial.prototype, "_fresnelSeparate", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
-    ], WaterMaterial.prototype, "fresnelSeparate", void 0);
-    __decorate([
-        BABYLON.serialize("bumpAffectsReflection")
-    ], WaterMaterial.prototype, "_bumpAffectsReflection", void 0);
-    __decorate([
-        BABYLON.expandToProperty("_markAllSubMeshesAsMiscDirty")
-    ], WaterMaterial.prototype, "bumpAffectsReflection", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], WaterMaterial.prototype, "waterColor", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "colorBlendFactor", void 0);
-    __decorate([
-        BABYLON.serializeAsColor3()
-    ], WaterMaterial.prototype, "waterColor2", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "colorBlendFactor2", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "waveLength", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "waveSpeed", void 0);
-    __decorate([
-        BABYLON.serialize()
-    ], WaterMaterial.prototype, "useLogarithmicDepth", null);
     BABYLON.WaterMaterial = WaterMaterial;
 })(BABYLON || (BABYLON = {}));
 

dist/preview release/postProcessesLibrary/babylon.asciiArtPostProcess.js

@@ -145,14 +145,14 @@ var BABYLON;
             var texture = BABYLON.SerializationHelper.Parse(function () { return new AsciiArtFontTexture(source.name, source.font, source.text, scene); }, source, scene, null);
             return texture;
         };
+        __decorate([
+            BABYLON.serialize("font")
+        ], AsciiArtFontTexture.prototype, "_font", void 0);
+        __decorate([
+            BABYLON.serialize("text")
+        ], AsciiArtFontTexture.prototype, "_text", void 0);
         return AsciiArtFontTexture;
     }(BABYLON.BaseTexture));
-    __decorate([
-        BABYLON.serialize("font")
-    ], AsciiArtFontTexture.prototype, "_font", void 0);
-    __decorate([
-        BABYLON.serialize("text")
-    ], AsciiArtFontTexture.prototype, "_text", void 0);
     BABYLON.AsciiArtFontTexture = AsciiArtFontTexture;
     /**
      * AsciiArtPostProcess helps rendering everithing in Ascii Art.

dist/preview release/postProcessesLibrary/babylon.digitalRainPostProcess.js

@@ -145,14 +145,14 @@ var BABYLON;
             var texture = BABYLON.SerializationHelper.Parse(function () { return new DigitalRainFontTexture(source.name, source.font, source.text, scene); }, source, scene, null);
             return texture;
         };
+        __decorate([
+            BABYLON.serialize("font")
+        ], DigitalRainFontTexture.prototype, "_font", void 0);
+        __decorate([
+            BABYLON.serialize("text")
+        ], DigitalRainFontTexture.prototype, "_text", void 0);
         return DigitalRainFontTexture;
     }(BABYLON.BaseTexture));
-    __decorate([
-        BABYLON.serialize("font")
-    ], DigitalRainFontTexture.prototype, "_font", void 0);
-    __decorate([
-        BABYLON.serialize("text")
-    ], DigitalRainFontTexture.prototype, "_text", void 0);
     BABYLON.DigitalRainFontTexture = DigitalRainFontTexture;
     /**
      * DigitalRainPostProcess helps rendering everithing in digital rain.

dist/preview release/what's new.md

@@ -5,6 +5,7 @@
 - Engine can now be initialized with an existing webgl context ([deltakosh](https://github.com/deltakosh))
 
 ## Updates
+- POW2 textures rescale is now done by shaders (It was done using canvas before) ([deltakosh](https://github.com/deltakosh))
 - Added `SceneLoader.CleanBoneMatrixWeights` to force the loader to normalize matrix weights when loading bones (off by default) ([deltakosh](https://github.com/deltakosh)) 
 - Added `camera.onViewMatrixChangedObservable` and `camera.onProjectionMatrixChangedObservable` ([deltakosh](https://github.com/deltakosh))
 - Added support for folders when drag'n'dropping into the sandbox ([deltakosh](https://github.com/deltakosh))

gui/src/advancedDynamicTexture.ts

@@ -261,7 +261,8 @@ module BABYLON.GUI {
         }
 
         private _doPicking(x: number, y: number, type: number): void {
-            var engine = this.getScene().getEngine();
+            var scene = this.getScene();
+            var engine = scene.getEngine();
             var textureSize = this.getSize();
 
             if (this._isFullscreen) {
@@ -295,8 +296,14 @@ module BABYLON.GUI {
                     return;
                 }
 
+                let camera = scene.activeCamera;
+                let engine = scene.getEngine();
+                let viewport = camera.viewport;
+                let x = (scene.pointerX - viewport.x * engine.getRenderWidth()) / viewport.width;
+                let y = (scene.pointerY - viewport.y * engine.getRenderHeight()) / viewport.height;
+
                 this._shouldBlockPointer = false;
-                this._doPicking(scene.pointerX, scene.pointerY, pi.type);
+                this._doPicking(x, y, pi.type);
 
                 pi.skipOnPointerObservable = this._shouldBlockPointer && pi.type !== BABYLON.PointerEventTypes.POINTERUP;
             });

materialsLibrary/src/water/babylon.waterMaterial.ts

@@ -133,6 +133,8 @@ module BABYLON {
         @serialize()
         public waveSpeed: number = 1.0;
 
+        protected _renderTargets = new SmartArray<RenderTargetTexture>(16);
+
 		/*
 		* Private members
 		*/
@@ -157,8 +159,17 @@ module BABYLON {
         constructor(name: string, scene: Scene, public renderTargetSize: Vector2 = new Vector2(512, 512)) {
             super(name, scene);
 
-            // Create render targets
             this._createRenderTargets(scene, renderTargetSize);
+
+            // Create render targets
+            this.getRenderTargetTextures = (): SmartArray<RenderTargetTexture> => {
+                this._renderTargets.reset();
+                this._renderTargets.push(this._reflectionRTT);
+                this._renderTargets.push(this._refractionRTT);
+
+                return this._renderTargets;
+            }
+
         }
 
         @serialize()
@@ -468,13 +479,12 @@ module BABYLON {
             this._refractionRTT = new RenderTargetTexture(name + "_refraction", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
             this._refractionRTT.wrapU = BABYLON.Texture.MIRROR_ADDRESSMODE;
             this._refractionRTT.wrapV = BABYLON.Texture.MIRROR_ADDRESSMODE;
+            this._refractionRTT.ignoreCameraViewport = true;
 
             this._reflectionRTT = new RenderTargetTexture(name + "_reflection", { width: renderTargetSize.x, height: renderTargetSize.y }, scene, false, true);
             this._reflectionRTT.wrapU = BABYLON.Texture.MIRROR_ADDRESSMODE;
             this._reflectionRTT.wrapV = BABYLON.Texture.MIRROR_ADDRESSMODE;
-
-            scene.customRenderTargets.push(this._refractionRTT);
-            scene.customRenderTargets.push(this._reflectionRTT);
+            this._reflectionRTT.ignoreCameraViewport = true;
 
             var isVisible: boolean;
             var clipPlane = null;
@@ -498,7 +508,7 @@ module BABYLON {
                     this._mesh.isVisible = isVisible;
                 }
 
-                // Clip plane
+                // Clip plane 
                 scene.clipPlane = clipPlane;
             };
 
@@ -616,7 +626,7 @@ module BABYLON {
 
         public getClassName(): string {
             return "WaterMaterial";
-        }        
+        }
 
         // Statics
         public static Parse(source: any, scene: Scene, rootUrl: string): WaterMaterial {

src/Bones/babylon.bone.ts

@@ -249,7 +249,7 @@ module BABYLON {
          * @param space The space that the translation is in.
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          */
-        public translate (vec: Vector3, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        public translate(vec: Vector3, space = Space.LOCAL, mesh?: AbstractMesh): void {
 
             var lm = this.getLocalMatrix();
 
@@ -302,7 +302,7 @@ module BABYLON {
          * @param space The space that the position is in.
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          */
-        public setPosition (position: Vector3, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        public setPosition(position: Vector3, space = Space.LOCAL, mesh?: AbstractMesh): void {
 
             var lm = this.getLocalMatrix();
 
@@ -364,7 +364,7 @@ module BABYLON {
          * @param z The scale of the bone on the z axis.
          * @param scaleChildren Set this to true if children of the bone should be scaled.
          */
-        public setScale (x: number, y: number, z: number, scaleChildren = false): void {
+        public setScale(x: number, y: number, z: number, scaleChildren = false): void {
 
             if (this.animations[0] && !this.animations[0].isStopped()) {
                 if (!scaleChildren) {
@@ -386,7 +386,7 @@ module BABYLON {
          * @param z The amount to scale the bone on the z axis.
          * @param scaleChildren Set this to true if children of the bone should be scaled.
          */
-        public scale (x: number, y: number, z: number, scaleChildren = false): void {
+        public scale(x: number, y: number, z: number, scaleChildren = false): void {
 	
             var locMat = this.getLocalMatrix();
             var origLocMat = Bone._tmpMats[0];
@@ -449,7 +449,7 @@ module BABYLON {
          * @param space The space that the axes of rotation are in.
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          */
-        public setYawPitchRoll (yaw: number, pitch: number, roll: number, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        public setYawPitchRoll(yaw: number, pitch: number, roll: number, space = Space.LOCAL, mesh?: AbstractMesh): void {
 	
             var rotMat = Bone._tmpMats[0];
             Matrix.RotationYawPitchRollToRef(yaw, pitch, roll, rotMat);
@@ -471,7 +471,7 @@ module BABYLON {
          * @param space The space that the axis is in.
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          */
-        public rotate (axis: Vector3, amount: number, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        public rotate(axis: Vector3, amount: number, space = Space.LOCAL, mesh?: AbstractMesh): void {
             
             var rmat = Bone._tmpMats[0];
             rmat.m[12] = 0;
@@ -491,7 +491,7 @@ module BABYLON {
          * @param space The space that the axis is in.
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          */
-        public setAxisAngle (axis: Vector3, angle: number, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        public setAxisAngle(axis: Vector3, angle: number, space = Space.LOCAL, mesh?: AbstractMesh): void {
 
             var rotMat = Bone._tmpMats[0];
             Matrix.RotationAxisToRef(axis, angle, rotMat);
@@ -510,7 +510,7 @@ module BABYLON {
          * @param space The space that the rotation is in.
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          */
-        public setRotation (rotation: Vector3, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        public setRotation(rotation: Vector3, space = Space.LOCAL, mesh?: AbstractMesh): void {
             
             this.setYawPitchRoll(rotation.y, rotation.x, rotation.z, space, mesh);
 
@@ -522,7 +522,7 @@ module BABYLON {
          * @param space The space that the rotation is in.
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          */
-        public setRotationQuaternion (quat: Quaternion, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        public setRotationQuaternion(quat: Quaternion, space = Space.LOCAL, mesh?: AbstractMesh): void {
 
             var rotMatInv = Bone._tmpMats[0];
 
@@ -543,7 +543,7 @@ module BABYLON {
          * @param space The space that the rotation is in.
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          */
-        public setRotationMatrix (rotMat: Matrix, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        public setRotationMatrix(rotMat: Matrix, space = Space.LOCAL, mesh?: AbstractMesh): void {
 
             var rotMatInv = Bone._tmpMats[0];
             
@@ -558,7 +558,7 @@ module BABYLON {
 
         }
 
-        private _rotateWithMatrix (rmat: Matrix, space = Space.LOCAL, mesh?: AbstractMesh): void {
+        private _rotateWithMatrix(rmat: Matrix, space = Space.LOCAL, mesh?: AbstractMesh): void {
 
             var lmat = this.getLocalMatrix();
             var lx = lmat.m[12];
@@ -670,7 +670,7 @@ module BABYLON {
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          * @returns The position of the bone
          */
-        public getPosition (space = Space.LOCAL, mesh?: AbstractMesh): Vector3 {
+        public getPosition(space = Space.LOCAL, mesh?: AbstractMesh): Vector3 {
 
             var pos = Vector3.Zero();
 
@@ -686,7 +686,7 @@ module BABYLON {
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          * @param result The vector3 to copy the position to.
          */
-        public getPositionToRef (space = Space.LOCAL, mesh: AbstractMesh, result: Vector3): void {
+        public getPositionToRef(space = Space.LOCAL, mesh: AbstractMesh, result: Vector3): void {
 
             if(space == Space.LOCAL){
 
@@ -729,7 +729,7 @@ module BABYLON {
          * @param mesh The mesh that this bone is attached to.
          * @returns The absolute position of the bone
          */
-        public getAbsolutePosition (mesh?: AbstractMesh): Vector3 {
+        public getAbsolutePosition(mesh?: AbstractMesh): Vector3 {
 
             var pos = Vector3.Zero();
 
@@ -744,7 +744,7 @@ module BABYLON {
          * @param mesh The mesh that this bone is attached to.
          * @param result The vector3 to copy the absolute position to.
          */
-        public getAbsolutePositionToRef (mesh: AbstractMesh, result: Vector3) {
+        public getAbsolutePositionToRef(mesh: AbstractMesh, result: Vector3) {
 
             this.getPositionToRef(Space.WORLD, mesh, result);
 
@@ -753,7 +753,7 @@ module BABYLON {
         /**
          * Compute the absolute transforms of this bone and its children.
          */
-        public computeAbsoluteTransforms (): void {
+        public computeAbsoluteTransforms(): void {
 
             if (this._parent) {
                 this._localMatrix.multiplyToRef(this._parent._absoluteTransform, this._absoluteTransform);
@@ -808,7 +808,7 @@ module BABYLON {
          * @param mesh The mesh that this bone is attached to.
          * @returns The world direction
          */
-        public getDirection (localAxis: Vector3, mesh?: AbstractMesh): Vector3{
+        public getDirection(localAxis: Vector3, mesh?: AbstractMesh): Vector3{
 
             var result = Vector3.Zero();
 
@@ -824,7 +824,7 @@ module BABYLON {
          * @param mesh The mesh that this bone is attached to.
          * @param result The vector3 that the world direction will be copied to.
          */
-        public getDirectionToRef (localAxis: Vector3, mesh: AbstractMesh, result: Vector3): void {
+        public getDirectionToRef(localAxis: Vector3, mesh: AbstractMesh, result: Vector3): void {
 
             var wm:Matrix;
 
@@ -903,7 +903,7 @@ module BABYLON {
          * @param mesh The mesh that this bone is attached to.  This is only used in world space.
          * @param result The quaternion that the rotation should be copied to.
          */
-        public getRotationQuaternionToRef( space = Space.LOCAL, mesh: AbstractMesh, result: Quaternion): void{
+        public getRotationQuaternionToRef(space = Space.LOCAL, mesh: AbstractMesh, result: Quaternion): void{
 
             if(space == Space.LOCAL){
 

src/Materials/Textures/Procedurals/babylon.proceduralTexture.ts

@@ -291,7 +291,7 @@
 
             if (this.isCube) {
                 for (var face = 0; face < 6; face++) {
-                    engine.bindFramebuffer(this._texture, face);
+                    engine.bindFramebuffer(this._texture, face, undefined, undefined, true);
 
                     // VBOs
                     engine.bindBuffers(this._vertexBuffers, this._indexBuffer, this._effect);
@@ -310,7 +310,7 @@
                     }
                 }
             } else {
-                engine.bindFramebuffer(this._texture);
+                engine.bindFramebuffer(this._texture, 0, undefined, undefined, true);
 
                 // VBOs
                 engine.bindBuffers(this._vertexBuffers, this._indexBuffer, this._effect);

src/Materials/Textures/babylon.renderTargetTexture.ts

@@ -40,7 +40,8 @@
         public activeCamera: Camera;
         public customRenderFunction: (opaqueSubMeshes: SmartArray<SubMesh>, transparentSubMeshes: SmartArray<SubMesh>, alphaTestSubMeshes: SmartArray<SubMesh>, beforeTransparents?: () => void) => void;
         public useCameraPostProcesses: boolean;
-        
+        public ignoreCameraViewport: boolean = false;
+
         private _postProcessManager: PostProcessManager;
         private _postProcesses: PostProcess[];
 
@@ -50,7 +51,7 @@
         * An event triggered when the texture is unbind.
         * @type {BABYLON.Observable}
         */
-        public onBeforeBindObservable = new Observable<RenderTargetTexture>();        
+        public onBeforeBindObservable = new Observable<RenderTargetTexture>();
 
         /**
         * An event triggered when the texture is unbind.
@@ -170,7 +171,7 @@
             if (this._samples === value) {
                 return;
             }
-            
+
             this._samples = this.getScene().getEngine().updateRenderTargetTextureSampleCount(this._texture, value);
         }
 
@@ -320,7 +321,7 @@
                 return;
             }
 
-            this.onBeforeBindObservable.notifyObservers(this);            
+            this.onBeforeBindObservable.notifyObservers(this);
 
             // Set custom projection.
             // Needs to be before binding to prevent changing the aspect ratio.
@@ -329,8 +330,7 @@
                 camera = this.activeCamera;
                 engine.setViewport(this.activeCamera.viewport, this._size, this._size);
 
-                if (this.activeCamera !== scene.activeCamera)
-                {
+                if (this.activeCamera !== scene.activeCamera) {
                     scene.setTransformMatrix(this.activeCamera.getViewMatrix(), this.activeCamera.getProjectionMatrix(true));
                 }
             }
@@ -356,7 +356,7 @@
                     }
 
                     mesh._preActivateForIntermediateRendering(sceneRenderId);
-                    
+
                     let isMasked;
                     if (!this.renderList) {
                         isMasked = ((mesh.layerMask & camera.layerMask) === 0);
@@ -377,17 +377,17 @@
             }
 
             for (var particleIndex = 0; particleIndex < scene.particleSystems.length; particleIndex++) {
-                    var particleSystem = scene.particleSystems[particleIndex];
+                var particleSystem = scene.particleSystems[particleIndex];
 
-                    let emitter: any = particleSystem.emitter;
-                    if (!particleSystem.isStarted() || !emitter || !emitter.position || !emitter.isEnabled()) {
-                        continue;
-                    }
+                let emitter: any = particleSystem.emitter;
+                if (!particleSystem.isStarted() || !emitter || !emitter.position || !emitter.isEnabled()) {
+                    continue;
+                }
 
-                    if (currentRenderList.indexOf(emitter) >= 0) {
-                        this._renderingManager.dispatchParticles(particleSystem);
-                    }
+                if (currentRenderList.indexOf(emitter) >= 0) {
+                    this._renderingManager.dispatchParticles(particleSystem);
                 }
+            }
 
             if (this.isCube) {
                 for (var face = 0; face < 6; face++) {
@@ -409,7 +409,7 @@
             scene.resetCachedMaterial();
         }
 
-        private renderToTarget(faceIndex: number, currentRenderList: AbstractMesh[], currentRenderListLength:number, useCameraPostProcess: boolean, dumpForDebug: boolean): void {
+        private renderToTarget(faceIndex: number, currentRenderList: AbstractMesh[], currentRenderListLength: number, useCameraPostProcess: boolean, dumpForDebug: boolean): void {
             var scene = this.getScene();
             var engine = scene.getEngine();
 
@@ -418,11 +418,7 @@
                 this._postProcessManager._prepareFrame(this._texture, this._postProcesses);
             }
             else if (!useCameraPostProcess || !scene.postProcessManager._prepareFrame(this._texture)) {
-                if (this.isCube) {
-                    engine.bindFramebuffer(this._texture, faceIndex);
-                } else {
-                    engine.bindFramebuffer(this._texture);
-                }
+                engine.bindFramebuffer(this._texture, this.isCube ? faceIndex : undefined, undefined, undefined, this.ignoreCameraViewport);
             }
 
             this.onBeforeRenderObservable.notifyObservers(faceIndex);
@@ -467,7 +463,7 @@
                 }
 
                 engine.unBindFramebuffer(this._texture, this.isCube, () => {
-                    this.onAfterRenderObservable.notifyObservers(faceIndex);    
+                    this.onAfterRenderObservable.notifyObservers(faceIndex);
                 });
             } else {
                 this.onAfterRenderObservable.notifyObservers(faceIndex);
@@ -487,7 +483,7 @@
             opaqueSortCompareFn: (a: SubMesh, b: SubMesh) => number = null,
             alphaTestSortCompareFn: (a: SubMesh, b: SubMesh) => number = null,
             transparentSortCompareFn: (a: SubMesh, b: SubMesh) => number = null): void {
-            
+
             this._renderingManager.setRenderingOrder(renderingGroupId,
                 opaqueSortCompareFn,
                 alphaTestSortCompareFn,
@@ -500,7 +496,7 @@
          * @param renderingGroupId The rendering group id corresponding to its index
          * @param autoClearDepthStencil Automatically clears depth and stencil between groups if true.
          */
-        public setRenderingAutoClearDepthStencil(renderingGroupId: number, autoClearDepthStencil: boolean): void {            
+        public setRenderingAutoClearDepthStencil(renderingGroupId: number, autoClearDepthStencil: boolean): void {
             this._renderingManager.setRenderingAutoClearDepthStencil(renderingGroupId, autoClearDepthStencil);
         }
 

src/Materials/babylon.effect.ts

@@ -254,8 +254,7 @@
                 return;
             }
             
-            var observer = this.onCompileObservable.add((effect) => {
-                this.onCompileObservable.remove(observer);
+            this.onCompileObservable.add((effect) => {
                 func(effect);
             });
         }
@@ -534,6 +533,7 @@
                     this.onCompiled(this);
                 }
                 this.onCompileObservable.notifyObservers(this);
+                this.onCompileObservable.clear();
             } catch (e) {
                 this._compilationError = e.message;
 

src/Rendering/babylon.boundingBoxRenderer.ts

@@ -27,7 +27,7 @@
 
 
             var engine = this._scene.getEngine();
-            var boxdata = VertexData.CreateBox(1.0);
+            var boxdata = VertexData.CreateBox({size: 1.0});
             this._vertexBuffers[VertexBuffer.PositionKind] = new VertexBuffer(engine, boxdata.positions, VertexBuffer.PositionKind, false);
             this._indexBuffer = engine.createIndexBuffer([0, 1, 1, 2, 2, 3, 3, 0, 4, 5, 5, 6, 6, 7, 7, 4, 0, 7, 1, 6, 2, 5, 3, 4]);
         }

src/babylon.engine.ts

@@ -103,48 +103,7 @@
             mag: magFilter
         }
     }
-
-    var prepareWebGLTexture = (texture: WebGLTexture, gl: WebGLRenderingContext, scene: Scene, width: number, height: number, invertY: boolean, noMipmap: boolean, isCompressed: boolean,
-        processFunction: (width: number, height: number) => void, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE) => {
-        var engine = scene.getEngine();
-        if (!engine) {
-            return;
-        }
-
-        var potWidth = engine.needPOTTextures ? Tools.GetExponentOfTwo(width, engine.getCaps().maxTextureSize) : width;
-        var potHeight = engine.needPOTTextures ? Tools.GetExponentOfTwo(height, engine.getCaps().maxTextureSize) : height;
-
-        engine._bindTextureDirectly(gl.TEXTURE_2D, texture);
-        gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, invertY === undefined ? 1 : (invertY ? 1 : 0));
-
-        texture._baseWidth = width;
-        texture._baseHeight = height;
-        texture._width = potWidth;
-        texture._height = potHeight;
-        texture.isReady = true;
-
-        processFunction(potWidth, potHeight);
-
-        var filters = getSamplingParameters(samplingMode, !noMipmap, gl);
-
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filters.mag);
-        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filters.min);
-
-        if (!noMipmap && !isCompressed) {
-            gl.generateMipmap(gl.TEXTURE_2D);
-        }
-
-        engine._bindTextureDirectly(gl.TEXTURE_2D, null);
-
-        engine.resetTextureCache();
-        scene._removePendingData(texture);
-
-        texture.onLoadedCallbacks.forEach(callback => {
-            callback();
-        });
-        texture.onLoadedCallbacks = [];
-    };
-
+  
     var partialLoad = (url: string, index: number, loadedImages: any, scene,
         onfinish: (images: HTMLImageElement[]) => void, onErrorCallBack: () => void = null) => {
 
@@ -668,6 +627,7 @@
 
         private _workingCanvas: HTMLCanvasElement;
         private _workingContext: CanvasRenderingContext2D;
+        private _rescalePostProcess: PassPostProcess;
 
         private _dummyFramebuffer: WebGLFramebuffer;
 
@@ -2610,8 +2570,9 @@
                     callback = (data) => {
                         var ktx = new Internals.KhronosTextureContainer(data, 1);
 
-                        prepareWebGLTexture(texture, this._gl, scene, ktx.pixelWidth, ktx.pixelHeight, invertY, false, true, () => {
+                        this._prepareWebGLTexture(texture, scene, ktx.pixelWidth, ktx.pixelHeight, invertY, false, true, () => {
                             ktx.uploadLevels(this._gl, !noMipmap);
+                            return false;
                         }, samplingMode);
                     };
                 } else if (isTGA) {
@@ -2620,8 +2581,9 @@
 
                         var header = Internals.TGATools.GetTGAHeader(data);
 
-                        prepareWebGLTexture(texture, this._gl, scene, header.width, header.height, invertY, noMipmap, false, () => {
+                        this._prepareWebGLTexture(texture, scene, header.width, header.height, invertY, noMipmap, false, () => {
                             Internals.TGATools.UploadContent(this._gl, data);
+                            return false;
                         }, samplingMode);
                     };
 
@@ -2630,8 +2592,9 @@
                         var info = Internals.DDSTools.GetDDSInfo(data);
 
                         var loadMipmap = (info.isRGB || info.isLuminance || info.mipmapCount > 1) && !noMipmap && ((info.width >> (info.mipmapCount - 1)) === 1);
-                        prepareWebGLTexture(texture, this._gl, scene, info.width, info.height, invertY, !loadMipmap, info.isFourCC, () => {
+                        this._prepareWebGLTexture(texture, scene, info.width, info.height, invertY, !loadMipmap, info.isFourCC, () => {
                             Internals.DDSTools.UploadDDSLevels(this, data, info, loadMipmap, 1);
+                            return false;
                         }, samplingMode);
                     };
                 }
@@ -2646,34 +2609,34 @@
                 // image format processing
             } else {
                 var onload = (img) => {
-                    prepareWebGLTexture(texture, this._gl, scene, img.width, img.height, invertY, noMipmap, false, (potWidth, potHeight) => {
+                    this._prepareWebGLTexture(texture, scene, img.width, img.height, invertY, noMipmap, false, (potWidth, potHeight, continuationCallback) => {
+                        let gl = this._gl;
                         var isPot = (img.width === potWidth && img.height === potHeight);
-                        if (!isPot) {
-                            this._prepareWorkingCanvas();
-                            this._workingCanvas.width = potWidth;
-                            this._workingCanvas.height = potHeight;
-
-                            if (samplingMode === Texture.NEAREST_SAMPLINGMODE) {
-                                this._workingContext.imageSmoothingEnabled = false;
-                                this._workingContext.mozImageSmoothingEnabled = false;
-                                this._workingContext.oImageSmoothingEnabled = false;
-                                this._workingContext.webkitImageSmoothingEnabled = false;
-                                this._workingContext.msImageSmoothingEnabled = false;
-                            }
-
-                            this._workingContext.drawImage(img, 0, 0, img.width, img.height, 0, 0, potWidth, potHeight);
+                        let internalFormat = format ? this._getInternalFormat(format) : ((extension === ".jpg") ? gl.RGB : gl.RGBA);
 
-                            if (samplingMode === Texture.NEAREST_SAMPLINGMODE) {
-                                this._workingContext.imageSmoothingEnabled = true;
-                                this._workingContext.mozImageSmoothingEnabled = true;
-                                this._workingContext.oImageSmoothingEnabled = true;
-                                this._workingContext.webkitImageSmoothingEnabled = true;
-                                this._workingContext.msImageSmoothingEnabled = true;
-                            }
+                        if (isPot) {
+                            gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, internalFormat, gl.UNSIGNED_BYTE, img);
+                            return false;
                         }
 
-                        let internalFormat = format ? this._getInternalFormat(format) : ((extension === ".jpg") ? this._gl.RGB : this._gl.RGBA);
-                        this._gl.texImage2D(this._gl.TEXTURE_2D, 0, internalFormat, internalFormat, this._gl.UNSIGNED_BYTE, isPot ? img : this._workingCanvas);
+                        // Using shaders to rescale because canvas.drawImage is lossy
+                        let source = gl.createTexture();
+                        this._bindTextureDirectly(gl.TEXTURE_2D, source);
+                        gl.texImage2D(gl.TEXTURE_2D, 0, internalFormat, internalFormat, gl.UNSIGNED_BYTE, img);
+
+                        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, gl.LINEAR);
+                        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, gl.LINEAR);
+                        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_S, gl.CLAMP_TO_EDGE);
+                        gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_WRAP_T, gl.CLAMP_TO_EDGE);                        
+
+                        this._rescaleTexture(source, texture, scene, internalFormat, () => {
+                            this._releaseTexture(source);
+                            this._bindTextureDirectly(gl.TEXTURE_2D, texture);
+
+                            continuationCallback();
+                        });
+
+                        return true;
                     }, samplingMode);
                 };
 
@@ -2688,6 +2651,41 @@
             return texture;
         }
 
+        private _rescaleTexture(source: WebGLTexture, destination: WebGLTexture, scene: Scene, internalFormat: number, onComplete: () => void): void {
+            let rtt = this.createRenderTargetTexture({
+                    width: destination._width,
+                    height: destination._height,
+                }, {
+                    generateMipMaps: false,
+                    type: Engine.TEXTURETYPE_UNSIGNED_INT,
+                    samplingMode: Texture.BILINEAR_SAMPLINGMODE,
+                    generateDepthBuffer: false,
+                    generateStencilBuffer: false
+                }
+            );
+
+            if (!this._rescalePostProcess) {
+                this._rescalePostProcess = new BABYLON.PassPostProcess("rescale", 1, null, Texture.BILINEAR_SAMPLINGMODE, this, false, Engine.TEXTURETYPE_UNSIGNED_INT);
+            }
+			this._rescalePostProcess.getEffect().executeWhenCompiled(() => {
+                this._rescalePostProcess.onApply = function (effect) {
+                    effect._bindTexture("textureSampler", source);
+                }
+
+                scene.postProcessManager.directRender([this._rescalePostProcess], rtt);
+
+                this._bindTextureDirectly(this._gl.TEXTURE_2D, destination);
+                this._gl.copyTexImage2D(this._gl.TEXTURE_2D, 0, internalFormat, 0, 0, destination._width, destination._height, 0);
+
+                this.unBindFramebuffer(rtt);
+                this._releaseTexture(rtt);
+                
+                if (onComplete) {
+                    onComplete();
+                }
+            });
+        }
+
         private _getInternalFormat(format: number): number {
             var internalFormat = this._gl.RGBA;
             switch (format) {
@@ -3681,6 +3679,53 @@
             return texture;
         };
 
+        private _prepareWebGLTextureContinuation(texture: WebGLTexture, scene: Scene, noMipmap: boolean, isCompressed: boolean, samplingMode: number): void {
+            var gl = this._gl;
+            var filters = getSamplingParameters(samplingMode, !noMipmap, gl);
+
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MAG_FILTER, filters.mag);
+            gl.texParameteri(gl.TEXTURE_2D, gl.TEXTURE_MIN_FILTER, filters.min);
+
+            if (!noMipmap && !isCompressed) {
+                gl.generateMipmap(gl.TEXTURE_2D);
+            }
+
+            this._bindTextureDirectly(gl.TEXTURE_2D, null);
+
+            this.resetTextureCache();
+            scene._removePendingData(texture);
+
+            texture.onLoadedCallbacks.forEach(callback => {
+                callback();
+            });
+            texture.onLoadedCallbacks = [];
+        }
+
+        private _prepareWebGLTexture(texture: WebGLTexture, scene: Scene, width: number, height: number, invertY: boolean, noMipmap: boolean, isCompressed: boolean,
+                                        processFunction: (width: number, height: number, continuationCallback: () => void) => boolean, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE): void {
+            var potWidth = this.needPOTTextures ? Tools.GetExponentOfTwo(width, this.getCaps().maxTextureSize) : width;
+            var potHeight = this.needPOTTextures ? Tools.GetExponentOfTwo(height, this.getCaps().maxTextureSize) : height;
+
+            var gl = this._gl;
+            this._bindTextureDirectly(gl.TEXTURE_2D, texture);
+            gl.pixelStorei(gl.UNPACK_FLIP_Y_WEBGL, invertY === undefined ? 1 : (invertY ? 1 : 0));
+
+            texture._baseWidth = width;
+            texture._baseHeight = height;
+            texture._width = potWidth;
+            texture._height = potHeight;
+            texture.isReady = true;
+
+            if (processFunction(potWidth, potHeight, () => {
+                this._prepareWebGLTextureContinuation(texture, scene, noMipmap, isCompressed, samplingMode);
+            })) {
+                // Returning as texture needs extra async steps
+                return;
+            }         
+
+            this._prepareWebGLTextureContinuation(texture, scene, noMipmap, isCompressed, samplingMode);
+        }
+
         private _convertRGBtoRGBATextureData(rgbData: ArrayBufferView, width: number, height: number, textureType: number): ArrayBufferView {
             // Create new RGBA data container.
             var rgbaData: ArrayBufferView;
@@ -3845,7 +3890,6 @@
                 return;
             }
 
-
             var internalTexture = texture.isReady() ? texture.getInternalTexture() :
                 (texture.isCube ? this.emptyCubeTexture : this.emptyTexture);
 
@@ -4072,6 +4116,11 @@
                 this._emptyCubeTexture = null;
             }
 
+            // Rescale PP
+            if (this._rescalePostProcess) {
+                this._rescalePostProcess.dispose();
+            }
+
             // Release scenes
             while (this.scenes.length) {
                 this.scenes[0].dispose();

src/babylon.scene.ts

@@ -247,6 +247,7 @@
         public constantlyUpdateMeshUnderPointer = false;
 
         public hoverCursor = "pointer";
+        public defaultCursor: string = "";
 
         // Metadata
         public metadata: any = null;
@@ -726,6 +727,9 @@
         private _audioEnabled = true;
         private _headphone = false;
 
+        // VR Helper
+        public VRHelper: VRExperienceHelper;
+
         //Simplification Queue
         public simplificationQueue: SimplificationQueue;
 
@@ -1045,11 +1049,6 @@
 
             this._unTranslatedPointerX = this._pointerX;
             this._unTranslatedPointerY = this._pointerY;
-
-            if (this.cameraToUseForPointers) {
-                this._pointerX = this._pointerX - this.cameraToUseForPointers.viewport.x * this._engine.getRenderWidth();
-                this._pointerY = this._pointerY - this.cameraToUseForPointers.viewport.y * this._engine.getRenderHeight();
-            }
         }
 
         private _createUbo(): void {
@@ -1242,7 +1241,7 @@
                             canvas.style.cursor = this.hoverCursor;
                         }
                     } else {
-                        canvas.style.cursor = "";
+                        canvas.style.cursor = this.defaultCursor;
                     }
                 } else {
                     this.setPointerOverMesh(null);
@@ -1259,7 +1258,7 @@
                     } else {
                         this.setPointerOverSprite(null);
                         // Restore pointer
-                        canvas.style.cursor = "";
+                        canvas.style.cursor = this.defaultCursor;
                     }
                 }
 
@@ -3379,6 +3378,11 @@
                 this.disposeSounds();
             }
 
+            // VR Helper
+            if (this.VRHelper) {
+                this.VRHelper.dispose();
+            }
+
             // Detach cameras
             var canvas = this._engine.getRenderingCanvas();
             var index;
@@ -3890,9 +3894,8 @@
             return hdrSkybox;
         }
 
-        public createDefaultVRExperience(): VRExperienceHelper {
-            var vrHelper = new BABYLON.VRExperienceHelper(this, null);
-            return vrHelper;
+        public createDefaultVRExperience() {
+            this.VRHelper = new BABYLON.VRExperienceHelper(this, null);
         }
 
         // Tags