преди 7 години · ae0dc14d80
--- a/Playground/babylon.d.txt
+++ b/Playground/babylon.d.txt
--- a/Playground/frame.css
+++ b/Playground/frame.css
@@ -8,6 +8,11 @@
 
				     touch-action: none;

			
 
				 }

			
 
				 

			
 
				+canvas {

			
 
				+    border:none !important;

			
 
				+    outline:none !important;

			
 
				+}

			
 
				+

			
 
				 #fpsLabel {

			
 
				     position: absolute;

			
 
				     right: 10px;

			
--- a/Playground/frame.html
+++ b/Playground/frame.html
@@ -24,9 +24,12 @@
 
				     <meta name="theme-color" content="#ffffff">

			
 
				 

			
 
				     <script src="https://code.jquery.com/pep/0.4.2/pep.min.js"></script>

			
 
				+    

			
 
				+    <script src="https://cdnjs.cloudflare.com/ajax/libs/dat-gui/0.6.2/dat.gui.min.js"></script>

			
 
				     <!-- Babylon.js -->

			
 
				     <script src="https://preview.babylonjs.com/cannon.js"></script>

			
 
				     <script src="https://preview.babylonjs.com/Oimo.js"></script>

			
 
				+    <script src="https://preview.babylonjs.com/earcut.min.js"></script>

			
 
				     <script src="https://preview.babylonjs.com/babylon.js"></script>

			
 
				     <script src="https://preview.babylonjs.com/inspector/babylon.inspector.bundle.js"></script>

			
 
				 

			
--- a/Playground/js/index.js
+++ b/Playground/js/index.js
--- a/Playground/textures/Flare2.png
+++ b/Playground/textures/Flare2.png
--- a/Playground/textures/Space/space_back.jpg
+++ b/Playground/textures/Space/space_back.jpg
--- a/Playground/textures/Space/space_down.jpg
+++ b/Playground/textures/Space/space_down.jpg
--- a/Playground/textures/Space/space_front.jpg
+++ b/Playground/textures/Space/space_front.jpg
--- a/Playground/textures/Space/space_left.jpg
+++ b/Playground/textures/Space/space_left.jpg
--- a/Playground/textures/Space/space_right.jpg
+++ b/Playground/textures/Space/space_right.jpg
--- a/Playground/textures/Space/space_up.jpg
+++ b/Playground/textures/Space/space_up.jpg
--- a/Playground/textures/flare3.png
+++ b/Playground/textures/flare3.png
--- a/Playground/textures/wood.jpg
+++ b/Playground/textures/wood.jpg
--- a/Tools/Gulp/config.json
+++ b/Tools/Gulp/config.json
@@ -1764,7 +1764,7 @@
 
				                 "name": "babylonjs-viewer",
			
 
				                 "main": "../../Viewer/src/index.d.ts",
			
 
				                 "out": "../../dist/preview release/viewer/babylon.viewer.module.d.ts",
			
 
				-                "prependText": "/// <reference path=\"./babylon.d.ts\"/>\n/// <reference path=\"./babylon.glTF2Interface.d.ts\"/>\n/// <reference path=\"./babylonjs.loaders.d.ts\"/>\n"
			
 
				+                "prependText": "/// <reference path=\"./babylon.d.ts\"/>\n/// <reference path=\"./babylon.glTF2Interface.d.ts\"/>\n/// <reference path=\"./babylonjs.loaders.d.ts\"/>\ndeclare module \"babylonjs-loaders\"{ export=BABYLON;}\n"
			
 
				             },
			
 
				             "outputs": [
			
 
				                 {
			
--- a/Viewer/assets/templates/default/loadingScreen.html
+++ b/Viewer/assets/templates/default/loadingScreen.html
@@ -10,9 +10,9 @@
 
				         display: flex;

			
 
				         justify-content: center;

			
 
				         align-items: center;

			
 
				-        -webkit-transition: opacity 2s ease;

			
 
				-        -moz-transition: opacity 2s ease;

			
 
				-        transition: opacity 2s ease;

			
 
				+        -webkit-transition: opacity 1s ease;

			
 
				+        -moz-transition: opacity 1s ease;

			
 
				+        transition: opacity 1s ease;

			
 
				     }

			
 
				 

			
 
				     img.loading-image {

			
--- a/Viewer/dist/_headers
+++ b/Viewer/dist/_headers
@@ -0,0 +1,2 @@
 
				+/*
			
 
				+	Access-Control-Allow-Origin: *
			
--- a/Viewer/dist/assets/environment/Skybox_2.0-256.dds
+++ b/Viewer/dist/assets/environment/Skybox_2.0-256.dds
--- a/Viewer/dist/ufoExample.html
+++ b/Viewer/dist/ufoExample.html
@@ -20,8 +20,10 @@
 
				     <body>

			
 
				         <babylon extends="default, shadowDirectionalLight, environmentMap" templates.nav-bar.params.hide-animations="true" templates.nav-bar.params.disable-on-fullscreen="true">

			
 
				             <scene glow="true">

			
 
				-                <main-color r="0.5" g="0.2" b="0.2"></main-color>

			
 
				             </scene>

			
 
				+            <lab>

			
 
				+                <environment-main-color r="0.5" g="0.2" b="0.2"></environment-main-color>

			
 
				+            </lab>

			
 
				             <model url="https://models.babylonjs.com/ufo.glb">

			
 
				                 <animation auto-start="true"></animation>

			
 
				             </model>

			
--- a/Viewer/src/configuration/configuration.ts
+++ b/Viewer/src/configuration/configuration.ts
@@ -1,5 +1,19 @@
 
				 import { ITemplateConfiguration } from './../templateManager';

			
 
				-import { EngineOptions, IGlowLayerOptions } from 'babylonjs';

			
 
				+import { EngineOptions, IGlowLayerOptions, DepthOfFieldEffectBlurLevel } from 'babylonjs';

			
 
				+

			
 
				+export function getConfigurationKey(key: string, configObject: any) {

			
 
				+    let splits = key.split('.');

			
 
				+

			
 
				+    if (splits.length === 0 || !configObject) return false;

			
 
				+    else if (splits.length === 1) {

			
 
				+        if (configObject[key] !== undefined) {

			
 
				+            return configObject[key];

			
 
				+        }

			
 
				+    } else {

			
 
				+        let firstKey = splits.shift();

			
 
				+        return getConfigurationKey(splits.join("."), configObject[firstKey!])

			
 
				+    }

			
 
				+}

			
 
				 

			
 
				 export interface ViewerConfiguration {

			
 
				 

			
@@ -32,6 +46,7 @@ export interface ViewerConfiguration {
 
				     lights?: { [name: string]: boolean | ILightConfiguration },

			
 
				     // engine configuration. optional!

			
 
				     engine?: {

			
 
				+        renderInBackground?: boolean;

			
 
				         antialiasing?: boolean;

			
 
				         disableResize?: boolean;

			
 
				         engineOptions?: EngineOptions;

			
@@ -73,7 +88,8 @@ export interface ViewerConfiguration {
 
				             specular?: { r: number, g: number, b: number };

			
 
				         }

			
 
				         hideLoadingDelay?: number;

			
 
				-        environmentAssetsRootURL?: string;

			
 
				+        assetsRootURL?: string;

			
 
				+        environmentMainColor?: { r: number, g: number, b: number };

			
 
				         environmentMap?: {

			
 
				             /**

			
 
				              * Environment map texture path in relative to the asset folder.

			
@@ -90,30 +106,67 @@ export interface ViewerConfiguration {
 
				              */

			
 
				             tintLevel: number;

			
 
				         }

			
 
				-        renderingPipelines?: {

			
 
				-            default?: boolean | {

			
 
				-                [propName: string]: any;

			
 
				-            };

			
 
				-            standard?: boolean | {

			
 
				-                [propName: string]: any;

			
 
				-            };

			
 
				-            /*lens?: boolean | {

			
 
				-                [propName: string]: boolean | string | number | undefined;

			
 
				-            };*/

			
 
				-            ssao?: boolean | {

			
 
				-                [propName: string]: any;

			
 
				-            };

			
 
				-            ssao2?: boolean | {

			
 
				-                [propName: string]: any;

			
 
				-            };

			
 
				-        }

			
 
				+        defaultRenderingPipelines?: boolean | IDefaultRenderingPipelineConfiguration;

			
 
				     }

			
 
				 }

			
 
				 

			
 
				+/**

			
 
				+ * Defines an animation to be applied to a model (translation, scale or rotation).

			
 
				+ */

			
 
				+export interface IModelAnimationConfiguration {

			
 
				+    /**

			
 
				+     * Time of animation, in seconds

			
 
				+     */

			
 
				+    time?: number;

			
 
				+

			
 
				+    /**

			
 
				+     * Scale to apply

			
 
				+     */

			
 
				+    scaling?: {

			
 
				+        x: number;

			
 
				+        y: number;

			
 
				+        z: number;

			
 
				+    };

			
 
				+

			
 
				+    /**

			
 
				+     * Easing function to apply

			
 
				+     * See SPECTRE.EasingFunction

			
 
				+     */

			
 
				+    easingFunction?: number;

			
 
				+

			
 
				+    /**

			
 
				+     * An Easing mode to apply to the easing function

			
 
				+     * See BABYLON.EasingFunction

			
 
				+     */

			
 
				+    easingMode?: number;

			
 
				+}

			
 
				+

			
 
				+

			
 
				+export interface IDefaultRenderingPipelineConfiguration {

			
 
				+    sharpenEnabled?: boolean;

			
 
				+    bloomEnabled?: boolean;

			
 
				+    bloomThreshold?: number;

			
 
				+    depthOfFieldEnabled?: boolean;

			
 
				+    depthOfFieldBlurLevel?: DepthOfFieldEffectBlurLevel;

			
 
				+    fxaaEnabled?: boolean;

			
 
				+    imageProcessingEnabled?: boolean;

			
 
				+    defaultPipelineTextureType?: number;

			
 
				+    bloomScale?: number;

			
 
				+    chromaticAberrationEnabled?: boolean;

			
 
				+    grainEnabled?: boolean;

			
 
				+    bloomKernel?: number;

			
 
				+    hardwareScaleLevel?: number;

			
 
				+    bloomWeight?: number;

			
 
				+    bllomThreshold?: number;

			
 
				+    hdr?: boolean;

			
 
				+    samples?: number;

			
 
				+}

			
 
				+

			
 
				 export interface IModelConfiguration {

			
 
				     id?: string;

			
 
				     url?: string;

			
 
				     root?: string; //optional

			
 
				+    file?: string; // is a file being loaded? root and url ignored

			
 
				     loader?: string; // obj, gltf?

			
 
				     position?: { x: number, y: number, z: number };

			
 
				     rotation?: { x: number, y: number, z: number, w?: number };

			
@@ -137,6 +190,9 @@ export interface IModelConfiguration {
 
				         playOnce?: boolean;

			
 
				     }

			
 
				 

			
 
				+    entryAnimation?: IModelAnimationConfiguration;

			
 
				+    exitAnimation?: IModelAnimationConfiguration;

			
 
				+

			
 
				     material?: {

			
 
				         directEnabled?: boolean;

			
 
				         directIntensity?: number;

			
@@ -358,6 +414,7 @@ export interface ISceneOptimizerConfiguration {
 
				         renderTarget?: ISceneOptimizerParameters;

			
 
				         mergeMeshes?: ISceneOptimizerParameters;

			
 
				     }

			
 
				+    custom?: string;

			
 
				 }

			
 
				 

			
 
				 export interface IObserversConfiguration {

			
--- a/Viewer/src/configuration/types/default.ts
+++ b/Viewer/src/configuration/types/default.ts
@@ -65,13 +65,17 @@ export let defaultConfiguration: ViewerConfiguration = {
 
				     },

			
 
				     camera: {

			
 
				         behaviors: {

			
 
				-            autoRotate: 0,

			
 
				+            autoRotate: {

			
 
				+                type: 0

			
 
				+            },

			
 
				             framing: {

			
 
				                 type: 2,

			
 
				                 zoomOnBoundingInfo: true,

			
 
				                 zoomStopsAnimation: false

			
 
				             },

			
 
				-            bouncing: 1

			
 
				+            bouncing: {

			
 
				+                type: 1

			
 
				+            }

			
 
				         },

			
 
				         wheelPrecision: 200,

			
 
				     },

			
@@ -80,9 +84,9 @@ export let defaultConfiguration: ViewerConfiguration = {
 
				             url: 'https://playground.babylonjs.com/textures/environment.dds',

			
 
				             gammaSpace: false

			
 
				         },*/

			
 
				-        pbr: true,

			
 
				+        /*pbr: true,

			
 
				         blur: 0.7,

			
 
				-        infiniteDistance: false,

			
 
				+        infiniteDistance: false,*/

			
 
				         /*material: {

			
 
				             imageProcessingConfiguration: {

			
 
				                 colorCurves: {

			
@@ -108,10 +112,10 @@ export let defaultConfiguration: ViewerConfiguration = {
 
				         antialiasing: true

			
 
				     },

			
 
				     scene: {

			
 
				-        imageProcessingConfiguration: {

			
 
				+        /*imageProcessingConfiguration: {

			
 
				             exposure: 1.4,

			
 
				             contrast: 1.66,

			
 
				             toneMappingEnabled: true

			
 
				-        }

			
 
				+        }*/

			
 
				     }

			
 
				 }
			
--- a/Viewer/src/configuration/types/environmentMap.ts
+++ b/Viewer/src/configuration/types/environmentMap.ts
@@ -2,7 +2,7 @@ import { ViewerConfiguration } from './../configuration';
 
				 

			
 
				 export const environmentMapConfiguration: ViewerConfiguration = {

			
 
				     lab: {

			
 
				-        environmentAssetsRootURL: '/assets/environment/',

			
 
				+        assetsRootURL: '/assets/environment/',

			
 
				         environmentMap: {

			
 
				             texture: 'EnvMap_2.0-256.env',

			
 
				             rotationY: 0,

			
--- a/Viewer/src/configuration/types/extended.ts
+++ b/Viewer/src/configuration/types/extended.ts
@@ -1,61 +1,257 @@
 
				 import { ViewerConfiguration } from './../configuration';

			
 
				+import { Tools } from 'babylonjs';

			
 
				 

			
 
				 export let extendedConfiguration: ViewerConfiguration = {

			
 
				     version: "3.2.0",

			
 
				     extends: "default",

			
 
				     camera: {

			
 
				+        exposure: 3.034578,

			
 
				+        fov: 0.7853981633974483,

			
 
				+        contrast: 1.6,

			
 
				+        toneMappingEnabled: true,

			
 
				+        upperBetaLimit: 1.3962634015954636 + Math.PI / 2,

			
 
				+        lowerBetaLimit: -1.4835298641951802 + Math.PI / 2,

			
 
				+        behaviors: {

			
 
				+            framing: {

			
 
				+                type: 2,

			
 
				+                mode: 0,

			
 
				+                positionScale: 0.5,

			
 
				+                defaultElevation: 0.2617993877991494,

			
 
				+                elevationReturnWaitTime: 3000,

			
 
				+                elevationReturnTime: 2000,

			
 
				+                framingTime: 500,

			
 
				+                zoomStopsAnimation: false,

			
 
				+                radiusScale: 0.866

			
 
				+            },

			
 
				+            autoRotate: {

			
 
				+                type: 0,

			
 
				+                idleRotationWaitTime: 4000,

			
 
				+                idleRotationSpeed: 0.17453292519943295,

			
 
				+                idleRotationSpinupTime: 2500,

			
 
				+                zoomStopsAnimation: false

			
 
				+            },

			
 
				+            bouncing: {

			
 
				+                type: 1,

			
 
				+                lowerRadiusTransitionRange: 0.05,

			
 
				+                upperRadiusTransitionRange: -0.2

			
 
				+            }

			
 
				+        },

			
 
				+        upperRadiusLimit: 5,

			
 
				+        lowerRadiusLimit: 0.5,

			
 
				+        frameOnModelLoad: true,

			
 
				+        framingElevation: 0.2617993877991494,

			
 
				+        framingRotation: 1.5707963267948966,

			
 
				         radius: 2,

			
 
				-        alpha: -1.5708,

			
 
				+        alpha: 1.5708,

			
 
				         beta: Math.PI * 0.5 - 0.2618,

			
 
				         wheelPrecision: 300,

			
 
				         minZ: 0.1,

			
 
				         maxZ: 50,

			
 
				+        fovMode: 0,

			
 
				+        pinchPrecision: 1500,

			
 
				+        panningSensibility: 3000

			
 
				     },

			
 
				     lights: {

			
 
				-        "light1": {

			
 
				+        light0: {

			
 
				             type: 0,

			
 
				-            shadowEnabled: false,

			
 
				-            position: { x: -1.78, y: 2.298, z: 2.62 },

			
 
				-            diffuse: { r: 0.8, g: 0.8, b: 0.8 },

			
 
				-            intensity: 3,

			
 
				+            frustumEdgeFalloff: 0,

			
 
				+            intensity: 7,

			
 
				             intensityMode: 0,

			
 
				-            radius: 3.135,

			
 
				+            radius: 0.6,

			
 
				+            range: 0.6,

			
 
				+            spotAngle: 60,

			
 
				+            diffuse: {

			
 
				+                r: 1,

			
 
				+                g: 1,

			
 
				+                b: 1

			
 
				+            },

			
 
				+            position: {

			
 
				+                x: -2,

			
 
				+                y: 2.5,

			
 
				+                z: 2

			
 
				+            },

			
 
				+            target: {

			
 
				+                x: 0,

			
 
				+                y: 0,

			
 
				+                z: 0

			
 
				+            },

			
 
				+            enabled: true,

			
 
				+            shadowEnabled: true,

			
 
				+            shadowBufferSize: 512,

			
 
				+            shadowMinZ: 1,

			
 
				+            shadowMaxZ: 10,

			
 
				+            shadowFieldOfView: 60,

			
 
				+            shadowFrustumSize: 2,

			
 
				+            shadowConfig: {

			
 
				+                useBlurCloseExponentialShadowMap: true,

			
 
				+                useKernelBlur: true,

			
 
				+                blurScale: 1.0,

			
 
				+                bias: 0.001,

			
 
				+                depthScale: 50 * (10 - 1),

			
 
				+                frustumEdgeFalloff: 0

			
 
				+            }

			
 
				         },

			
 
				-        "light3": {

			
 
				-            type: 2,

			
 
				+        light1: {

			
 
				+            type: 0,

			
 
				+            frustumEdgeFalloff: 0,

			
 
				+            intensity: 7,

			
 
				+            intensityMode: 0,

			
 
				+            radius: 0.4,

			
 
				+            range: 0.4,

			
 
				+            spotAngle: 57,

			
 
				+            diffuse: {

			
 
				+                r: 1,

			
 
				+                g: 1,

			
 
				+                b: 1

			
 
				+            },

			
 
				+            position: {

			
 
				+                x: 4,

			
 
				+                y: 3,

			
 
				+                z: -0.5

			
 
				+            },

			
 
				+            target: {

			
 
				+                x: 0,

			
 
				+                y: 0,

			
 
				+                z: 0

			
 
				+            },

			
 
				+            enabled: true,

			
 
				             shadowEnabled: false,

			
 
				-            position: { x: -4, y: 2, z: -2.23 },

			
 
				-            diffuse: { r: 0.718, g: 0.772, b: 0.749 },

			
 
				-            intensity: 2.052,

			
 
				+            shadowBufferSize: 512,

			
 
				+            shadowMinZ: 0.2,

			
 
				+            shadowMaxZ: 10,

			
 
				+            shadowFieldOfView: 28,

			
 
				+            shadowFrustumSize: 2

			
 
				+        },

			
 
				+        light2: {

			
 
				+            type: 0,

			
 
				+            frustumEdgeFalloff: 0,

			
 
				+            intensity: 1,

			
 
				             intensityMode: 0,

			
 
				             radius: 0.5,

			
 
				-            spotAngle: 42.85

			
 
				+            range: 0.5,

			
 
				+            spotAngle: 42.85,

			
 
				+            diffuse: {

			
 
				+                r: 0.8,

			
 
				+                g: 0.8,

			
 
				+                b: 0.8

			
 
				+            },

			
 
				+            position: {

			
 
				+                x: -1,

			
 
				+                y: 3,

			
 
				+                z: -3

			
 
				+            },

			
 
				+            target: {

			
 
				+                x: 0,

			
 
				+                y: 0,

			
 
				+                z: 0

			
 
				+            },

			
 
				+            enabled: true,

			
 
				+            shadowEnabled: false,

			
 
				+            shadowBufferSize: 512,

			
 
				+            shadowMinZ: 0.2,

			
 
				+            shadowMaxZ: 10,

			
 
				+            shadowFieldOfView: 45,

			
 
				+            shadowFrustumSize: 2

			
 
				         }

			
 
				     },

			
 
				     ground: {

			
 
				-        receiveShadows: true

			
 
				+        shadowLevel: 0.9,

			
 
				+        texture: "Ground_2.0-1024.png",

			
 
				+        material: {

			
 
				+            primaryColorHighlightLevel: 0.035,

			
 
				+            primaryColorShadowLevel: 0,

			
 
				+            enableNoise: true,

			
 
				+            useRGBColor: false,

			
 
				+            maxSimultaneousLights: 1,

			
 
				+            diffuseTexture: {

			
 
				+                gammaSpace: true

			
 
				+            }

			
 
				+        },

			
 
				+        opacity: 1,

			
 
				+        mirror: false,

			
 
				+        receiveShadows: true,

			
 
				+        size: 5

			
 
				+    },

			
 
				+    skybox: {

			
 
				+        scale: 11,

			
 
				+        cubeTexture: {

			
 
				+            url: "Skybox_2.0-256.dds"

			
 
				+        },

			
 
				+        material: {

			
 
				+            primaryColorHighlightLevel: 0.03,

			
 
				+            primaryColorShadowLevel: 0.03,

			
 
				+            enableNoise: true,

			
 
				+            useRGBColor: false,

			
 
				+            reflectionTexture: {

			
 
				+                gammaSpace: true

			
 
				+            }

			
 
				+        }

			
 
				+    },

			
 
				+    engine: {

			
 
				+        renderInBackground: true

			
 
				     },

			
 
				     scene: {

			
 
				+        flags: {

			
 
				+            shadowsEnabled: true,

			
 
				+            particlesEnabled: false,

			
 
				+            collisionsEnabled: false,

			
 
				+            lightsEnabled: true,

			
 
				+            texturesEnabled: true,

			
 
				+            lensFlaresEnabled: false,

			
 
				+            proceduralTexturesEnabled: false,

			
 
				+            renderTargetsEnabled: true,

			
 
				+            spritesEnabled: false,

			
 
				+            skeletonsEnabled: true,

			
 
				+            audioEnabled: false,

			
 
				+        },

			
 
				+        defaultMaterial: {

			
 
				+            materialType: 'pbr',

			
 
				+            reflectivityColor: {

			
 
				+                r: 0.1,

			
 
				+                g: 0.1,

			
 
				+                b: 0.1

			
 
				+            },

			
 
				+            microSurface: 0.6

			
 
				+        },

			
 
				+        clearColor: {

			
 
				+            r: 0.9,

			
 
				+            g: 0.9,

			
 
				+            b: 0.9,

			
 
				+            a: 1.0

			
 
				+        },

			
 
				         imageProcessingConfiguration: {

			
 
				+            vignetteCentreX: 0,

			
 
				+            vignetteCentreY: 0,

			
 
				+            vignetteColor: {

			
 
				+                r: 0.086,

			
 
				+                g: 0.184,

			
 
				+                b: 0.259,

			
 
				+                a: 1

			
 
				+            },

			
 
				+            vignetteWeight: 0.855,

			
 
				+            vignetteStretch: 0.5,

			
 
				+            vignetteBlendMode: 0,

			
 
				+            vignetteCameraFov: 0.7853981633974483,

			
 
				+            isEnabled: true,

			
 
				             colorCurves: {

			
 
				-                shadowsHue: 43.359,

			
 
				-                shadowsDensity: 1,

			
 
				-                shadowsSaturation: -25,

			
 
				-                shadowsExposure: -3.0,

			
 
				-                midtonesHue: 93.65,

			
 
				-                midtonesDensity: -15.24,

			
 
				-                midtonesExposure: 7.37,

			
 
				-                midtonesSaturation: -15,

			
 
				-                highlightsHue: 37.2,

			
 
				-                highlightsDensity: -22.43,

			
 
				-                highlightsExposure: 45.0,

			
 
				-                highlightsSaturation: -15

			
 
				+                shadowsHue: 0,

			
 
				+                shadowsDensity: 0,

			
 
				+                shadowsSaturation: 0,

			
 
				+                shadowsExposure: 0,

			
 
				+                midtonesHue: 0,

			
 
				+                midtonesDensity: 0,

			
 
				+                midtonesExposure: 0,

			
 
				+                midtonesSaturation: 0,

			
 
				+                highlightsHue: 0,

			
 
				+                highlightsDensity: 0,

			
 
				+                highlightsExposure: 0,

			
 
				+                highlightsSaturation: 0

			
 
				             }

			
 
				         },

			
 
				         mainColor: {

			
 
				-            r: 0.7,

			
 
				-            g: 0.7,

			
 
				-            b: 0.7

			
 
				+            r: 0.8823529411764706,

			
 
				+            g: 0.8823529411764706,

			
 
				+            b: 0.8823529411764706

			
 
				         }

			
 
				     },

			
 
				     loaderPlugins: {

			
@@ -67,27 +263,52 @@ export let extendedConfiguration: ViewerConfiguration = {
 
				     model: {

			
 
				         rotationOffsetAxis: {

			
 
				             x: 0,

			
 
				-            y: 1,

			
 
				+            y: -1,

			
 
				             z: 0

			
 
				         },

			
 
				-        rotationOffsetAngle: 3.66519,

			
 
				+        rotationOffsetAngle: Tools.ToRadians(210),

			
 
				         material: {

			
 
				             directEnabled: true,

			
 
				             directIntensity: 0.884,

			
 
				             emissiveIntensity: 1.04,

			
 
				-            environmentIntensity: 0.868

			
 
				+            environmentIntensity: 0.6

			
 
				+        },

			
 
				+        entryAnimation: {

			
 
				+            scaling: {

			
 
				+                x: 0,

			
 
				+                y: 0,

			
 
				+                z: 0

			
 
				+            },

			
 
				+            time: 0.5,

			
 
				+            easingFunction: 4,

			
 
				+            easingMode: 1

			
 
				+        },

			
 
				+        exitAnimation: {

			
 
				+            scaling: {

			
 
				+                x: 0,

			
 
				+                y: 0,

			
 
				+                z: 0

			
 
				+            },

			
 
				+            time: 0.5,

			
 
				+            easingFunction: 4,

			
 
				+            easingMode: 1

			
 
				         },

			
 
				         normalize: true,

			
 
				         castShadow: true,

			
 
				         receiveShadows: true

			
 
				     },

			
 
				     lab: {

			
 
				-        renderingPipelines: {

			
 
				-            default: {

			
 
				-                bloomEnabled: true,

			
 
				-                bloomThreshold: 1.0,

			
 
				-                fxaaEnabled: true

			
 
				-            }

			
 
				+        assetsRootURL: '/assets/environment/',

			
 
				+        environmentMap: {

			
 
				+            texture: "EnvMap_2.0-256.env",

			
 
				+            rotationY: 3,

			
 
				+            tintLevel: 0.4

			
 
				+        },

			
 
				+        defaultRenderingPipelines: {

			
 
				+            bloomEnabled: true,

			
 
				+            bloomThreshold: 1.0,

			
 
				+            fxaaEnabled: true,

			
 
				+            bloomWeight: 0.05

			
 
				         }

			
 
				     }

			
 
				 }
			
--- a/Viewer/src/index.ts
+++ b/Viewer/src/index.ts
@@ -42,5 +42,7 @@ function disposeAll() {
 
				 

			
 
				 const Version = BABYLON.Engine.Version;

			
 
				 

			
 
				+console.log("Babylon.js viewer (v" + Version + ")");

			
 
				+

			
 
				 // public API for initialization

			
 
				 export { BABYLON, Version, InitTags, DefaultViewer, AbstractViewer, viewerGlobals, telemetryManager, disableInit, viewerManager, mapperManager, disposeAll, ModelLoader, ViewerModel, AnimationPlayMode, AnimationState, ModelState, ILoaderPlugin };

			
--- a/Viewer/src/labs/viewerLabs.ts
+++ b/Viewer/src/labs/viewerLabs.ts
@@ -9,7 +9,7 @@ export class ViewerLabs {
 
				 

			
 
				     constructor(private _sceneManager: SceneManager) { }

			
 
				 

			
 
				-    public environmentAssetsRootURL: string;

			
 
				+    public assetsRootURL: string;

			
 
				     public environment: PBREnvironment = {

			
 
				         //irradiance

			
 
				         irradiancePolynomialCoefficients: {

			
@@ -57,7 +57,7 @@ export class ViewerLabs {
 
				             this.environment = EnvironmentDeserializer.Parse(data);

			
 
				             if (onSuccess) onSuccess(this.environment);

			
 
				         } else if (typeof data === 'string') {

			
 
				-            let url = this.getEnvironmentAssetUrl(data);

			
 
				+            let url = this.getAssetUrl(data);

			
 
				             this._sceneManager.scene._loadFile(

			
 
				                 url,

			
 
				                 (arrayBuffer: ArrayBuffer) => {

			
@@ -124,15 +124,15 @@ export class ViewerLabs {
 
				      * @param url Asset url

			
 
				      * @returns The Asset url using the `environmentAssetsRootURL` if the url is not an absolute path.

			
 
				      */

			
 
				-    public getEnvironmentAssetUrl(url: string): string {

			
 
				+    public getAssetUrl(url: string): string {

			
 
				         let returnUrl = url;

			
 
				         if (url && url.toLowerCase().indexOf("//") === -1) {

			
 
				-            if (!this.environmentAssetsRootURL) {

			
 
				-                Tools.Warn("Please, specify the root url of your assets before loading the configuration (labs.environmentAssetsRootURL) or disable the background through the viewer options.");

			
 
				+            if (!this.assetsRootURL) {

			
 
				+                // Tools.Warn("Please, specify the root url of your assets before loading the configuration (labs.environmentAssetsRootURL) or disable the background through the viewer options.");

			
 
				                 return url;

			
 
				             }

			
 
				 

			
 
				-            returnUrl = this.environmentAssetsRootURL + returnUrl;

			
 
				+            returnUrl = this.assetsRootURL + returnUrl;

			
 
				         }

			
 
				 

			
 
				         return returnUrl;

			
--- a/Viewer/src/loader/modelLoader.ts
+++ b/Viewer/src/loader/modelLoader.ts
@@ -63,8 +63,18 @@ export class ModelLoader {
 
				             return model;

			
 
				         }

			
 
				 

			
 
				-        let filename = Tools.GetFilename(modelConfiguration.url) || modelConfiguration.url;

			
 
				-        let base = modelConfiguration.root || Tools.GetFolderPath(modelConfiguration.url);

			
 
				+        let base: string;

			
 
				+        let filename: any;

			
 
				+        if (modelConfiguration.file) {

			
 
				+            base = "file:";

			
 
				+            filename = modelConfiguration.file;

			
 
				+        }

			
 
				+        else {

			
 
				+            filename = Tools.GetFilename(modelConfiguration.url) || modelConfiguration.url;

			
 
				+            base = modelConfiguration.root || Tools.GetFolderPath(modelConfiguration.url);

			
 
				+        }

			
 
				+

			
 
				+

			
 
				         let plugin = modelConfiguration.loader;

			
 
				 

			
 
				         model.loader = SceneLoader.ImportMesh(undefined, base, filename, this._viewer.sceneManager.scene, (meshes, particleSystems, skeletons, animationGroups) => {

			
@@ -80,7 +90,9 @@ export class ModelLoader {
 
				             }

			
 
				 

			
 
				             this._checkAndRun("onLoaded", model);

			
 
				-            model.onLoadedObservable.notifyObserversWithPromise(model);

			
 
				+            this._viewer.sceneManager.scene.executeWhenReady(() => {

			
 
				+                model.onLoadedObservable.notifyObservers(model);

			
 
				+            });

			
 
				         }, (progressEvent) => {

			
 
				             this._checkAndRun("onProgress", progressEvent);

			
 
				             model.onLoadProgressObservable.notifyObserversWithPromise(progressEvent);

			
@@ -95,6 +107,12 @@ export class ModelLoader {
 
				             let gltfLoader = (<GLTFFileLoader>model.loader);

			
 
				             gltfLoader.animationStartMode = GLTFLoaderAnimationStartMode.NONE;

			
 
				             gltfLoader.compileMaterials = true;

			
 
				+

			
 
				+            if (!modelConfiguration.file) {

			
 
				+                gltfLoader.rewriteRootURL = (rootURL, responseURL) => {

			
 
				+                    return modelConfiguration.root || Tools.GetFolderPath(responseURL || modelConfiguration.url || '');

			
 
				+                };

			
 
				+            }

			
 
				             // if ground is set to "mirror":

			
 
				             if (this._viewer.configuration.ground && typeof this._viewer.configuration.ground === 'object' && this._viewer.configuration.ground.mirror) {

			
 
				                 gltfLoader.useClipPlane = true;

			
@@ -109,7 +127,13 @@ export class ModelLoader {
 
				                 if (data && data.json && data.json['asset']) {

			
 
				                     model.loadInfo = data.json['asset'];

			
 
				                 }

			
 
				-            })

			
 
				+            });

			
 
				+

			
 
				+            gltfLoader.onCompleteObservable.add(() => {

			
 
				+                model.loaderDone = true;

			
 
				+            });

			
 
				+        } else {

			
 
				+            model.loaderDone = true;

			
 
				         }

			
 
				 

			
 
				         this._checkAndRun("onInit", model.loader, model);

			
--- a/Viewer/src/loader/plugins/extendedMaterialLoaderPlugin.ts
+++ b/Viewer/src/loader/plugins/extendedMaterialLoaderPlugin.ts
@@ -5,8 +5,6 @@ import { Color3, Texture, BaseTexture, Tools, ISceneLoaderPlugin, ISceneLoaderPl
 
				 

			
 
				 export class ExtendedMaterialLoaderPlugin implements ILoaderPlugin {

			
 
				 

			
 
				-    private _model: ViewerModel;

			
 
				-

			
 
				     public onMaterialLoaded(baseMaterial: Material) {

			
 
				         var material = baseMaterial as PBRMaterial;

			
 
				         material.alphaMode = Engine.ALPHA_PREMULTIPLIED_PORTERDUFF;

			
--- a/Viewer/src/loader/plugins/minecraftLoaderPlugin.ts
+++ b/Viewer/src/loader/plugins/minecraftLoaderPlugin.ts
@@ -16,7 +16,7 @@ export class MinecraftLoaderPlugin implements ILoaderPlugin {
 
				         this._minecraftEnabled = false;

			
 
				     }

			
 
				 

			
 
				-    public inParsed(data: IGLTFLoaderData) {

			
 
				+    public onParsed(data: IGLTFLoaderData) {

			
 
				         if (data && data.json && data.json['meshes'] && data.json['meshes'].length) {

			
 
				             var meshes = data.json['meshes'] as GLTF2.IMesh[];

			
 
				             for (var i = 0; i < meshes.length; i++) {

			
--- a/Viewer/src/model/modelAnimation.ts
+++ b/Viewer/src/model/modelAnimation.ts
@@ -1,9 +1,9 @@
 
				-import { AnimationGroup, Animatable, Skeleton } from "babylonjs";

			
 
				+import { AnimationGroup, Animatable, Skeleton, Vector3 } from "babylonjs";

			
 
				 

			
 
				 /**

			
 
				  * Animation play mode enum - is the animation looping or playing once

			
 
				  */

			
 
				-export enum AnimationPlayMode {

			
 
				+export const enum AnimationPlayMode {

			
 
				     ONCE,

			
 
				     LOOP

			
 
				 }

			
@@ -11,7 +11,7 @@ export enum AnimationPlayMode {
 
				 /**

			
 
				  * An enum representing the current state of an animation object

			
 
				  */

			
 
				-export enum AnimationState {

			
 
				+export const enum AnimationState {

			
 
				     INIT,

			
 
				     PLAYING,

			
 
				     PAUSED,

			
@@ -20,6 +20,51 @@ export enum AnimationState {
 
				 }

			
 
				 

			
 
				 /**

			
 
				+ * The different type of easing functions available 

			
 
				+ */

			
 
				+export const enum EasingFunction {

			
 
				+    Linear = 0,

			
 
				+    CircleEase = 1,

			
 
				+    BackEase = 2,

			
 
				+    BounceEase = 3,

			
 
				+    CubicEase = 4,

			
 
				+    ElasticEase = 5,

			
 
				+    ExponentialEase = 6,

			
 
				+    PowerEase = 7,

			
 
				+    QuadraticEase = 8,

			
 
				+    QuarticEase = 9,

			
 
				+    QuinticEase = 10,

			
 
				+    SineEase = 11

			
 
				+}

			
 
				+

			
 
				+/**

			
 
				+ * Defines a simple animation to be applied to a model (scale).

			
 
				+ */

			
 
				+export interface ModelAnimationConfiguration {

			
 
				+    /**

			
 
				+     * Time of animation, in seconds

			
 
				+     */

			
 
				+    time: number;

			
 
				+

			
 
				+    /**

			
 
				+     * Scale to apply

			
 
				+     */

			
 
				+    scaling?: Vector3;

			
 
				+

			
 
				+    /**

			
 
				+     * Easing function to apply

			
 
				+     * See SPECTRE.EasingFunction

			
 
				+     */

			
 
				+    easingFunction?: number;

			
 
				+

			
 
				+    /**

			
 
				+     * An Easing mode to apply to the easing function

			
 
				+     * See BABYLON.EasingFunction

			
 
				+     */

			
 
				+    easingMode?: number;

			
 
				+}

			
 
				+

			
 
				+/**

			
 
				  * This interface can be implemented to define new types of ModelAnimation objects.

			
 
				  */

			
 
				 export interface IModelAnimation {

			
--- a/Viewer/src/model/viewerModel.ts
+++ b/Viewer/src/model/viewerModel.ts
--- a/Viewer/src/optimizer/custom/extended.ts
+++ b/Viewer/src/optimizer/custom/extended.ts
@@ -0,0 +1,94 @@
 
				+import { AbstractViewer } from '../../viewer/viewer';

			
 
				+import { Scalar, DefaultRenderingPipeline } from 'babylonjs';

			
 
				+

			
 
				+export function extendedUpgrade(viewer: AbstractViewer): boolean {

			
 
				+    let defaultPipeline = <DefaultRenderingPipeline>viewer.sceneManager.defaultRenderingPipeline;

			
 
				+    // if (!this.Scene.BackgroundHelper) {

			
 
				+    // 	this.Scene.EngineScene.autoClear = false;

			
 
				+    // this.Scene.BackgroundHelper = true;

			
 
				+    // Would require a dedicated clear color;

			
 
				+    // return false;

			
 
				+    // }

			
 
				+    if (viewer.engine.getHardwareScalingLevel() > 1) {

			
 
				+        let scaling = Scalar.Clamp(viewer.engine.getHardwareScalingLevel() - 0.25, 0, 1);

			
 
				+        viewer.engine.setHardwareScalingLevel(scaling);

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (!viewer.sceneManager.scene.postProcessesEnabled) {

			
 
				+        viewer.sceneManager.scene.postProcessesEnabled = true;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (!viewer.sceneManager.groundEnabled) {

			
 
				+        viewer.sceneManager.groundEnabled = true;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (defaultPipeline && !viewer.sceneManager.fxaaEnabled) {

			
 
				+        viewer.sceneManager.fxaaEnabled = true

			
 
				+        return false;

			
 
				+    }

			
 
				+    var hardwareScalingLevel = Math.max(1 / 2, 1 / (window.devicePixelRatio || 2));

			
 
				+    if (viewer.engine.getHardwareScalingLevel() > hardwareScalingLevel) {

			
 
				+        let scaling = Scalar.Clamp(viewer.engine.getHardwareScalingLevel() - 0.25, 0, hardwareScalingLevel);

			
 
				+        viewer.engine.setHardwareScalingLevel(scaling);

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (!viewer.sceneManager.processShadows) {

			
 
				+        viewer.sceneManager.processShadows = true;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (defaultPipeline && !viewer.sceneManager.bloomEnabled) {

			
 
				+        viewer.sceneManager.bloomEnabled = true

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (!viewer.sceneManager.groundMirrorEnabled) {

			
 
				+        viewer.sceneManager.groundMirrorEnabled = true;

			
 
				+        return false;

			
 
				+    }

			
 
				+    return true;

			
 
				+}

			
 
				+

			
 
				+export function extendedDegrade(viewer: AbstractViewer): boolean {

			
 
				+    let defaultPipeline = <DefaultRenderingPipeline>viewer.sceneManager.defaultRenderingPipeline;

			
 
				+

			
 
				+    if (viewer.sceneManager.groundMirrorEnabled) {

			
 
				+        viewer.sceneManager.groundMirrorEnabled = false;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (defaultPipeline && viewer.sceneManager.bloomEnabled) {

			
 
				+        viewer.sceneManager.bloomEnabled = false;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (viewer.sceneManager.processShadows) {

			
 
				+        viewer.sceneManager.processShadows = false;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (viewer.engine.getHardwareScalingLevel() < 1) {

			
 
				+        let scaling = Scalar.Clamp(viewer.engine.getHardwareScalingLevel() + 0.25, 0, 1);

			
 
				+        viewer.engine.setHardwareScalingLevel(scaling);

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (defaultPipeline && viewer.sceneManager.fxaaEnabled) {

			
 
				+        viewer.sceneManager.fxaaEnabled = false;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (viewer.sceneManager.groundEnabled) {

			
 
				+        viewer.sceneManager.groundEnabled = false;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (viewer.sceneManager.scene.postProcessesEnabled) {

			
 
				+        viewer.sceneManager.scene.postProcessesEnabled = false;

			
 
				+        return false;

			
 
				+    }

			
 
				+    if (viewer.engine.getHardwareScalingLevel() < 1.25) {

			
 
				+        let scaling = Scalar.Clamp(viewer.engine.getHardwareScalingLevel() + 0.25, 0, 1.25);

			
 
				+        viewer.engine.setHardwareScalingLevel(scaling);

			
 
				+        return false;

			
 
				+    }

			
 
				+    // if (this.Scene.BackgroundHelper) {

			
 
				+    // 	this.Scene.EngineScene.autoClear = true;

			
 
				+    // this.Scene.BackgroundHelper = false;

			
 
				+    // Would require a dedicated clear color;

			
 
				+    // return false;

			
 
				+    // }

			
 
				+    return true;

			
 
				+}
			
--- a/Viewer/src/optimizer/custom/index.ts
+++ b/Viewer/src/optimizer/custom/index.ts
@@ -0,0 +1,20 @@
 
				+import { AbstractViewer } from "../../viewer/viewer";

			
 
				+import { extendedUpgrade, extendedDegrade } from "./extended";

			
 
				+

			
 
				+const cache: { [key: string]: (viewer: AbstractViewer) => boolean } = {};

			
 
				+

			
 
				+export function getCustomOptimizerByName(name: string, upgrade?: boolean) {

			
 
				+    if (!cache[name]) {

			
 
				+        switch (name) {

			
 
				+            case 'extended':

			
 
				+                if (upgrade) {

			
 
				+                    return extendedUpgrade;

			
 
				+                }

			
 
				+                else {

			
 
				+                    return extendedDegrade;

			
 
				+                }

			
 
				+        }

			
 
				+    }

			
 
				+

			
 
				+    return cache[name];

			
 
				+}
			
--- a/Viewer/src/viewer/defaultViewer.ts
+++ b/Viewer/src/viewer/defaultViewer.ts
@@ -23,10 +23,6 @@ export class DefaultViewer extends AbstractViewer {
 
				     constructor(public containerElement: HTMLElement, initialConfiguration: ViewerConfiguration = { extends: 'default' }) {

			
 
				         super(containerElement, initialConfiguration);

			
 
				         this.onModelLoadedObservable.add(this._onModelLoaded);

			
 
				-        this.sceneManager.onSceneInitObservable.add(() => {

			
 
				-            // extendClassWithConfig(this.sceneManager.scene, this._configuration.scene);

			
 
				-            return this.sceneManager.scene;

			
 
				-        });

			
 
				 

			
 
				         this.sceneManager.onLightsConfiguredObservable.add((data) => {

			
 
				             this._configureLights(data.newConfiguration, data.model!);

			
@@ -249,9 +245,12 @@ export class DefaultViewer extends AbstractViewer {
 
				      * The scene will automatically be cleared of the old models, if exist.

			
 
				      * @param model the configuration object (or URL) to load.

			
 
				      */

			
 
				-    public loadModel(model: any = this._configuration.model): Promise<ViewerModel> {

			
 
				+    public loadModel(model?: string | IModelConfiguration): Promise<ViewerModel> {

			
 
				+        if (!model) {

			
 
				+            model = this.configuration.model;

			
 
				+        }

			
 
				         this.showLoadingScreen();

			
 
				-        return super.loadModel(model, true).catch((error) => {

			
 
				+        return super.loadModel(model!, true).catch((error) => {

			
 
				             console.log(error);

			
 
				             this.hideLoadingScreen();

			
 
				             this.showOverlayScreen('error');

			
@@ -262,12 +261,14 @@ export class DefaultViewer extends AbstractViewer {
 
				     private _onModelLoaded = (model: ViewerModel) => {

			
 
				         this._configureTemplate(model);

			
 
				         // with a short timeout, making sure everything is there already.

			
 
				-        let hideLoadingDelay = 500;

			
 
				+        let hideLoadingDelay = 20;

			
 
				         if (this._configuration.lab && this._configuration.lab.hideLoadingDelay !== undefined) {

			
 
				             hideLoadingDelay = this._configuration.lab.hideLoadingDelay;

			
 
				         }

			
 
				         setTimeout(() => {

			
 
				-            this.hideLoadingScreen();

			
 
				+            this.sceneManager.scene.executeWhenReady(() => {

			
 
				+                this.hideLoadingScreen();

			
 
				+            });

			
 
				         }, hideLoadingDelay);

			
 
				 

			
 
				         return;

			
--- a/Viewer/src/viewer/sceneManager.ts
+++ b/Viewer/src/viewer/sceneManager.ts
--- a/Viewer/src/viewer/viewer.ts
+++ b/Viewer/src/viewer/viewer.ts
--- a/Viewer/tests/unit/src/viewer/viewer.ts
+++ b/Viewer/tests/unit/src/viewer/viewer.ts
@@ -76,7 +76,7 @@ describe('Viewer', function () {
 
				         let viewer: DefaultViewer = <DefaultViewer>Helper.getNewViewerInstance();

			
 
				         let renderCount = 0;

			
 
				         let sceneRenderCount = 0;

			
 
				-        viewer.onSceneInitObservable.add(() => {

			
 
				+        viewer.onSceneInitObservable.add((scene) => {

			
 
				             viewer.sceneManager.scene.registerBeforeRender(() => {

			
 
				                 sceneRenderCount++;

			
 
				             });

			
@@ -174,13 +174,13 @@ describe('Viewer', function () {
 
				     it('should render in background if set to true', (done) => {

			
 
				         let viewer = Helper.getNewViewerInstance();

			
 
				         viewer.onInitDoneObservable.add(() => {

			
 
				-            assert.isFalse(viewer.engine.renderEvenInBackground, "Engine is rendering in background");

			
 
				+            assert.isTrue(viewer.engine.renderEvenInBackground, "Engine is rendering in background");

			
 
				             viewer.updateConfiguration({

			
 
				                 scene: {

			
 
				-                    renderInBackground: true

			
 
				+                    renderInBackground: false

			
 
				                 }

			
 
				             });

			
 
				-            assert.isTrue(viewer.engine.renderEvenInBackground, "Engine is not rendering in background");

			
 
				+            assert.isFalse(viewer.engine.renderEvenInBackground, "Engine is not rendering in background");

			
 
				             viewer.dispose();

			
 
				             done();

			
 
				         });

			
--- a/release/babylon.d.ts
+++ b/release/babylon.d.ts
--- a/release/babylon.js
+++ b/release/babylon.js
--- a/release/babylon.max.js
+++ b/release/babylon.max.js
--- a/release/babylon.no-module.max.js
+++ b/release/babylon.no-module.max.js
--- a/release/babylon.worker.js
+++ b/release/babylon.worker.js
--- a/release/es6.js
+++ b/release/es6.js
--- a/release/gltf2Interface/package.json
+++ b/release/gltf2Interface/package.json
@@ -1,7 +1,7 @@
 
				 {
			
 
				     "name": "babylonjs-gltf2interface",
			
 
				     "description": "A typescript declaration of babylon's gltf2 inteface.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
--- a/release/gui/package.json
+++ b/release/gui/package.json
@@ -4,7 +4,7 @@
 
				     },
			
 
				     "name": "babylonjs-gui",
			
 
				     "description": "The Babylon.js GUI library is an extension you can use to generate interactive user interface. It is build on top of the DynamicTexture.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
--- a/release/inspector/babylon.inspector.bundle.js
+++ b/release/inspector/babylon.inspector.bundle.js
--- a/release/inspector/babylon.inspector.d.ts
+++ b/release/inspector/babylon.inspector.d.ts
@@ -226,6 +226,12 @@ declare module INSPECTOR {
 
				         'PhysicsImpostor': {
			
 
				             type: typeof BABYLON.PhysicsImpostor;
			
 
				         };
			
 
				+        'ImageProcessingConfiguration': {
			
 
				+            type: typeof BABYLON.ImageProcessingConfiguration;
			
 
				+        };
			
 
				+        'ColorCurves': {
			
 
				+            type: typeof BABYLON.ColorCurves;
			
 
				+        };
			
 
				     };
			
 
				 }
			
 
				 
			
--- a/release/inspector/babylon.inspector.js
+++ b/release/inspector/babylon.inspector.js
@@ -477,6 +477,12 @@ var INSPECTOR;
 
				         'PhysicsImpostor': {
			
 
				             type: BABYLON.PhysicsImpostor
			
 
				         },
			
 
				+        'ImageProcessingConfiguration': {
			
 
				+            type: BABYLON.ImageProcessingConfiguration
			
 
				+        },
			
 
				+        'ColorCurves': {
			
 
				+            type: BABYLON.ColorCurves
			
 
				+        }
			
 
				     };
			
 
				 })(INSPECTOR || (INSPECTOR = {}));
			
 
				 
			
--- a/release/inspector/babylon.inspector.min.js
+++ b/release/inspector/babylon.inspector.min.js
--- a/release/inspector/package.json
+++ b/release/inspector/package.json
@@ -4,7 +4,7 @@
 
				     },
			
 
				     "name": "babylonjs-inspector",
			
 
				     "description": "The Babylon.js inspector.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
--- a/release/loaders/babylon.glTF1FileLoader.js
+++ b/release/loaders/babylon.glTF1FileLoader.js
@@ -406,15 +406,13 @@ var BABYLON;
 
				             loader.onTextureLoadedObservable.add(function (texture) { return _this.onTextureLoadedObservable.notifyObservers(texture); });
			
 
				             loader.onMaterialLoadedObservable.add(function (material) { return _this.onMaterialLoadedObservable.notifyObservers(material); });
			
 
				             loader.onCameraLoadedObservable.add(function (camera) { return _this.onCameraLoadedObservable.notifyObservers(camera); });
			
 
				-            loader.onExtensionLoadedObservable.add(function (extension) {
			
 
				-                _this.onExtensionLoadedObservable.notifyObservers(extension);
			
 
				-                _this.onExtensionLoadedObservable.clear();
			
 
				-            });
			
 
				+            loader.onExtensionLoadedObservable.add(function (extension) { return _this.onExtensionLoadedObservable.notifyObservers(extension); });
			
 
				             loader.onCompleteObservable.add(function () {
			
 
				                 _this.onMeshLoadedObservable.clear();
			
 
				                 _this.onTextureLoadedObservable.clear();
			
 
				                 _this.onMaterialLoadedObservable.clear();
			
 
				                 _this.onCameraLoadedObservable.clear();
			
 
				+                _this.onExtensionLoadedObservable.clear();
			
 
				                 _this.onCompleteObservable.notifyObservers(_this);
			
 
				                 _this.onCompleteObservable.clear();
			
 
				             });
			
--- a/release/loaders/babylon.glTF1FileLoader.min.js
+++ b/release/loaders/babylon.glTF1FileLoader.min.js
--- a/release/loaders/babylon.glTF2FileLoader.d.ts
+++ b/release/loaders/babylon.glTF2FileLoader.d.ts
@@ -443,7 +443,7 @@ declare module BABYLON.GLTF2 {
 
				         _parent: _ILoaderNode;
			
 
				         _babylonMesh?: Mesh;
			
 
				         _primitiveBabylonMeshes?: Mesh[];
			
 
				-        _babylonAnimationTargets?: Node[];
			
 
				+        _babylonBones?: Bone[];
			
 
				         _numMorphTargets?: number;
			
 
				     }
			
 
				     /** @hidden */
			
@@ -797,7 +797,7 @@ declare module BABYLON.GLTF2.Extensions {
 
				 
			
 
				 declare module BABYLON.GLTF2.Extensions {
			
 
				     /**
			
 
				-     * [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)
			
 
				+     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
			
 
				      */
			
 
				     class KHR_materials_unlit extends GLTFLoaderExtension {
			
 
				         readonly name: string;
			
--- a/release/loaders/babylon.glTF2FileLoader.js
+++ b/release/loaders/babylon.glTF2FileLoader.js
@@ -406,15 +406,13 @@ var BABYLON;
 
				             loader.onTextureLoadedObservable.add(function (texture) { return _this.onTextureLoadedObservable.notifyObservers(texture); });
			
 
				             loader.onMaterialLoadedObservable.add(function (material) { return _this.onMaterialLoadedObservable.notifyObservers(material); });
			
 
				             loader.onCameraLoadedObservable.add(function (camera) { return _this.onCameraLoadedObservable.notifyObservers(camera); });
			
 
				-            loader.onExtensionLoadedObservable.add(function (extension) {
			
 
				-                _this.onExtensionLoadedObservable.notifyObservers(extension);
			
 
				-                _this.onExtensionLoadedObservable.clear();
			
 
				-            });
			
 
				+            loader.onExtensionLoadedObservable.add(function (extension) { return _this.onExtensionLoadedObservable.notifyObservers(extension); });
			
 
				             loader.onCompleteObservable.add(function () {
			
 
				                 _this.onMeshLoadedObservable.clear();
			
 
				                 _this.onTextureLoadedObservable.clear();
			
 
				                 _this.onMaterialLoadedObservable.clear();
			
 
				                 _this.onCameraLoadedObservable.clear();
			
 
				+                _this.onExtensionLoadedObservable.clear();
			
 
				                 _this.onCompleteObservable.notifyObservers(_this);
			
 
				                 _this.onCompleteObservable.clear();
			
 
				             });
			
@@ -1055,8 +1053,6 @@ var BABYLON;
 
				                 var promises = new Array();
			
 
				                 var babylonMesh = new BABYLON.Mesh(node.name || "node" + node._index, this._babylonScene, node._parent._babylonMesh);
			
 
				                 node._babylonMesh = babylonMesh;
			
 
				-                node._babylonAnimationTargets = node._babylonAnimationTargets || [];
			
 
				-                node._babylonAnimationTargets.push(babylonMesh);
			
 
				                 GLTFLoader._LoadTransform(node, babylonMesh);
			
 
				                 if (node.mesh != undefined) {
			
 
				                     var mesh = GLTFLoader._GetProperty(context + "/mesh", this._gltf.meshes, node.mesh);
			
@@ -1320,8 +1316,8 @@ var BABYLON;
 
				                 var boneIndex = skin.joints.indexOf(node._index);
			
 
				                 babylonBone = new BABYLON.Bone(node.name || "joint" + node._index, skin._babylonSkeleton, babylonParentBone, this._getNodeMatrix(node), null, null, boneIndex);
			
 
				                 babylonBones[node._index] = babylonBone;
			
 
				-                node._babylonAnimationTargets = node._babylonAnimationTargets || [];
			
 
				-                node._babylonAnimationTargets.push(babylonBone);
			
 
				+                node._babylonBones = node._babylonBones || [];
			
 
				+                node._babylonBones.push(babylonBone);
			
 
				                 return babylonBone;
			
 
				             };
			
 
				             GLTFLoader.prototype._loadSkinInverseBindMatricesDataAsync = function (context, skin) {
			
@@ -1418,7 +1414,7 @@ var BABYLON;
 
				                 var targetNode = GLTFLoader._GetProperty(context + "/target/node", this._gltf.nodes, channel.target.node);
			
 
				                 // Ignore animations that have no animation targets.
			
 
				                 if ((channel.target.path === "weights" /* WEIGHTS */ && !targetNode._numMorphTargets) ||
			
 
				-                    (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonAnimationTargets)) {
			
 
				+                    (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonMesh)) {
			
 
				                     return Promise.resolve();
			
 
				                 }
			
 
				                 // Ignore animations targeting TRS of skinned nodes.
			
@@ -1534,13 +1530,12 @@ var BABYLON;
 
				                                 value: key.value[targetIndex],
			
 
				                                 outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined
			
 
				                             }); }));
			
 
				-                            var morphTargets = new Array();
			
 
				                             _this._forEachPrimitive(targetNode, function (babylonMesh) {
			
 
				                                 var morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);
			
 
				-                                morphTarget.animations.push(babylonAnimation);
			
 
				-                                morphTargets.push(morphTarget);
			
 
				+                                var babylonAnimationClone = babylonAnimation.clone();
			
 
				+                                morphTarget.animations.push(babylonAnimationClone);
			
 
				+                                babylonAnimationGroup.addTargetedAnimation(babylonAnimationClone, morphTarget);
			
 
				                             });
			
 
				-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, morphTargets);
			
 
				                         };
			
 
				                         for (var targetIndex = 0; targetIndex < targetNode._numMorphTargets; targetIndex++) {
			
 
				                             _loop_1(targetIndex);
			
@@ -1550,12 +1545,17 @@ var BABYLON;
 
				                         var animationName = babylonAnimationGroup.name + "_channel" + babylonAnimationGroup.targetedAnimations.length;
			
 
				                         var babylonAnimation = new BABYLON.Animation(animationName, targetPath, 1, animationType);
			
 
				                         babylonAnimation.setKeys(keys);
			
 
				-                        if (targetNode._babylonAnimationTargets) {
			
 
				-                            for (var _i = 0, _a = targetNode._babylonAnimationTargets; _i < _a.length; _i++) {
			
 
				-                                var babylonAnimationTarget = _a[_i];
			
 
				+                        if (targetNode._babylonBones) {
			
 
				+                            var babylonAnimationTargets = [targetNode._babylonMesh].concat(targetNode._babylonBones);
			
 
				+                            for (var _i = 0, babylonAnimationTargets_1 = babylonAnimationTargets; _i < babylonAnimationTargets_1.length; _i++) {
			
 
				+                                var babylonAnimationTarget = babylonAnimationTargets_1[_i];
			
 
				                                 babylonAnimationTarget.animations.push(babylonAnimation);
			
 
				                             }
			
 
				-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonAnimationTargets);
			
 
				+                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, babylonAnimationTargets);
			
 
				+                        }
			
 
				+                        else {
			
 
				+                            targetNode._babylonMesh.animations.push(babylonAnimation);
			
 
				+                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonMesh);
			
 
				                         }
			
 
				                     }
			
 
				                 });
			
@@ -2730,7 +2730,7 @@ var BABYLON;
 
				         (function (Extensions) {
			
 
				             var NAME = "KHR_materials_unlit";
			
 
				             /**
			
 
				-             * [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)
			
 
				+             * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
			
 
				              */
			
 
				             var KHR_materials_unlit = /** @class */ (function (_super) {
			
 
				                 __extends(KHR_materials_unlit, _super);
			
--- a/release/loaders/babylon.glTF2FileLoader.min.js
+++ b/release/loaders/babylon.glTF2FileLoader.min.js
--- a/release/loaders/babylon.glTFFileLoader.d.ts
+++ b/release/loaders/babylon.glTFFileLoader.d.ts
@@ -1019,7 +1019,7 @@ declare module BABYLON.GLTF2 {
 
				         _parent: _ILoaderNode;
			
 
				         _babylonMesh?: Mesh;
			
 
				         _primitiveBabylonMeshes?: Mesh[];
			
 
				-        _babylonAnimationTargets?: Node[];
			
 
				+        _babylonBones?: Bone[];
			
 
				         _numMorphTargets?: number;
			
 
				     }
			
 
				     /** @hidden */
			
@@ -1373,7 +1373,7 @@ declare module BABYLON.GLTF2.Extensions {
 
				 
			
 
				 declare module BABYLON.GLTF2.Extensions {
			
 
				     /**
			
 
				-     * [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)
			
 
				+     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
			
 
				      */
			
 
				     class KHR_materials_unlit extends GLTFLoaderExtension {
			
 
				         readonly name: string;
			
--- a/release/loaders/babylon.glTFFileLoader.js
+++ b/release/loaders/babylon.glTFFileLoader.js
@@ -406,15 +406,13 @@ var BABYLON;
 
				             loader.onTextureLoadedObservable.add(function (texture) { return _this.onTextureLoadedObservable.notifyObservers(texture); });
			
 
				             loader.onMaterialLoadedObservable.add(function (material) { return _this.onMaterialLoadedObservable.notifyObservers(material); });
			
 
				             loader.onCameraLoadedObservable.add(function (camera) { return _this.onCameraLoadedObservable.notifyObservers(camera); });
			
 
				-            loader.onExtensionLoadedObservable.add(function (extension) {
			
 
				-                _this.onExtensionLoadedObservable.notifyObservers(extension);
			
 
				-                _this.onExtensionLoadedObservable.clear();
			
 
				-            });
			
 
				+            loader.onExtensionLoadedObservable.add(function (extension) { return _this.onExtensionLoadedObservable.notifyObservers(extension); });
			
 
				             loader.onCompleteObservable.add(function () {
			
 
				                 _this.onMeshLoadedObservable.clear();
			
 
				                 _this.onTextureLoadedObservable.clear();
			
 
				                 _this.onMaterialLoadedObservable.clear();
			
 
				                 _this.onCameraLoadedObservable.clear();
			
 
				+                _this.onExtensionLoadedObservable.clear();
			
 
				                 _this.onCompleteObservable.notifyObservers(_this);
			
 
				                 _this.onCompleteObservable.clear();
			
 
				             });
			
@@ -3270,8 +3268,6 @@ var BABYLON;
 
				                 var promises = new Array();
			
 
				                 var babylonMesh = new BABYLON.Mesh(node.name || "node" + node._index, this._babylonScene, node._parent._babylonMesh);
			
 
				                 node._babylonMesh = babylonMesh;
			
 
				-                node._babylonAnimationTargets = node._babylonAnimationTargets || [];
			
 
				-                node._babylonAnimationTargets.push(babylonMesh);
			
 
				                 GLTFLoader._LoadTransform(node, babylonMesh);
			
 
				                 if (node.mesh != undefined) {
			
 
				                     var mesh = GLTFLoader._GetProperty(context + "/mesh", this._gltf.meshes, node.mesh);
			
@@ -3535,8 +3531,8 @@ var BABYLON;
 
				                 var boneIndex = skin.joints.indexOf(node._index);
			
 
				                 babylonBone = new BABYLON.Bone(node.name || "joint" + node._index, skin._babylonSkeleton, babylonParentBone, this._getNodeMatrix(node), null, null, boneIndex);
			
 
				                 babylonBones[node._index] = babylonBone;
			
 
				-                node._babylonAnimationTargets = node._babylonAnimationTargets || [];
			
 
				-                node._babylonAnimationTargets.push(babylonBone);
			
 
				+                node._babylonBones = node._babylonBones || [];
			
 
				+                node._babylonBones.push(babylonBone);
			
 
				                 return babylonBone;
			
 
				             };
			
 
				             GLTFLoader.prototype._loadSkinInverseBindMatricesDataAsync = function (context, skin) {
			
@@ -3633,7 +3629,7 @@ var BABYLON;
 
				                 var targetNode = GLTFLoader._GetProperty(context + "/target/node", this._gltf.nodes, channel.target.node);
			
 
				                 // Ignore animations that have no animation targets.
			
 
				                 if ((channel.target.path === "weights" /* WEIGHTS */ && !targetNode._numMorphTargets) ||
			
 
				-                    (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonAnimationTargets)) {
			
 
				+                    (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonMesh)) {
			
 
				                     return Promise.resolve();
			
 
				                 }
			
 
				                 // Ignore animations targeting TRS of skinned nodes.
			
@@ -3749,13 +3745,12 @@ var BABYLON;
 
				                                 value: key.value[targetIndex],
			
 
				                                 outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined
			
 
				                             }); }));
			
 
				-                            var morphTargets = new Array();
			
 
				                             _this._forEachPrimitive(targetNode, function (babylonMesh) {
			
 
				                                 var morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);
			
 
				-                                morphTarget.animations.push(babylonAnimation);
			
 
				-                                morphTargets.push(morphTarget);
			
 
				+                                var babylonAnimationClone = babylonAnimation.clone();
			
 
				+                                morphTarget.animations.push(babylonAnimationClone);
			
 
				+                                babylonAnimationGroup.addTargetedAnimation(babylonAnimationClone, morphTarget);
			
 
				                             });
			
 
				-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, morphTargets);
			
 
				                         };
			
 
				                         for (var targetIndex = 0; targetIndex < targetNode._numMorphTargets; targetIndex++) {
			
 
				                             _loop_1(targetIndex);
			
@@ -3765,12 +3760,17 @@ var BABYLON;
 
				                         var animationName = babylonAnimationGroup.name + "_channel" + babylonAnimationGroup.targetedAnimations.length;
			
 
				                         var babylonAnimation = new BABYLON.Animation(animationName, targetPath, 1, animationType);
			
 
				                         babylonAnimation.setKeys(keys);
			
 
				-                        if (targetNode._babylonAnimationTargets) {
			
 
				-                            for (var _i = 0, _a = targetNode._babylonAnimationTargets; _i < _a.length; _i++) {
			
 
				-                                var babylonAnimationTarget = _a[_i];
			
 
				+                        if (targetNode._babylonBones) {
			
 
				+                            var babylonAnimationTargets = [targetNode._babylonMesh].concat(targetNode._babylonBones);
			
 
				+                            for (var _i = 0, babylonAnimationTargets_1 = babylonAnimationTargets; _i < babylonAnimationTargets_1.length; _i++) {
			
 
				+                                var babylonAnimationTarget = babylonAnimationTargets_1[_i];
			
 
				                                 babylonAnimationTarget.animations.push(babylonAnimation);
			
 
				                             }
			
 
				-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonAnimationTargets);
			
 
				+                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, babylonAnimationTargets);
			
 
				+                        }
			
 
				+                        else {
			
 
				+                            targetNode._babylonMesh.animations.push(babylonAnimation);
			
 
				+                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonMesh);
			
 
				                         }
			
 
				                     }
			
 
				                 });
			
@@ -4945,7 +4945,7 @@ var BABYLON;
 
				         (function (Extensions) {
			
 
				             var NAME = "KHR_materials_unlit";
			
 
				             /**
			
 
				-             * [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)
			
 
				+             * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
			
 
				              */
			
 
				             var KHR_materials_unlit = /** @class */ (function (_super) {
			
 
				                 __extends(KHR_materials_unlit, _super);
			
--- a/release/loaders/babylon.glTFFileLoader.min.js
+++ b/release/loaders/babylon.glTFFileLoader.min.js
--- a/release/loaders/babylonjs.loaders.d.ts
+++ b/release/loaders/babylonjs.loaders.d.ts
@@ -1115,7 +1115,7 @@ declare module BABYLON.GLTF2 {
 
				         _parent: _ILoaderNode;
			
 
				         _babylonMesh?: Mesh;
			
 
				         _primitiveBabylonMeshes?: Mesh[];
			
 
				-        _babylonAnimationTargets?: Node[];
			
 
				+        _babylonBones?: Bone[];
			
 
				         _numMorphTargets?: number;
			
 
				     }
			
 
				     /** @hidden */
			
@@ -1469,7 +1469,7 @@ declare module BABYLON.GLTF2.Extensions {
 
				 
			
 
				 declare module BABYLON.GLTF2.Extensions {
			
 
				     /**
			
 
				-     * [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)
			
 
				+     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
			
 
				      */
			
 
				     class KHR_materials_unlit extends GLTFLoaderExtension {
			
 
				         readonly name: string;
			
--- a/release/loaders/babylonjs.loaders.js
+++ b/release/loaders/babylonjs.loaders.js
@@ -1406,15 +1406,13 @@ var BABYLON;
 
				             loader.onTextureLoadedObservable.add(function (texture) { return _this.onTextureLoadedObservable.notifyObservers(texture); });
			
 
				             loader.onMaterialLoadedObservable.add(function (material) { return _this.onMaterialLoadedObservable.notifyObservers(material); });
			
 
				             loader.onCameraLoadedObservable.add(function (camera) { return _this.onCameraLoadedObservable.notifyObservers(camera); });
			
 
				-            loader.onExtensionLoadedObservable.add(function (extension) {
			
 
				-                _this.onExtensionLoadedObservable.notifyObservers(extension);
			
 
				-                _this.onExtensionLoadedObservable.clear();
			
 
				-            });
			
 
				+            loader.onExtensionLoadedObservable.add(function (extension) { return _this.onExtensionLoadedObservable.notifyObservers(extension); });
			
 
				             loader.onCompleteObservable.add(function () {
			
 
				                 _this.onMeshLoadedObservable.clear();
			
 
				                 _this.onTextureLoadedObservable.clear();
			
 
				                 _this.onMaterialLoadedObservable.clear();
			
 
				                 _this.onCameraLoadedObservable.clear();
			
 
				+                _this.onExtensionLoadedObservable.clear();
			
 
				                 _this.onCompleteObservable.notifyObservers(_this);
			
 
				                 _this.onCompleteObservable.clear();
			
 
				             });
			
@@ -4252,8 +4250,6 @@ var BABYLON;
 
				                 var promises = new Array();
			
 
				                 var babylonMesh = new BABYLON.Mesh(node.name || "node" + node._index, this._babylonScene, node._parent._babylonMesh);
			
 
				                 node._babylonMesh = babylonMesh;
			
 
				-                node._babylonAnimationTargets = node._babylonAnimationTargets || [];
			
 
				-                node._babylonAnimationTargets.push(babylonMesh);
			
 
				                 GLTFLoader._LoadTransform(node, babylonMesh);
			
 
				                 if (node.mesh != undefined) {
			
 
				                     var mesh = GLTFLoader._GetProperty(context + "/mesh", this._gltf.meshes, node.mesh);
			
@@ -4517,8 +4513,8 @@ var BABYLON;
 
				                 var boneIndex = skin.joints.indexOf(node._index);
			
 
				                 babylonBone = new BABYLON.Bone(node.name || "joint" + node._index, skin._babylonSkeleton, babylonParentBone, this._getNodeMatrix(node), null, null, boneIndex);
			
 
				                 babylonBones[node._index] = babylonBone;
			
 
				-                node._babylonAnimationTargets = node._babylonAnimationTargets || [];
			
 
				-                node._babylonAnimationTargets.push(babylonBone);
			
 
				+                node._babylonBones = node._babylonBones || [];
			
 
				+                node._babylonBones.push(babylonBone);
			
 
				                 return babylonBone;
			
 
				             };
			
 
				             GLTFLoader.prototype._loadSkinInverseBindMatricesDataAsync = function (context, skin) {
			
@@ -4615,7 +4611,7 @@ var BABYLON;
 
				                 var targetNode = GLTFLoader._GetProperty(context + "/target/node", this._gltf.nodes, channel.target.node);
			
 
				                 // Ignore animations that have no animation targets.
			
 
				                 if ((channel.target.path === "weights" /* WEIGHTS */ && !targetNode._numMorphTargets) ||
			
 
				-                    (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonAnimationTargets)) {
			
 
				+                    (channel.target.path !== "weights" /* WEIGHTS */ && !targetNode._babylonMesh)) {
			
 
				                     return Promise.resolve();
			
 
				                 }
			
 
				                 // Ignore animations targeting TRS of skinned nodes.
			
@@ -4731,13 +4727,12 @@ var BABYLON;
 
				                                 value: key.value[targetIndex],
			
 
				                                 outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined
			
 
				                             }); }));
			
 
				-                            var morphTargets = new Array();
			
 
				                             _this._forEachPrimitive(targetNode, function (babylonMesh) {
			
 
				                                 var morphTarget = babylonMesh.morphTargetManager.getTarget(targetIndex);
			
 
				-                                morphTarget.animations.push(babylonAnimation);
			
 
				-                                morphTargets.push(morphTarget);
			
 
				+                                var babylonAnimationClone = babylonAnimation.clone();
			
 
				+                                morphTarget.animations.push(babylonAnimationClone);
			
 
				+                                babylonAnimationGroup.addTargetedAnimation(babylonAnimationClone, morphTarget);
			
 
				                             });
			
 
				-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, morphTargets);
			
 
				                         };
			
 
				                         for (var targetIndex = 0; targetIndex < targetNode._numMorphTargets; targetIndex++) {
			
 
				                             _loop_1(targetIndex);
			
@@ -4747,12 +4742,17 @@ var BABYLON;
 
				                         var animationName = babylonAnimationGroup.name + "_channel" + babylonAnimationGroup.targetedAnimations.length;
			
 
				                         var babylonAnimation = new BABYLON.Animation(animationName, targetPath, 1, animationType);
			
 
				                         babylonAnimation.setKeys(keys);
			
 
				-                        if (targetNode._babylonAnimationTargets) {
			
 
				-                            for (var _i = 0, _a = targetNode._babylonAnimationTargets; _i < _a.length; _i++) {
			
 
				-                                var babylonAnimationTarget = _a[_i];
			
 
				+                        if (targetNode._babylonBones) {
			
 
				+                            var babylonAnimationTargets = [targetNode._babylonMesh].concat(targetNode._babylonBones);
			
 
				+                            for (var _i = 0, babylonAnimationTargets_1 = babylonAnimationTargets; _i < babylonAnimationTargets_1.length; _i++) {
			
 
				+                                var babylonAnimationTarget = babylonAnimationTargets_1[_i];
			
 
				                                 babylonAnimationTarget.animations.push(babylonAnimation);
			
 
				                             }
			
 
				-                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonAnimationTargets);
			
 
				+                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, babylonAnimationTargets);
			
 
				+                        }
			
 
				+                        else {
			
 
				+                            targetNode._babylonMesh.animations.push(babylonAnimation);
			
 
				+                            babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonMesh);
			
 
				                         }
			
 
				                     }
			
 
				                 });
			
@@ -5873,7 +5873,7 @@ var BABYLON;
 
				         (function (Extensions) {
			
 
				             var NAME = "KHR_materials_unlit";
			
 
				             /**
			
 
				-             * [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)
			
 
				+             * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
			
 
				              */
			
 
				             var KHR_materials_unlit = /** @class */ (function (_super) {
			
 
				                 __extends(KHR_materials_unlit, _super);
			
--- a/release/loaders/babylonjs.loaders.min.js
+++ b/release/loaders/babylonjs.loaders.min.js
--- a/release/loaders/babylonjs.loaders.module.d.ts
+++ b/release/loaders/babylonjs.loaders.module.d.ts
@@ -1122,7 +1122,7 @@ declare module BABYLON.GLTF2 {
 
				         _parent: _ILoaderNode;
			
 
				         _babylonMesh?: Mesh;
			
 
				         _primitiveBabylonMeshes?: Mesh[];
			
 
				-        _babylonAnimationTargets?: Node[];
			
 
				+        _babylonBones?: Bone[];
			
 
				         _numMorphTargets?: number;
			
 
				     }
			
 
				     /** @hidden */
			
@@ -1476,7 +1476,7 @@ declare module BABYLON.GLTF2.Extensions {
 
				 
			
 
				 declare module BABYLON.GLTF2.Extensions {
			
 
				     /**
			
 
				-     * [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)
			
 
				+     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)
			
 
				      */
			
 
				     class KHR_materials_unlit extends GLTFLoaderExtension {
			
 
				         readonly name: string;
			
--- a/release/loaders/package.json
+++ b/release/loaders/package.json
@@ -4,7 +4,7 @@
 
				     },
			
 
				     "name": "babylonjs-loaders",
			
 
				     "description": "The Babylon.js file loaders library is an extension you can use to load different 3D file types into a Babylon scene.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
@@ -27,7 +27,7 @@
 
				     ],
			
 
				     "license": "Apache-2.0",
			
 
				     "dependencies": {
			
 
				-        "babylonjs-gltf2interface": "3.2.0-rc.2"
			
 
				+        "babylonjs-gltf2interface": "3.2.0-rc.3"
			
 
				     },
			
 
				     "peerDependencies": {
			
 
				         "babylonjs": ">=3.2.0-alpha"
			
--- a/release/materialsLibrary/babylon.cellMaterial.js
+++ b/release/materialsLibrary/babylon.cellMaterial.js
--- a/release/materialsLibrary/babylon.cellMaterial.min.js
+++ b/release/materialsLibrary/babylon.cellMaterial.min.js
--- a/release/materialsLibrary/babylonjs.materials.js
+++ b/release/materialsLibrary/babylonjs.materials.js
--- a/release/materialsLibrary/babylonjs.materials.min.js
+++ b/release/materialsLibrary/babylonjs.materials.min.js
--- a/release/materialsLibrary/package.json
+++ b/release/materialsLibrary/package.json
@@ -4,7 +4,7 @@
 
				     },
			
 
				     "name": "babylonjs-materials",
			
 
				     "description": "The Babylon.js materials library is a collection of advanced materials to be used in a Babylon.js scene.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
--- a/release/postProcessesLibrary/package.json
+++ b/release/postProcessesLibrary/package.json
@@ -4,7 +4,7 @@
 
				     },
			
 
				     "name": "babylonjs-post-process",
			
 
				     "description": "The Babylon.js materials library is a collection of advanced materials to be used in a Babylon.js scene.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
--- a/release/proceduralTexturesLibrary/package.json
+++ b/release/proceduralTexturesLibrary/package.json
@@ -4,7 +4,7 @@
 
				     },
			
 
				     "name": "babylonjs-procedural-textures",
			
 
				     "description": "The Babylon.js materials library is a collection of advanced materials to be used in a Babylon.js scene.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
--- a/release/serializers/package.json
+++ b/release/serializers/package.json
@@ -4,7 +4,7 @@
 
				     },
			
 
				     "name": "babylonjs-serializers",
			
 
				     "description": "The Babylon.js serializers library is an extension you can use to serialize Babylon scenes.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
@@ -27,7 +27,7 @@
 
				     ],
			
 
				     "license": "Apache-2.0",
			
 
				     "dependencies": {
			
 
				-        "babylonjs-gltf2interface": "3.2.0-rc.2"
			
 
				+        "babylonjs-gltf2interface": "3.2.0-rc.3"
			
 
				     },
			
 
				     "peerDependencies": {
			
 
				         "babylonjs": ">=3.2.0-alpha"
			
--- a/release/viewer/babylon.viewer.js
+++ b/release/viewer/babylon.viewer.js
--- a/release/viewer/babylon.viewer.max.js
+++ b/release/viewer/babylon.viewer.max.js
--- a/release/viewer/package.json
+++ b/release/viewer/package.json
@@ -4,7 +4,7 @@
 
				     },
			
 
				     "name": "babylonjs-viewer",
			
 
				     "description": "A simple-to-use viewer based on BabylonJS to display 3D elements natively",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3.2",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
@@ -12,6 +12,7 @@
 
				     "main": "babylon.viewer.js",
			
 
				     "files": [
			
 
				         "babylon.viewer.js",
			
 
				+        "babylon.viewer.max.js",
			
 
				         "babylon.viewer.module.d.ts",
			
 
				         "babylon.glTF2Interface.d.ts",
			
 
				         "babylonjs.loaders.d.ts",
			
--- a/release/what's
+++ b/release/what's
@@ -15,13 +15,13 @@
 
				 - New [AssetContainer](http://doc.babylonjs.com/how_to/how_to_use_assetcontainer) class and loading methods ([trevordev](https://github.com/trevordev))

			
 
				 - Added [depth of field](https://www.babylonjs-playground.com/frame.html#8F5HYV#9), [MSAA, sharpening, chromatic aberration and grain effect](https://www.babylonjs-playground.com/#Y3C0HQ#146) to the default pipeline ([trevordev](https://github.com/trevordev))

			
 
				 - Added support for [animation weights](http://doc.babylonjs.com/babylon101/animations#animation-weights). Demo [here](https://www.babylonjs-playground.com/#LL5BIQ) ([deltakosh](https://github.com/deltakosh))

			
 
				-- Added [sub emitters for particle system](http://doc.babylonjs.com/babylon101/particles#sub-emitters) which will spawn new particle systems when particles dies. Demo [here](https://www.babylonjs-playground.com/frame.html#9NHBCC#1) ([IbraheemOsama](https://github.com/IbraheemOsama))

			
 
				+- Added [sub emitters for particle system](http://doc.babylonjs.com/babylon101/particles#sub-emitters) which will spawn new particle systems when particles die. Demo [here](https://www.babylonjs-playground.com/frame.html#9NHBCC#1) ([IbraheemOsama](https://github.com/IbraheemOsama))

			
 
				 - New [Babylon.js](http://doc.babylonjs.com/resources/maya) and [glTF](http://doc.babylonjs.com/resources/maya_to_gltf) exporter for Autodesk Maya ([Noalak](https://github.com/Noalak))

			
 
				-- New glTF [serializer](https://github.com/BabylonJS/Babylon.js/tree/master/serializers/src/glTF/2.0). You can now export glTF or glb files directly from a Babylon scene ([kcoley](https://github.com/kcoley))

			
 
				 - New [glTF exporter](http://doc.babylonjs.com/resources/3dsmax_to_gltf) for Autodesk 3dsmax ([Noalak](https://github.com/Noalak))

			
 
				+- New glTF [serializer](http://doc.babylonjs.com/extensions/gltfexporter). You can now export glTF or glb files directly from a Babylon scene ([kcoley](https://github.com/kcoley))

			
 
				 - Physics - Latest production version of Oimo.js is being used - 1.0.9 ([RaananW](https://github.com/RaananW))

			
 
				 - Introduces [PCF](https://doc.babylonjs.com/babylon101/shadows#percentage-closer-filtering-webgl2-only) and [PCSS](https://doc.babylonjs.com/babylon101/shadows#contact-hardening-shadow-webgl2-only) shadow support in Webgl 2 ([sebavan](https://github.com/sebavan)))

			
 
				-- Introduces [PBR Specular Anti Aliasing support](https://doc.babylonjs.com/how_to/physically_based_rendering_master#specular-aliasing) ([sebavan](https://github.com/sebavan)))

			
 
				+- Introduces [PBR Specular Anti Aliasing support](https://doc.babylonjs.com/how_to/physically_based_rendering_master#specular-aliasing). Demoo [here](https://www.babylonjs-playground.com/#1XJD4C) ([sebavan](https://github.com/sebavan)))

			
 
				 

			
 
				 ## Documentation

			
 
				 

			
@@ -31,7 +31,7 @@
 
				 ## Updates

			
 
				 

			
 
				 - Improved [animation blending](https://www.babylonjs-playground.com/#DMLMIP#1) ([deltakosh](https://github.com/deltakosh))

			
 
				-- New [particle system emitter shapes](http://doc.babylonjs.com/babylon101/particles#particles-shapes): cone and sphere ([IbraheemOsama](https://github.com/IbraheemOsama))

			
 
				+- New [particle system emitter shapes](http://doc.babylonjs.com/babylon101/particles#shape-emitters): cone and sphere ([IbraheemOsama](https://github.com/IbraheemOsama))

			
 
				 - Added support for 16bits TGA ([deltakosh](https://github.com/deltakosh))

			
 
				 - New `AnimationPropertiesOverride` class used to simplify setting animation properties on child animations. [Documentation](http://doc.babylonjs.com/babylon101/animations#overriding-properties) ([deltakosh](https://github.com/deltakosh))

			
 
				 - New `Texture.UseSerializedUrlIfAny` static property to let textures serialize complete URL instead of using side by side loading ([deltakosh](https://github.com/deltakosh))

			
@@ -39,107 +39,106 @@
 
				 - Added support for all RGBA orders (BGR, RGB, etc..) for the DDS loader ([deltakosh](https://github.com/deltakosh))

			
 
				 - Improved [SceneOptimizer](http://doc.babylonjs.com/how_to/how_to_use_sceneoptimizer) to provide better adaptability ([deltakosh](https://github.com/deltakosh))

			
 
				 - Improved `scene.isReady()` function which now takes in account shadows and LOD ([deltakosh](https://github.com/deltakosh))

			
 
				-- New watcher configuration for VSCode. Now the task only compiles changed files ([sebavan](https://github.com/sebavan))

			
 
				 - Added new draw modes to engine (points, lines, linesloop, linestrip, trianglestrip, trianglefan) ([benaadams](https://github.com/benaadams))

			
 
				-- Added GUI Textblock.lineSpacing setter and getter to configure vertical space between lines in pixels or percentage values when working with text wrapping ([carloslanderas](https://github.com/carloslanderas))

			
 
				-- VRHelper now has onSelectedMeshUnselected observable that will notify observers when the current selected mesh gets unselected

			
 
				+- Added GUI `Textblock.lineSpacing` setter and getter to configure vertical space between lines in pixels or percentage values when working with text wrapping ([carloslanderas](https://github.com/carloslanderas))

			
 
				+- WebVR:

			
 
				+  - `VRExperienceHelper` will create an empty controller model so that controller interactions can be used while the actual model is still loading ([trevordev](https://github.com/trevordev))

			
 
				+  - VRHelper now has `onSelectedMeshUnselected` observable that will notify observers when the current selected mesh gets unselected

			
 
				   ([carloslanderas](https://github.com/carloslanderas))

			
 
				-- VRHelper now has onBeforeCameraTeleport and onAfterCameraTeleport observables that will be notified before and after camera teleportation is triggered.

			
 
				+  - VRHelper now has `onBeforeCameraTeleport` and `onAfterCameraTelepor`t observables that will be notified before and after camera teleportation is triggered.

			
 
				   ([carloslanderas](https://github.com/carloslanderas))

			
 
				-- VRHelper now has the public property teleportationEnabled to enable / disable camera teleportation.

			
 
				+  - VRHelper now has the public property `teleportationEnabled` to enable / disable camera teleportation.

			
 
				    ([carloslanderas](https://github.com/carloslanderas))

			
 
				-- VRHelper now exposes onNewMeshPicked observable that will notify a PickingInfo object after meshSelectionPredicate evaluation

			
 
				+  - VRHelper now exposes onNewMeshPicked observable that will notify a PickingInfo object after meshSelectionPredicate evaluation

			
 
				    ([carloslanderas](https://github.com/carloslanderas))

			
 
				-- `AssetsManager` will now clear its `tasks` lsit from all successfully loaded tasks ([deltakosh](https://github.com/deltakosh))

			
 
				-- Added documentation to WebVRCamera and VRExperienceHelper ([trevordev](https://github.com/trevordev))

			
 
				+  - VRHelper will notify now `onSelectedMeshUnselected` observable to subscribers when the applied ray selection predicate does not produce a hit and a mesh compliant with the meshSelectionPredicate was previously selected  ([carloslanderas](https://github.com/carloslanderas))

			
 
				+  - Support multiple simultaneous WebVR controller gui interactions in `VRExperienceHelper` ([trevordev](https://github.com/trevordev))

			
 
				+  - Ability to set a mesh to customize the WebVR gaze tracker ([trevordev](https://github.com/trevordev))

			
 
				+- `AssetsManager` will now clear its `tasks` list from all successfully loaded tasks ([deltakosh](https://github.com/deltakosh))

			
 
				+- Added documentation to `WebVRCamera` and `VRExperienceHelper` ([trevordev](https://github.com/trevordev))

			
 
				 - Introduced `isStroke` on `HighlightLayerOptions` which makes the highlight solid ([PixelsCommander](https://github.com/pixelscommander))

			
 
				-- (Viewer) There is now an option to paste payload instead of a URL for configuration ([RaananW](https://github.com/RaananW))

			
 
				-- (Viewer) Models can be loaded async using JavaScript ([RaananW](https://github.com/RaananW))

			
 
				-- VRHelper will notify now onSelectedMeshUnselected observable to subscribers when the applied ray selection predicate does not produce a hit and a mesh compliant with the meshSelectionPredicate was previously selected

			
 
				-   ([carloslanderas](https://github.com/carloslanderas))

			
 
				-- (Viewer) initScene and initEngine can now be extended. onProgress during model loading is implemented as observable. ([RaananW](https://github.com/RaananW))

			
 
				-- glTF loader now supports the KHR_lights extension ([MiiBond](https://github.com/MiiBond))

			
 
				-- The observable can now notify observers using promise-based callback chain. ([RaananW](https://github.com/RaananW))

			
 
				+- The observables can now notify observers using promise-based callback chain ([RaananW](https://github.com/RaananW))

			
 
				 - Added base64 helper functions to `Tools` ([bghgary](https://github.com/bghgary))

			
 
				 - Added `createDefaultCamera` and `createDefaultLight` functions to `Scene` ([bghgary](https://github.com/bghgary))

			
 
				-- Gulp process now supports multiple outputs when using webpack. ([RaananW](https://github.com/RaananW))

			
 
				-- (Viewer) Scene Optimizer intergrated in viewer. ([RaananW](https://github.com/RaananW))

			
 
				-- (Viewer) The viewer supports custom shaders in the configuration. ([RaananW](https://github.com/RaananW))

			
 
				-- Documented PostProcessRenderEffect, DefaultRenderingPipeline, BlurPostProcess, DepthOfFieldEffect, PostProcess, PostProcessManager, Effect classes ([trevordev](https://github.com/trevordev))

			
 
				+- Viewer:

			
 
				+  - `initScene` and `initEngine` can now be extended. `onProgress` during model loading is implemented as observable ([RaananW](https://github.com/RaananW))

			
 
				+  - There is now an option to paste payload instead of a URL for configuration ([RaananW](https://github.com/RaananW))

			
 
				+  - Models can be loaded asynchronously using JavaScript ([RaananW](https://github.com/RaananW))

			
 
				+  - Scene Optimizer integrated in viewer ([RaananW](https://github.com/RaananW))

			
 
				+  - The viewer supports custom shaders in the configuration ([RaananW](https://github.com/RaananW))

			
 
				+  - Introducing the viewer labs - testing new features ([RaananW](https://github.com/RaananW))

			
 
				+  - Model can be normalized using configuration, camera is dynamically configured ([RaananW](https://github.com/RaananW))

			
 
				+  - It is now possible to update parts of the configuration without recreating the objects ([RaananW](https://github.com/RaananW))

			
 
				+  - Viewer supports model animations and multi-model loading ([RaananW](https://github.com/RaananW))

			
 
				+  - Viewer's declaration file automatically generated ([RaananW](https://github.com/RaananW))

			
 
				+- Build process:

			
 
				+  - New watcher configuration for VSCode. Now the task only compiles changed files ([sebavan](https://github.com/sebavan))

			
 
				+  - Gulp process now supports multiple outputs when using webpack. ([RaananW](https://github.com/RaananW))

			
 
				+  - Extra/external declarations can be prepended to final declarations during build. ([RaananW](https://github.com/RaananW))

			
 
				+  - Extra/external declarations can be prepended to final NPM declarations during build. ([RaananW](https://github.com/RaananW))

			
 
				+  - NPM package now has a dependency system, updated during build. ([RaananW](https://github.com/RaananW))

			
 
				 - SPS internal storage of each solid particle rotation matrix ([jbousquie](https://github.com/jbousquie))

			
 
				 - SPS particle parenting feature ([jbousquie](https://github.com/jbousquie))

			
 
				-- (Viewer) Introducing the viewer labs - testing new features. ([RaananW](https://github.com/RaananW))

			
 
				 - KeepAssets class and AssetContainer.moveAllFromScene ([HoloLite](http://www.html5gamedevs.com/profile/28694-hololite/) [trevordev](https://github.com/trevordev))

			
 
				-- (Viewer) It is now possible to update parts of the configuration without rcreating the objects. Extra configuration can be loaded sync (if provided) ([RaananW](https://github.com/RaananW))

			
 
				-- (Gulp) extra/external declarations can be prepended to final declarations during build. ([RaananW](https://github.com/RaananW))

			
 
				-- (Viewer) Model can be normalized using configuration, camera is dynamically configured. ([RaananW](https://github.com/RaananW))

			
 
				-- (Gulp) extra/external declarations can be prepended to final NPM declarations during build. ([RaananW](https://github.com/RaananW))

			
 
				 - GUI.Line can have its world position set from one end or the other ([SvenFrankson](https://github.com/SvenFrankson))

			
 
				 - Added FOV system to background material for zoom effects in skyboxes without adjusting camera FOV ([DavidHGillen](https://github.com/DavidHGillen))

			
 
				-- Improved glTF loader by using promises for asynchronous operations. ([bghgary](https://github.com/bghgary)]

			
 
				-- Improved glTF loader performance by compiling materials in parallel with downloading external resources. ([bghgary](https://github.com/bghgary)]

			
 
				-- Added unit tests for the glTF 2.0 loader. ([bghgary](https://github.com/bghgary)]

			
 
				+- glTF loader:

			
 
				+  - glTF loader now supports the KHR_lights extension ([MiiBond](https://github.com/MiiBond))

			
 
				+  - Improved glTF loader by using promises for asynchronous operations ([bghgary](https://github.com/bghgary)]

			
 
				+  - Improved glTF loader performance by compiling materials in parallel with downloading external resources ([bghgary](https://github.com/bghgary)]

			
 
				+  - Added unit tests for the glTF 2.0 loader ([bghgary](https://github.com/bghgary)]

			
 
				+  - Added support for primitive modes to glTF 2.0 loader ([bghgary](https://github.com/bghgary)]

			
 
				+  - Add support for sparse accessors to glTF 2.0 loader ([bghgary](https://github.com/bghgary))

			
 
				+  - Add support for cameras to glTF 2.0 loader ([bghgary](https://github.com/bghgary)]

			
 
				+  - Add support for preprocessing urls to glTF 2.0 loader ([bghgary](https://github.com/bghgary)]

			
 
				+  - Added Draco mesh compression support to glTF 2.0 loader. ([bghgary](https://github.com/bghgary))

			
 
				+  - Added unlit material extension support to glTF 2.0 loader. ([bghgary](https://github.com/bghgary))

			
 
				 - Added promise-based async functions to the SceneLoader, Scene.whenReadyAsync, and material.forceCompilationAsync. ([bghgary](https://github.com/bghgary)]

			
 
				 - Added checks to VertexData.merge to ensure data is valid before merging. ([bghgary](https://github.com/bghgary)]

			
 
				-- Ability to set a mesh to customize the webVR gaze tracker ([trevordev](https://github.com/trevordev))

			
 
				-- Added promise-based async functions for initWebVRAsync and useStandingMatrixAsync ([trevordev](https://github.com/trevordev))

			
 
				+- Added promise-based async functions for `initWebVRAsync` and `useStandingMatrixAsync` ([trevordev](https://github.com/trevordev))

			
 
				 - Add stroke (outline) options on GUI text control ([SvenFrankson](https://github.com/SvenFrankson))

			
 
				 - Add isThumbClamped option on GUI slider control ([JeanPhilippeKernel](https://github.com/JeanPhilippeKernel))

			
 
				 - Add floating point texture support for RenderTargetCubeTexture ([PeapBoy](https://github.com/NicolasBuecher))

			
 
				 - Support for mutli-touch when interacting with multiple gui elements simultaneously ([trevordev](https://github.com/trevordev))

			
 
				-- (Viewer) Declaration file published, ready for npm. ([RaananW](https://github.com/RaananW))

			
 
				-- Added Draco mesh compression support to glTF 2.0 loader. ([bghgary](https://github.com/bghgary))

			
 
				-- Support multiple simultaneous webVR controller gui interactions in WebVRExperienceHelper ([trevordev](https://github.com/trevordev))

			
 
				-- (Viewer) XHR requests not use Tools.LoadFile and are disposed correctly - [#3671](https://github.com/BabylonJS/Babylon.js/issues/3671) ([RaananW](https://github.com/RaananW))

			
 
				+(https://github.com/trevordev))

			
 
				 - Added `Tools.WorkerPool` class for web worker management. ([bghgary](https://github.com/bghgary))

			
 
				 - Support depth maps for multiple active cameras for post processes like depth of field ([trevordev](https://github.com/trevordev))

			
 
				 - Integrates depth texture support in the engine ([sebavan](https://github.com/sebavan))

			
 
				-- NPM package now has a dependency system, updated during build. ([RaananW](https://github.com/RaananW))

			
 
				-- WebVRExperienceHelper will create an empty controller model so that controller interactions can be used while the actual model is still loading ([trevordev](https://github.com/trevordev))

			
 
				 - Default fragment shader will clamp negative values to avoid underflow, webVR post processing will render to eye texture size ([trevordev](https://github.com/trevordev))

			
 
				 - Supports Environment Drag and Drop in Sandbox ([sebavan](https://github.com/sebavan))

			
 
				 - EnvironmentHelper has no an onError observable to handle errors when loading the textures ([RaananW](https://github.com/RaananW))

			
 
				-- (Viewer) Viewer supports model animations and multi-model loading ([RaananW](https://github.com/RaananW))

			
 
				 - Tests for sharpen, chromatic aberration, default pipeline and enable/disable post processes ([trevordev](https://github.com/trevordev))

			
 
				 - onPointer* callbacks have now the event type as a 3rd variable ([RaananW](https://github.com/RaananW))

			
 
				 - Lightmap texture in PBR material follow the gammaSpace Flag of the texture ([sebavan](https://github.com/sebavan))

			
 
				 - Added setTextureFromPostProcessOutput to bind the output of a postprocess into an effect ([trevordev](https://github.com/trevordev))

			
 
				-- Added support for primitive modes to glTF 2.0 loader. ([bghgary](https://github.com/bghgary)]

			
 
				 - Updated bloom effect to only bloom areas of the image above a luminance threshold ([trevordev](https://github.com/trevordev))

			
 
				 - Cannon and Oimo are optional dependencies ([RaananW](https://github.com/RaananW))

			
 
				 - Shadows - Introduces [Normal Bias](https://doc.babylonjs.com/babylon101/shadows#normal-bias-since-32) ([sebavan](https://github.com/sebavan)))

			
 
				 - Earcut is an external, optional dependency. ([RaananW](https://github.com/RaananW))

			
 
				 - Return animation groups when calling `SceneLoader.ImportMesh`. ([bghgary](https://github.com/bghgary)]

			
 
				 - Add support for normalized and non-float data to `Buffer` and `VertexBuffer`. ([bghgary](https://github.com/bghgary)]

			
 
				-- Added unlit material extension support to glTF 2.0 loader. ([bghgary](https://github.com/bghgary))

			
 
				-- (Viewer) Viewer's declaration file automatically generated ([RaananW](https://github.com/RaananW))

			
 
				 - New serialize and parse functions for effect layers (Highlight and Glow layers) ([julien-moreau](https://github.com/julien-moreau))

			
 
				 - GUI: Introduced `MultiLine` which will draw lines between any number of meshes, controls and points. [Documentation](http://doc.babylonjs.com/how_to/gui#multiline) ([royibernthal](https://github.com/royibernthal))

			
 
				-- Added alphaCutOff support for StandardMaterial ([deltakosh](https://github.com/deltakosh))

			
 
				-- Add support for sparse accessors to glTF 2.0 loader. ([bghgary](https://github.com/bghgary))

			
 
				-- Add support for cameras to glTF 2.0 loader. ([bghgary](https://github.com/bghgary)]

			
 
				-- Add support for preprocessing urls to glTF 2.0 loader. ([bghgary](https://github.com/bghgary)]

			
 
				-- Viewer upgrade - see [PR](https://github.com/BabylonJS/Babylon.js/pull/4160) ([RaananW](https://github.com/RaananW))

			
 
				-- New serialize and parse functions for SSAO2 Rendering Pipeline ([julien-moreau](https://github.com/julien-moreau))

			
 
				+- Added `alphaCutOff` support for StandardMaterial ([deltakosh](https://github.com/deltakosh))

			
 
				+- New `serialize` and `Parse` functions for SSAO2 Rendering Pipeline ([julien-moreau](https://github.com/julien-moreau))

			
 
				 

			
 
				 ## Bug fixes

			
 
				 

			
 
				-- `setPivotMatrix` ws not setting pivot correctly. This is now fixed. We also introduced a new `setPreTransformMatrix` to reproduce the sometimes needed behavior of the previous `setPivotMatrix` function ([deltakosh](https://github.com/deltakosh))

			
 
				+- `setPivotMatrix` was not setting pivot correctly. This is now fixed. We also introduced a new `setPreTransformMatrix` to reproduce the sometimes needed behavior of the previous `setPivotMatrix` function ([deltakosh](https://github.com/deltakosh))

			
 
				 - SPS solid particle `.pivot` property now also behaves like the standard mesh pivot. Former behavior (particle translation) can be kept with the particle property `.translateFromPivot` set to true ([jbousquie](https://github.com/jbousquie))

			
 
				 - Texture extension detection in `Engine.CreateTexture` ([sebavan](https://github.com/sebavan))

			
 
				-- SPS internal temporary vector3 instead of Tmp.Vector3 to avoid possible concurrent uses ([jbousquie](https://github.com/jbousquie))

			
 
				+- SPS uses internal temporary Vector3 instead of Tmp.Vector3 to avoid possible concurrent uses ([jbousquie](https://github.com/jbousquie))

			
 
				 - Fixed a bug when calling load on an empty assets manager - [#3739](https://github.com/BabylonJS/Babylon.js/issues/3739) ([RaananW](https://github.com/RaananW))

			
 
				 - Enabling teleportation in the vr helper class caused a redundant post process to be added ([trevordev](https://github.com/trevordev))

			
 
				 - (Viewer) Fixed a bug where loading another mesh positioned it incorrectly ([RaananW](https://github.com/RaananW))

			
 
				-- Scale vr controllers by deviceScale when it is set in VRExperienceHelper ([trevordev](https://github.com/trevordev))

			
 
				 - (Viewer) Disabling templates now work correctly ([RaananW](https://github.com/RaananW))

			
 
				+- Scale vr controllers by deviceScale when it is set in VRExperienceHelper ([trevordev](https://github.com/trevordev))

			
 
				 - AMD "define" declaration is no longer anonymous ([RaananW](https://github.com/RaananW))

			
 
				 - Collision worker didn't initialize instanced meshes correctly - [#3819](https://github.com/BabylonJS/Babylon.js/issues/3819) ([RaananW](https://github.com/RaananW))

			
 
				-- postMessage calls in webworkers were fixed. ([RaananW](https://github.com/RaananW))

			
 
				+- `postMessage` calls in webworkers were fixed ([RaananW](https://github.com/RaananW))

			
 
				 - Fixed WebCam Texture on Firefox and Edge - [#3825](https://github.com/BabylonJS/Babylon.js/issues/3825) ([sebavan](https://github.com/sebavan))

			
 
				-- Add onLoadObservable on VideoTexture - [#3845](https://github.com/BabylonJS/Babylon.js/issues/3845) ([sebavan](https://github.com/sebavan))

			
 
				-- beforeRender is now triggered after the camera updated its state - [#3873](https://github.com/BabylonJS/Babylon.js/issues/3873) ([RaananW](https://github.com/RaananW))

			
 
				-- Tools.DeepCopy no longer copying getter-only elements - [#3929](https://github.com/BabylonJS/Babylon.js/issues/3929) ([RaananW](https://github.com/RaananW))

			
 
				+- Add `onLoadObservable` on VideoTexture - [#3845](https://github.com/BabylonJS/Babylon.js/issues/3845) ([sebavan](https://github.com/sebavan))

			
 
				+- `beforeRender` is now triggered after the camera updated its state - [#3873](https://github.com/BabylonJS/Babylon.js/issues/3873) ([RaananW](https://github.com/RaananW))

			
 
				 - Reflection and refraction no longer apply a toLinear conversion twice when applying image processing as a post process - [#4060](https://github.com/BabylonJS/Babylon.js/issues/4060) ([trevordev](https://github.com/trevordev))

			
 
				 - Fix ember.js compatibility in ```PostProcessRenderEffect``` ([sebavan](https://github.com/sebavan))

			
 
				 - Fix ember.js compatibility in ```BloomEffect``` and ```Camera``` ([kaysabelle](https://github.com/kaysabelle))

			
@@ -147,10 +146,10 @@
 
				 

			
 
				 ## Breaking changes

			
 
				 

			
 
				-- Removed the unused PostProcessRenderPass class and extended postProcessingRenderingEffect to support multiple PostProcesses ([trevordev](https://github.com/trevordev))

			
 
				-- VertexData.merge no longer supports merging of data that do not have the same set of attributes. ([bghgary](https://github.com/bghgary)]

			
 
				+- Removed the unused `PostProcessRenderPass` class and extended `postProcessingRenderingEffect` to support multiple PostProcesses ([trevordev](https://github.com/trevordev))

			
 
				+- `VertexData.merge` no longer supports merging of data that do not have the same set of attributes. ([bghgary](https://github.com/bghgary)]

			
 
				 - glTF 2.0 loader now creates a mesh for each primitive instead of merging the primitives together into one mesh. If a mesh only has one primitive, the behavior is the same as before. This change only affects meshes that have multiple primitives. ([bghgary](https://github.com/bghgary)]

			
 
				-- Engine's onCanvasPointerOutObservable will now return a PointerEvent instead of the Engine. ([trevordev](https://github.com/trevordev))

			
 
				+- Engine's `onCanvasPointerOutObservable` will now return a PointerEvent instead of the Engine. ([trevordev](https://github.com/trevordev))

			
 
				 - Removed public references to default rendering pipeline's internal post process ([trevordev](https://github.com/trevordev))

			
 
				 - `Bone.setScale` does not support scaleChildren property anymore. You can use `Bone.scale` to achieve the same effect ([deltakosh](https://github.com/deltakosh))

			
 
				 - Vector3 &amp; Vector4:

			
--- a/inspector/src/properties.ts
+++ b/inspector/src/properties.ts
@@ -121,6 +121,12 @@ module INSPECTOR {
 
				         'PhysicsImpostor': {

			
 
				             type: BABYLON.PhysicsImpostor

			
 
				         },

			
 
				+        'ImageProcessingConfiguration': {

			
 
				+            type: BABYLON.ImageProcessingConfiguration

			
 
				+        },

			
 
				+        'ColorCurves': {

			
 
				+            type: BABYLON.ColorCurves

			
 
				+        }

			
 
				     }

			
 
				 

			
 
				 }
			
--- a/loaders/src/glTF/2.0/Extensions/KHR_materials_unlit.ts
+++ b/loaders/src/glTF/2.0/Extensions/KHR_materials_unlit.ts
@@ -4,7 +4,7 @@ module BABYLON.GLTF2.Extensions {
 
				     const NAME = "KHR_materials_unlit";

			
 
				 

			
 
				     /**

			
 
				-     * [Specification](https://github.com/donmccurdy/glTF/tree/feat-khr-materials-cmnConstant/extensions/2.0/Khronos/KHR_materials_unlit) (Experimental)

			
 
				+     * [Specification](https://github.com/KhronosGroup/glTF/tree/master/extensions/2.0/Khronos/KHR_materials_unlit)

			
 
				      */

			
 
				     export class KHR_materials_unlit extends GLTFLoaderExtension {

			
 
				         public readonly name = NAME;

			
--- a/loaders/src/glTF/2.0/babylon.glTFLoader.ts
+++ b/loaders/src/glTF/2.0/babylon.glTFLoader.ts
@@ -507,9 +507,6 @@ module BABYLON.GLTF2 {
 
				             const babylonMesh = new Mesh(node.name || `node${node._index}`, this._babylonScene, node._parent._babylonMesh);

			
 
				             node._babylonMesh = babylonMesh;

			
 
				 

			
 
				-            node._babylonAnimationTargets = node._babylonAnimationTargets || [];

			
 
				-            node._babylonAnimationTargets.push(babylonMesh);

			
 
				-

			
 
				             GLTFLoader._LoadTransform(node, babylonMesh);

			
 
				 

			
 
				             if (node.mesh != undefined) {

			
@@ -818,8 +815,8 @@ module BABYLON.GLTF2 {
 
				             babylonBone = new Bone(node.name || `joint${node._index}`, skin._babylonSkeleton!, babylonParentBone, this._getNodeMatrix(node), null, null, boneIndex);

			
 
				             babylonBones[node._index] = babylonBone;

			
 
				 

			
 
				-            node._babylonAnimationTargets = node._babylonAnimationTargets || [];

			
 
				-            node._babylonAnimationTargets.push(babylonBone);

			
 
				+            node._babylonBones = node._babylonBones || [];

			
 
				+            node._babylonBones.push(babylonBone);

			
 
				 

			
 
				             return babylonBone;

			
 
				         }

			
@@ -939,7 +936,7 @@ module BABYLON.GLTF2 {
 
				 

			
 
				             // Ignore animations that have no animation targets.

			
 
				             if ((channel.target.path === AnimationChannelTargetPath.WEIGHTS && !targetNode._numMorphTargets) ||

			
 
				-                (channel.target.path !== AnimationChannelTargetPath.WEIGHTS && !targetNode._babylonAnimationTargets)) {

			
 
				+                (channel.target.path !== AnimationChannelTargetPath.WEIGHTS && !targetNode._babylonMesh)) {

			
 
				                 return Promise.resolve();

			
 
				             }

			
 
				 

			
@@ -1062,14 +1059,12 @@ module BABYLON.GLTF2 {
 
				                             outTangent: key.outTangent ? key.outTangent[targetIndex] : undefined

			
 
				                         })));

			
 
				 

			
 
				-                        const morphTargets = new Array<any>();

			
 
				                         this._forEachPrimitive(targetNode, babylonMesh => {

			
 
				                             const morphTarget = babylonMesh.morphTargetManager!.getTarget(targetIndex);

			
 
				-                            morphTarget.animations.push(babylonAnimation);

			
 
				-                            morphTargets.push(morphTarget);

			
 
				+                            const babylonAnimationClone = babylonAnimation.clone();

			
 
				+                            morphTarget.animations.push(babylonAnimationClone);

			
 
				+                            babylonAnimationGroup.addTargetedAnimation(babylonAnimationClone, morphTarget);

			
 
				                         });

			
 
				-

			
 
				-                        babylonAnimationGroup.addTargetedAnimation(babylonAnimation, morphTargets);

			
 
				                     }

			
 
				                 }

			
 
				                 else {

			
@@ -1077,12 +1072,16 @@ module BABYLON.GLTF2 {
 
				                     const babylonAnimation = new Animation(animationName, targetPath, 1, animationType);

			
 
				                     babylonAnimation.setKeys(keys);

			
 
				 

			
 
				-                    if (targetNode._babylonAnimationTargets) {

			
 
				-                        for (const babylonAnimationTarget of targetNode._babylonAnimationTargets) {

			
 
				+                    if (targetNode._babylonBones) {

			
 
				+                        const babylonAnimationTargets = [targetNode._babylonMesh!, ...targetNode._babylonBones];

			
 
				+                        for (const babylonAnimationTarget of babylonAnimationTargets) {

			
 
				                             babylonAnimationTarget.animations.push(babylonAnimation);

			
 
				                         }

			
 
				-

			
 
				-                        babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonAnimationTargets);

			
 
				+                        babylonAnimationGroup.addTargetedAnimation(babylonAnimation, babylonAnimationTargets);

			
 
				+                    }

			
 
				+                    else {

			
 
				+                        targetNode._babylonMesh!.animations.push(babylonAnimation);

			
 
				+                        babylonAnimationGroup.addTargetedAnimation(babylonAnimation, targetNode._babylonMesh);

			
 
				                     }

			
 
				                 }

			
 
				             });

			
--- a/loaders/src/glTF/2.0/babylon.glTFLoaderInterfaces.ts
+++ b/loaders/src/glTF/2.0/babylon.glTFLoaderInterfaces.ts
@@ -77,7 +77,7 @@ module BABYLON.GLTF2 {
 
				         _parent: _ILoaderNode;

			
 
				         _babylonMesh?: Mesh;

			
 
				         _primitiveBabylonMeshes?: Mesh[];

			
 
				-        _babylonAnimationTargets?: Node[];

			
 
				+        _babylonBones?: Bone[];

			
 
				         _numMorphTargets?: number;

			
 
				     }

			
 
				 

			
--- a/loaders/src/glTF/babylon.glTFFileLoader.ts
+++ b/loaders/src/glTF/babylon.glTFFileLoader.ts
@@ -592,17 +592,14 @@ module BABYLON {
 
				             loader.onTextureLoadedObservable.add(texture => this.onTextureLoadedObservable.notifyObservers(texture));

			
 
				             loader.onMaterialLoadedObservable.add(material => this.onMaterialLoadedObservable.notifyObservers(material));

			
 
				             loader.onCameraLoadedObservable.add(camera => this.onCameraLoadedObservable.notifyObservers(camera));

			
 
				-

			
 
				-            loader.onExtensionLoadedObservable.add(extension => {

			
 
				-                this.onExtensionLoadedObservable.notifyObservers(extension);

			
 
				-                this.onExtensionLoadedObservable.clear();

			
 
				-            });

			
 
				+            loader.onExtensionLoadedObservable.add(extension => this.onExtensionLoadedObservable.notifyObservers(extension));

			
 
				 

			
 
				             loader.onCompleteObservable.add(() => {

			
 
				                 this.onMeshLoadedObservable.clear();

			
 
				                 this.onTextureLoadedObservable.clear();

			
 
				                 this.onMaterialLoadedObservable.clear();

			
 
				                 this.onCameraLoadedObservable.clear();

			
 
				+                this.onExtensionLoadedObservable.clear();

			
 
				 

			
 
				                 this.onCompleteObservable.notifyObservers(this);

			
 
				                 this.onCompleteObservable.clear();

			
--- a/materialsLibrary/src/cell/cell.fragment.fx
+++ b/materialsLibrary/src/cell/cell.fragment.fx
@@ -138,7 +138,7 @@ void main(void)
 
				 	alpha *= vColor.a;

			
 
				 #endif

			
 
				 

			
 
				-	vec3 finalDiffuse = clamp(diffuseBase * diffuseColor, 0.0, 1.0) * baseColor.rgb;;

			
 
				+	vec3 finalDiffuse = clamp(diffuseBase * diffuseColor, 0.0, 1.0) * baseColor.rgb;

			
 
				 

			
 
				 	// Composition

			
 
				 	vec4 color = vec4(finalDiffuse, alpha);

			
--- a/package.json
+++ b/package.json
@@ -9,7 +9,7 @@
 
				     ],
			
 
				     "name": "babylonjs",
			
 
				     "description": "Babylon.js is a JavaScript 3D engine based on webgl.",
			
 
				-    "version": "3.2.0-rc.2",
			
 
				+    "version": "3.2.0-rc.3",
			
 
				     "repository": {
			
 
				         "type": "git",
			
 
				         "url": "https://github.com/BabylonJS/Babylon.js.git"
			
--- a/sandbox/index.css
+++ b/sandbox/index.css
@@ -107,7 +107,7 @@ a {
 
				 }

			
 
				 

			
 
				 #droptext {

			
 
				-    position: absolute;;

			
 
				+    position: absolute;

			
 
				     text-align: center;

			
 
				     color: #fff;

			
 
				     height: 50px;

			
--- a/src/Animations/babylon.animatable.ts
+++ b/src/Animations/babylon.animatable.ts
@@ -136,13 +136,7 @@
 
				             var runtimeAnimations = this._runtimeAnimations;

			
 
				 

			
 
				             for (var index = 0; index < runtimeAnimations.length; index++) {

			
 
				-                runtimeAnimations[index].reset();

			
 
				-            }

			
 
				-

			
 
				-            // Reset to original value

			
 
				-            for (index = 0; index < runtimeAnimations.length; index++) {

			
 
				-                var animation = runtimeAnimations[index];

			
 
				-                animation.animate(0, this.fromFrame, this.toFrame, false, this._speedRatio);

			
 
				+                runtimeAnimations[index].reset(true);

			
 
				             }

			
 
				 

			
 
				             this._localDelayOffset = null;

			
--- a/src/Animations/babylon.animationGroup.ts
+++ b/src/Animations/babylon.animationGroup.ts
@@ -115,12 +115,12 @@ module BABYLON {
 
				         /**

			
 
				          * This function will normalize every animation in the group to make sure they all go from beginFrame to endFrame

			
 
				          * It can add constant keys at begin or end

			
 
				-         * @param beginFrame defines the new begin frame for all animations. It can't be bigger than the smallest begin frame of all animations

			
 
				-         * @param endFrame defines the new end frame for all animations. It can't be smaller than the largest end frame of all animations

			
 
				+         * @param beginFrame defines the new begin frame for all animations or the smallest begin frame of all animations if null (defaults to 0)

			
 
				+         * @param endFrame defines the new end frame for all animations or the largest end frame of all animations if null (defaults to null)

			
 
				          */

			
 
				-        public normalize(beginFrame = -Number.MAX_VALUE, endFrame = Number.MAX_VALUE): AnimationGroup {

			
 
				-            beginFrame = Math.max(beginFrame, this._from);

			
 
				-            endFrame = Math.min(endFrame, this._to);

			
 
				+        public normalize(beginFrame: Nullable<number> = 0, endFrame: Nullable<number> = null): AnimationGroup {

			
 
				+            if (beginFrame == null) beginFrame = this._from;

			
 
				+            if (endFrame == null) endFrame = this._to;

			
 
				 

			
 
				             for (var index = 0; index < this._targetedAnimations.length; index++) {

			
 
				                 let targetedAnimation = this._targetedAnimations[index];

			
@@ -151,6 +151,9 @@ module BABYLON {
 
				                 }

			
 
				             }

			
 
				 

			
 
				+            this._from = beginFrame;

			
 
				+            this._to = endFrame;

			
 
				+

			
 
				             return this;

			
 
				         }

			
 
				 

			
--- a/src/Animations/babylon.runtimeAnimation.ts
+++ b/src/Animations/babylon.runtimeAnimation.ts
@@ -164,8 +164,13 @@
 
				 

			
 
				         /**

			
 
				          * Resets the runtime animation to the beginning

			
 
				+         * @param restoreOriginal defines whether to restore the target property to the original value

			
 
				          */

			
 
				-        public reset(): void {

			
 
				+        public reset(restoreOriginal = false): void {

			
 
				+            if (restoreOriginal && this._originalValue != null) {

			
 
				+                this.setValue(this._originalValue, -1);

			
 
				+            }

			
 
				+

			
 
				             this._offsetsCache = {};

			
 
				             this._highLimitsCache = {};

			
 
				             this._currentFrame = 0;

			
@@ -212,9 +217,9 @@
 
				         }

			
 
				 

			
 
				         /**

			
 
				-         * Affect the interpolated value to the target

			
 
				+         * Apply the interpolated value to the target

			
 
				          * @param currentValue defines the value computed by the animation

			
 
				-         * @param weight defines the weight to apply to this value

			
 
				+         * @param weight defines the weight to apply to this value (Defaults to 1.0)

			
 
				          */

			
 
				         public setValue(currentValue: any, weight = 1.0): void {

			
 
				             if (this._target instanceof Array) {

			
@@ -227,13 +232,7 @@
 
				             }

			
 
				         }

			
 
				 

			
 
				-        /**

			
 
				-         * Sets the value of the runtime animation

			
 
				-         * @param target The target property of the runtime animation

			
 
				-         * @param currentValue The current value to use for the runtime animation

			
 
				-         * @param weight The weight to use for the runtime animation (Defaults to 1.0)

			
 
				-         */

			
 
				-        private _setValue(target: any, currentValue: any, weight = 1.0): void {

			
 
				+        private _setValue(target: any, currentValue: any, weight: number): void {

			
 
				             // Set value

			
 
				             var path: any;

			
 
				             var destination: any;

			
@@ -258,10 +257,24 @@
 
				             this._activeTarget = destination;

			
 
				             this._weight = weight;

			
 
				 

			
 
				+            if (!this._originalValue) {

			
 
				+                let originalValue: any;

			
 
				+

			
 
				+                if (destination.getRestPose && path === "_matrix") { // For bones

			
 
				+                    originalValue = destination.getRestPose();

			
 
				+                } else {

			
 
				+                    originalValue = destination[path];

			
 
				+                }

			
 
				+

			
 
				+                if (originalValue && originalValue.clone) {

			
 
				+                    this._originalValue = originalValue.clone();

			
 
				+                } else {

			
 
				+                    this._originalValue = originalValue;

			
 
				+                }

			
 
				+            }

			
 
				+

			
 
				             // Blending

			
 
				-            let enableBlending = target && target.animationPropertiesOverride ? target.animationPropertiesOverride.enableBlending : this._animation.enableBlending;

			
 
				-            let blendingSpeed = target && target.animationPropertiesOverride ? target.animationPropertiesOverride.blendingSpeed : this._animation.blendingSpeed;

			
 
				-            

			
 
				+            const enableBlending = target && target.animationPropertiesOverride ? target.animationPropertiesOverride.enableBlending : this._animation.enableBlending;

			
 
				             if (enableBlending && this._blendingFactor <= 1.0) {

			
 
				                 if (!this._originalBlendValue) {

			
 
				                     let originalValue = destination[path];

			
@@ -272,27 +285,7 @@
 
				                         this._originalBlendValue = originalValue;

			
 
				                     }

			
 
				                 }

			
 
				-            }

			
 
				 

			
 
				-            if (weight !== -1.0) {

			
 
				-                if (!this._originalValue) {

			
 
				-                    let originalValue: any;

			
 
				-

			
 
				-                    if (destination.getRestPose && path === "_matrix") { // For bones

			
 
				-                        originalValue = destination.getRestPose();

			
 
				-                    } else {

			
 
				-                        originalValue = destination[path];

			
 
				-                    }

			
 
				-

			
 
				-                    if (originalValue.clone) {

			
 
				-                        this._originalValue = originalValue.clone();

			
 
				-                    } else {

			
 
				-                        this._originalValue = originalValue;

			
 
				-                    }

			
 
				-                }

			
 
				-            }

			
 
				-

			
 
				-            if (enableBlending && this._blendingFactor <= 1.0) {

			
 
				                 if (this._originalBlendValue.m) { // Matrix

			
 
				                     if (Animation.AllowMatrixDecomposeForInterpolation) {

			
 
				                         if (this._currentValue) {

			
@@ -319,6 +312,8 @@
 
				                         this._currentValue = currentValue;

			
 
				                     }

			
 
				                 }

			
 
				+

			
 
				+                const blendingSpeed = target && target.animationPropertiesOverride ? target.animationPropertiesOverride.blendingSpeed : this._animation.blendingSpeed;

			
 
				                 this._blendingFactor += blendingSpeed;

			
 
				             } else {

			
 
				                 this._currentValue = currentValue;

			
--- a/src/Cameras/VR/babylon.vrExperienceHelper.ts
+++ b/src/Cameras/VR/babylon.vrExperienceHelper.ts
@@ -43,6 +43,8 @@ module BABYLON {
 
				         public _teleportationEnabled: boolean;

			
 
				         public _teleportationRequestInitiated = false;

			
 
				         public _teleportationBackRequestInitiated = false;

			
 
				+        public _rotationRightAsked = false;

			
 
				+        public _rotationLeftAsked = false;

			
 
				         public _dpadPressed = true;

			
 
				 

			
 
				         public _activePointer = false;

			
@@ -93,12 +95,15 @@ module BABYLON {
 
				             this._activePointer = false;

			
 
				         }

			
 
				 

			
 
				-        public _updatePointerDistance(distance:number) {

			
 
				+        public _updatePointerDistance(distance:number = 100) {

			
 
				         }

			
 
				 

			
 
				         public dispose(){

			
 
				             this._interactionsEnabled = false;

			
 
				             this._teleportationEnabled = false;

			
 
				+            if(this._gazeTracker){

			
 
				+                this._gazeTracker.dispose()

			
 
				+            }

			
 
				         }

			
 
				     }

			
 
				 

			
@@ -172,7 +177,7 @@ module BABYLON {
 
				             this._laserPointer.parent = mesh;

			
 
				         }

			
 
				 

			
 
				-        public _updatePointerDistance(distance:number) {

			
 
				+        public _updatePointerDistance(distance:number = 100) {

			
 
				             this._laserPointer.scaling.y = distance;

			
 
				             this._laserPointer.position.z = -distance / 2;  

			
 
				         }

			
@@ -280,8 +285,6 @@ module BABYLON {
 
				         private _floorMeshesCollection: Mesh[] = [];

			
 
				         private _rotationAllowed: boolean = true;

			
 
				         private _teleportBackwardsVector = new Vector3(0, -1, -1);

			
 
				-        private _rotationRightAsked = false;

			
 
				-        private _rotationLeftAsked = false;

			
 
				         private _teleportationTarget: Mesh;

			
 
				         private _isDefaultTeleportationTarget = true;

			
 
				         private _postProcessMove: ImageProcessingPostProcess;

			
@@ -443,7 +446,7 @@ module BABYLON {
 
				                 if (this.rightController) {

			
 
				                     this.rightController._activatePointer();

			
 
				                 }

			
 
				-                else if (this.leftController) {

			
 
				+                if (this.leftController) {

			
 
				                     this.leftController._activatePointer();

			
 
				                 }

			
 
				             }

			
@@ -1157,29 +1160,29 @@ module BABYLON {
 
				                 return;

			
 
				             }

			
 
				 

			
 
				-            if (!this._rotationLeftAsked) {

			
 
				+            if (!gazer._rotationLeftAsked) {

			
 
				                 if (stateObject.x < -this._padSensibilityUp && gazer._dpadPressed) {

			
 
				-                    this._rotationLeftAsked = true;

			
 
				+                    gazer._rotationLeftAsked = true;

			
 
				                     if (this._rotationAllowed) {

			
 
				                         this._rotateCamera(false);

			
 
				                     }

			
 
				                 }

			
 
				             } else {

			
 
				                 if (stateObject.x > -this._padSensibilityDown) {

			
 
				-                    this._rotationLeftAsked = false;

			
 
				+                    gazer._rotationLeftAsked = false;

			
 
				                 }

			
 
				             }

			
 
				 

			
 
				-            if (!this._rotationRightAsked) {

			
 
				+            if (!gazer._rotationRightAsked) {

			
 
				                 if (stateObject.x > this._padSensibilityUp && gazer._dpadPressed) {

			
 
				-                    this._rotationRightAsked = true;

			
 
				+                    gazer._rotationRightAsked = true;

			
 
				                     if (this._rotationAllowed) {

			
 
				                         this._rotateCamera(true);

			
 
				                     }

			
 
				                 }

			
 
				             } else {

			
 
				                 if (stateObject.x < this._padSensibilityDown) {

			
 
				-                    this._rotationRightAsked = false;

			
 
				+                    gazer._rotationRightAsked = false;

			
 
				                 }

			
 
				             }

			
 
				         }

			
@@ -1243,8 +1246,8 @@ module BABYLON {
 
				                     controller.webVRController.onPadStateChangedObservable.add((stateObject) => {

			
 
				                         controller._dpadPressed = stateObject.pressed;

			
 
				                         if (!controller._dpadPressed) {

			
 
				-                            this._rotationLeftAsked = false;

			
 
				-                            this._rotationRightAsked = false;

			
 
				+                            controller._rotationLeftAsked = false;

			
 
				+                            controller._rotationRightAsked = false;

			
 
				                             controller._teleportationBackRequestInitiated = false;

			
 
				                         }

			
 
				                     });

			
@@ -1611,6 +1614,7 @@ module BABYLON {
 
				                 gazer._updatePointerDistance(hit.distance);        

			
 
				             }

			
 
				             else {

			
 
				+                gazer._updatePointerDistance();   

			
 
				                 gazer._gazeTracker.isVisible = false;

			
 
				             }

			
 
				 

			
--- a/src/Engine/babylon.engine.ts
+++ b/src/Engine/babylon.engine.ts
@@ -726,7 +726,7 @@
 
				          * Returns the current version of the framework

			
 
				          */

			
 
				         public static get Version(): string {

			
 
				-            return "3.2.0-rc.2";

			
 
				+            return "3.2.0-rc.3";

			
 
				         }

			
 
				 

			
 
				         // Updatable statics so stick with vars here

			
--- a/src/Engine/babylon.nullEngine.ts
+++ b/src/Engine/babylon.nullEngine.ts
@@ -428,5 +428,8 @@
 
				 

			
 
				             return false;

			
 
				         }

			
 
				+

			
 
				+        public releaseEffects() {

			
 
				+        }

			
 
				     }

			
 
				 }

			
--- a/src/Lights/babylon.spotLight.ts
+++ b/src/Lights/babylon.spotLight.ts
@@ -67,7 +67,7 @@
 
				             return this._projectionTextureMatrix;

			
 
				         }

			
 
				 

			
 
				-        protected _projectionTextureLightNear : number = 1e-6;;

			
 
				+        protected _projectionTextureLightNear : number = 1e-6;

			
 
				         /**

			
 
				          * Gets the near clip of the Spotlight for texture projection.

			
 
				          */

			
--- a/src/Loading/babylon.sceneLoader.ts
+++ b/src/Loading/babylon.sceneLoader.ts
@@ -494,7 +494,8 @@
 
				                     });

			
 
				                 }, onProgress, (scene, message, exception) => {

			
 
				                     reject(exception || new Error(message));

			
 
				-                });

			
 
				+                },

			
 
				+                pluginExtension);

			
 
				             });

			
 
				         }

			
 
				 

			
--- a/src/Materials/PBR/babylon.pbrBaseMaterial.ts
+++ b/src/Materials/PBR/babylon.pbrBaseMaterial.ts
@@ -1611,7 +1611,7 @@
 
				 

			
 
				             this._uniformBuffer.update();

			
 
				 

			
 
				-            this._afterBind(mesh);

			
 
				+            this._afterBind(mesh, this._activeEffect);

			
 
				         }

			
 
				 

			
 
				         /**

			
--- a/src/Materials/Textures/babylon.dynamicTexture.ts
+++ b/src/Materials/Textures/babylon.dynamicTexture.ts
@@ -140,7 +140,7 @@
 
				                 x = (size.width - textSize.width) / 2;

			
 
				             }

			
 
				             if (y === null || y === undefined) {

			
 
				-                var fontSize = parseInt((font.replace(/\D/g, '')));;

			
 
				+                var fontSize = parseInt((font.replace(/\D/g, '')));

			
 
				                 y = (size.height / 2) + (fontSize / 3.65);

			
 
				             }

			
 
				 

			
--- a/src/Materials/babylon.material.ts
+++ b/src/Materials/babylon.material.ts
@@ -1368,7 +1368,7 @@
 
				             }

			
 
				 

			
 
				             var materialType = Tools.Instantiate(parsedMaterial.customType);

			
 
				-            return materialType.Parse(parsedMaterial, scene, rootUrl);;

			
 
				+            return materialType.Parse(parsedMaterial, scene, rootUrl);

			
 
				         }

			
 
				     }

			
 
				 } 

			
--- a/src/Materials/babylon.standardMaterial.ts
+++ b/src/Materials/babylon.standardMaterial.ts
@@ -120,49 +120,49 @@ module BABYLON {
 
				 

			
 
				     export class StandardMaterial extends PushMaterial {

			
 
				         @serializeAsTexture("diffuseTexture")

			
 
				-        private _diffuseTexture: Nullable<BaseTexture>;;

			
 
				+        private _diffuseTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesAndMiscDirty")

			
 
				-        public diffuseTexture: Nullable<BaseTexture>;;

			
 
				+        public diffuseTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsTexture("ambientTexture")

			
 
				-        private _ambientTexture: Nullable<BaseTexture>;;

			
 
				+        private _ambientTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesDirty")

			
 
				-        public ambientTexture: Nullable<BaseTexture>;;

			
 
				+        public ambientTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsTexture("opacityTexture")

			
 
				-        private _opacityTexture: Nullable<BaseTexture>;;

			
 
				+        private _opacityTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesAndMiscDirty")

			
 
				-        public opacityTexture: Nullable<BaseTexture>;;

			
 
				+        public opacityTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsTexture("reflectionTexture")

			
 
				-        private _reflectionTexture: Nullable<BaseTexture>;;

			
 
				+        private _reflectionTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesDirty")

			
 
				         public reflectionTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsTexture("emissiveTexture")

			
 
				-        private _emissiveTexture: Nullable<BaseTexture>;;

			
 
				+        private _emissiveTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesDirty")

			
 
				-        public emissiveTexture: Nullable<BaseTexture>;;

			
 
				+        public emissiveTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsTexture("specularTexture")

			
 
				-        private _specularTexture: Nullable<BaseTexture>;;

			
 
				+        private _specularTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesDirty")

			
 
				-        public specularTexture: Nullable<BaseTexture>;;

			
 
				+        public specularTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsTexture("bumpTexture")

			
 
				-        private _bumpTexture: Nullable<BaseTexture>;;

			
 
				+        private _bumpTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesDirty")

			
 
				-        public bumpTexture: Nullable<BaseTexture>;;

			
 
				+        public bumpTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsTexture("lightmapTexture")

			
 
				-        private _lightmapTexture: Nullable<BaseTexture>;;

			
 
				+        private _lightmapTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesDirty")

			
 
				-        public lightmapTexture: Nullable<BaseTexture>;;

			
 
				+        public lightmapTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsTexture("refractionTexture")

			
 
				-        private _refractionTexture: Nullable<BaseTexture>;;

			
 
				+        private _refractionTexture: Nullable<BaseTexture>;

			
 
				         @expandToProperty("_markAllSubMeshesAsTexturesDirty")

			
 
				-        public refractionTexture: Nullable<BaseTexture>;;

			
 
				+        public refractionTexture: Nullable<BaseTexture>;

			
 
				 

			
 
				         @serializeAsColor3("ambient")

			
 
				         public ambientColor = new Color3(0, 0, 0);

			
--- a/src/Mesh/babylon.abstractMesh.ts
+++ b/src/Mesh/babylon.abstractMesh.ts
@@ -1151,7 +1151,7 @@
 
				          * @returns true if the mesh is completely in the frustum planes 

			
 
				          */

			
 
				         public isCompletelyInFrustum(frustumPlanes: Plane[]): boolean {

			
 
				-            return this._boundingInfo !== null && this._boundingInfo.isCompletelyInFrustum(frustumPlanes);;

			
 
				+            return this._boundingInfo !== null && this._boundingInfo.isCompletelyInFrustum(frustumPlanes);

			
 
				         }

			
 
				 

			
 
				         /** 

			
--- a/src/Mesh/babylon.geometry.ts
+++ b/src/Mesh/babylon.geometry.ts
@@ -387,11 +387,10 @@
 
				                  return null;

			
 
				             }

			
 
				 

			
 
				-            const defaultStride = VertexBuffer.DeduceStride(vertexBuffer.getKind());

			
 
				-            const defaultByteStride = defaultStride * VertexBuffer.GetTypeByteLength(vertexBuffer.type);

			
 
				-            const count = this._totalVertices * defaultStride;

			
 
				+            const tightlyPackedByteStride = vertexBuffer.getSize() * VertexBuffer.GetTypeByteLength(vertexBuffer.type);

			
 
				+            const count = this._totalVertices * vertexBuffer.getSize();

			
 
				 

			
 
				-            if (vertexBuffer.type !== VertexBuffer.FLOAT || vertexBuffer.byteStride !== defaultByteStride) {

			
 
				+            if (vertexBuffer.type !== VertexBuffer.FLOAT || vertexBuffer.byteStride !== tightlyPackedByteStride) {

			
 
				                 const copy = new Array<number>(count);

			
 
				                 vertexBuffer.forEach(count, (value, index) => {

			
 
				                     copy[index] = value;

			
@@ -399,7 +398,7 @@
 
				                 return copy;

			
 
				             }

			
 
				 

			
 
				-            if (!(data instanceof Array || data instanceof Float32Array) || vertexBuffer.byteOffset !== 0 || data.length !== count) {

			
 
				+            if (!((data instanceof Array) || (data instanceof Float32Array)) || vertexBuffer.byteOffset !== 0 || data.length !== count) {

			
 
				                 if (data instanceof Array) {

			
 
				                     const offset = vertexBuffer.byteOffset / 4;

			
 
				                     return Tools.Slice(data, offset, offset + count);

			
--- a/src/Mesh/babylon.meshBuilder.ts
+++ b/src/Mesh/babylon.meshBuilder.ts
@@ -649,7 +649,7 @@
 
				             var p = 0;

			
 
				             var step = pi2 / tessellation * arc;

			
 
				             var rotated;

			
 
				-            var path = new Array<Vector3>();;

			
 
				+            var path = new Array<Vector3>();

			
 
				             for (i = 0; i <= tessellation; i++) {

			
 
				                 var path: Vector3[] = [];

			
 
				                 if (cap == Mesh.CAP_START || cap == Mesh.CAP_ALL) {

			
--- a/src/Mesh/babylon.vertexBuffer.ts
+++ b/src/Mesh/babylon.vertexBuffer.ts
@@ -423,7 +423,7 @@
 
				                 case VertexBuffer.BYTE: {

			
 
				                     let value = dataView.getInt8(byteOffset);

			
 
				                     if (normalized) {

			
 
				-                        value = (value + 0.5) / 127.5;

			
 
				+                        value = Math.max(value / 127, -1);

			
 
				                     }

			
 
				                     return value;

			
 
				                 }

			
@@ -437,7 +437,7 @@
 
				                 case VertexBuffer.SHORT: {

			
 
				                     let value = dataView.getInt16(byteOffset, true);

			
 
				                     if (normalized) {

			
 
				-                        value = (value + 0.5) / 16383.5;

			
 
				+                        value = Math.max(value / 16383, -1);

			
 
				                     }

			
 
				                     return value;

			
 
				                 }

			
--- a/src/Morph/babylon.morphTarget.ts
+++ b/src/Morph/babylon.morphTarget.ts
@@ -9,6 +9,7 @@ module BABYLON {
 
				          */

			
 
				         public animations = new Array<Animation>();

			
 
				 

			
 
				+        private _scene: Nullable<Scene>;

			
 
				         private _positions: Nullable<FloatArray> = null;

			
 
				         private _normals: Nullable<FloatArray> = null;

			
 
				         private _tangents: Nullable<FloatArray> = null;

			
@@ -39,6 +40,23 @@ module BABYLON {
 
				             }

			
 
				         }

			
 
				 

			
 
				+        

			
 
				+        private _animationPropertiesOverride: Nullable<AnimationPropertiesOverride> = null;

			
 
				+

			
 
				+        /**

			
 
				+         * Gets or sets the animation properties override

			
 
				+         */

			
 
				+        public get animationPropertiesOverride(): Nullable<AnimationPropertiesOverride> {

			
 
				+            if (!this._animationPropertiesOverride && this._scene) {

			
 
				+                return this._scene.animationPropertiesOverride;

			
 
				+            }

			
 
				+            return this._animationPropertiesOverride;

			
 
				+        }

			
 
				+

			
 
				+        public set animationPropertiesOverride(value: Nullable<AnimationPropertiesOverride>) {

			
 
				+            this._animationPropertiesOverride = value;

			
 
				+        }        

			
 
				+

			
 
				         /**

			
 
				          * Creates a new MorphTarget

			
 
				          * @param name defines the name of the target

			
@@ -46,8 +64,9 @@ module BABYLON {
 
				          */

			
 
				         public constructor(

			
 
				             /** defines the name of the target */

			
 
				-            public name: string, influence = 0) {

			
 
				-            this.influence = influence;

			
 
				+            public name: string, influence = 0, scene: Nullable<Scene> = null) {

			
 
				+                this._scene = scene || Engine.LastCreatedScene;

			
 
				+                this.influence = influence;

			
 
				         }

			
 
				 

			
 
				         /**

			
@@ -186,7 +205,7 @@ module BABYLON {
 
				                 name = mesh.name;

			
 
				             }

			
 
				 

			
 
				-            var result = new MorphTarget(name, influence);

			
 
				+            var result = new MorphTarget(name, influence, mesh.getScene());

			
 
				 

			
 
				             result.setPositions(<FloatArray>mesh.getVerticesData(VertexBuffer.PositionKind));

			
 
				 

			
--- a/src/Particles/EmitterTypes/babylon.boxParticleEmitter.ts
+++ b/src/Particles/EmitterTypes/babylon.boxParticleEmitter.ts
@@ -107,10 +107,10 @@ module BABYLON {
 
				             var serializationObject: any = {};

			
 
				 

			
 
				             serializationObject.type = this.getClassName();

			
 
				-            serializationObject.direction1  = this.direction1.asArray();;

			
 
				-            serializationObject.direction2  = this.direction2.asArray();;

			
 
				-            serializationObject.minEmitBox  = this.minEmitBox.asArray();;

			
 
				-            serializationObject.maxEmitBox  = this.maxEmitBox.asArray();;

			
 
				+            serializationObject.direction1  = this.direction1.asArray();

			
 
				+            serializationObject.direction2  = this.direction2.asArray();

			
 
				+            serializationObject.minEmitBox  = this.minEmitBox.asArray();

			
 
				+            serializationObject.maxEmitBox  = this.maxEmitBox.asArray();

			
 
				 

			
 
				             return serializationObject;

			
 
				         }

			
--- a/src/Particles/EmitterTypes/babylon.sphereParticleEmitter.ts
+++ b/src/Particles/EmitterTypes/babylon.sphereParticleEmitter.ts