Merge remote-tracking branch 'upstream/master' into return-animationGroup

Playground/index-local.html

@@ -13,9 +13,10 @@
         <!-- jszip -->
         <script src="js/libs/jszip.min.js"></script>
         <script src="js/libs/fileSaver.js"></script>
-        <!-- Physics -->
+        <!-- Dependencies -->
         <script src="../dist/preview%20release/cannon.js"></script>
         <script src="../dist/preview%20release/Oimo.js"></script>
+        <script src="../dist/preview%20release/earcut.min.js"></script>
         <!--Monaco-->
         <script src="node_modules/monaco-editor/min/vs/loader.js"></script>
         <!-- Babylon.js -->

Playground/index.html

@@ -33,9 +33,10 @@
         <!-- jszip -->
         <script src="js/libs/jszip.min.js"></script>
         <script src="js/libs/fileSaver.js"></script>
-        <!-- Physics -->
+        <!-- Dependencies -->
         <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>
         <!--Monaco-->
         <script src="node_modules/monaco-editor/min/vs/loader.js"></script>
         <!-- Babylon.js -->

Tools/Gulp/config.json

@@ -27,6 +27,11 @@
                 "name": "OIMO",
                 "module": "oimo",
                 "optional": true
+            },
+            {
+                "name": "earcut",
+                "module": "earcut",
+                "optional": true
             }
         ]
     },
@@ -74,7 +79,9 @@
             "additionalPostProcess_fxaa",
             "additionalPostProcess_circleOfConfusion",
             "additionalPostProcess_depthOfFieldMerge",
+            "additionalPostProcess_bloomMerge",
             "additionalPostProcess_depthOfFieldEffect",
+            "additionalPostProcess_bloomEffect",
             "additionalPostProcess_imageProcessing",
             "bones",
             "hdr",
@@ -110,75 +117,6 @@
             "meshBuilder",
             "freeCamera",
             "hemisphericLight"
-        ],
-        "minimalGLTFViewer": [
-            "pbrMaterial",
-            "freeCamera",
-            "arcRotateCamera",
-            "hemisphericLight",
-            "pointLight",
-            "directionalLight",
-            "spotLight",
-            "animations",
-            "actions",
-            "sprites",
-            "picking",
-            "collisions",
-            "particles",
-            "solidParticles",
-            "additionalMeshes",
-            "meshBuilder",
-            "meshCompression",
-            "audio",
-            "additionalTextures",
-            "shadows",
-            "loader",
-            "userData",
-            "offline",
-            "fresnel",
-            "multiMaterial",
-            "touchCamera",
-            "procedural",
-            "gamepad",
-            "additionalCameras",
-            "postProcesses",
-            "renderingPipeline",
-            "additionalRenderingPipeline",
-            "defaultRenderingPipeline",
-            "depthRenderer",
-            "geometryBufferRenderer",
-            "additionalPostProcesses",
-            "additionalPostProcess_blur",
-            "additionalPostProcess_fxaa",
-            "additionalPostProcess_imageProcessing",
-            "bones",
-            "hdr",
-            "polygonMesh",
-            "csg",
-            "lensFlares",
-            "physics",
-            "textureFormats",
-            "debug",
-            "morphTargets",
-            "octrees",
-            "vr",
-            "virtualJoystick",
-            "optimizations",
-            "highlights",
-            "assetsManager",
-            "serialization",
-            "probes",
-            "layer",
-            "textureTools",
-            "cameraBehaviors",
-            "instrumentation",
-            "backgroundMaterial",
-            "environmentHelper",
-            "materialsLibrary/babylon.gridMaterial.js",
-            "loaders/babylon.glTFFileLoader.js"
-        ],
-        "distributed": [
-            "minimalGLTFViewer"
         ]
     },
     "workloads": {
@@ -803,6 +741,17 @@
                 "chromaticAberration.fragment"
             ]
         },
+        "additionalPostProcess_grain": {
+            "files": [
+                "../../src/PostProcess/babylon.grainPostProcess.js"
+            ],
+            "dependUpon": [
+                "postProcesses"
+            ],
+            "shaders": [
+                "grain.fragment"
+            ]
+        },
         "additionalPostProcess_depthOfFieldMerge": {
             "files": [
                 "../../src/PostProcess/babylon.depthOfFieldMergePostProcess.js"
@@ -814,6 +763,17 @@
                 "depthOfFieldMerge.fragment"
             ]
         },
+        "additionalPostProcess_bloomMerge": {
+            "files": [
+                "../../src/PostProcess/babylon.bloomMergePostProcess.js"
+            ],
+            "dependUpon": [
+                "postProcesses"
+            ],
+            "shaders": [
+                "bloomMerge.fragment"
+            ]
+        },
         "additionalPostProcess_depthOfFieldEffect": {
             "files": [
                 "../../src/PostProcess/babylon.depthOfFieldEffect.js"
@@ -824,6 +784,16 @@
                 "additionalPostProcess_circleOfConfusion"
             ]
         },
+        "additionalPostProcess_bloomEffect": {
+            "files": [
+                "../../src/PostProcess/babylon.bloomEffect.js"
+            ],
+            "dependUpon": [
+                "additionalPostProcess_blur",
+                "additionalPostProcess_bloomMerge",
+                "additionalPostProcess_extractHighlights"
+            ]
+        },
         "additionalPostProcess_fxaa": {
             "files": [
                 "../../src/PostProcess/babylon.fxaaPostProcess.js"
@@ -847,6 +817,17 @@
                 "highlights.fragment"
             ]
         },
+        "additionalPostProcess_extractHighlights": {
+            "files": [
+                "../../src/PostProcess/babylon.extractHighlightsPostProcess.js"
+            ],
+            "dependUpon": [
+                "postProcesses"
+            ],
+            "shaders": [
+                "extractHighlights.fragment"
+            ]
+        },
         "additionalPostProcess_imageProcessing": {
             "files": [
                 "../../src/PostProcess/babylon.imageProcessingPostProcess.js"
@@ -866,6 +847,7 @@
                 "../../src/PostProcess/babylon.convolutionPostProcess.js",
                 "../../src/PostProcess/babylon.sharpenPostProcess.js",
                 "../../src/PostProcess/babylon.chromaticAberrationPostProcess.js",
+                "../../src/PostProcess/babylon.grainPostProcess.js",
                 "../../src/PostProcess/babylon.filterPostProcess.js",
                 "../../src/PostProcess/babylon.fxaaPostProcess.js",
                 "../../src/PostProcess/babylon.volumetricLightScatteringPostProcess.js",
@@ -873,6 +855,7 @@
                 "../../src/PostProcess/babylon.tonemapPostProcess.js",
                 "../../src/PostProcess/babylon.displayPassPostProcess.js",
                 "../../src/PostProcess/babylon.highlightsPostProcess.js",
+                "../../src/PostProcess/babylon.extractHighlightsPostProcess.js",
                 "../../src/PostProcess/babylon.imageProcessingPostProcess.js"
             ],
             "dependUpon": [
@@ -919,7 +902,6 @@
                 "ssao.fragment",
                 "ssao2.fragment",
                 "ssaoCombine.fragment",
-                "chromaticAberration.fragment",
                 "lensHighlights.fragment",
                 "depthOfField.fragment",
                 "standard.fragment"
@@ -933,8 +915,10 @@
                 "renderingPipeline",
                 "additionalPostProcess_fxaa",
                 "additionalPostProcess_chromaticAberration",
+                "additionalPostProcess_grain",
                 "additionalPostProcess_sharpen",
-                "additionalPostProcess_depthOfFieldEffect"
+                "additionalPostProcess_depthOfFieldEffect",
+                "additionalPostProcess_bloomEffect"
             ]
         },
         "bones": {
@@ -970,7 +954,6 @@
         },
         "polygonMesh": {
             "files": [
-                "../../src/Tools/babylon.earcut.js",
                 "../../src/Mesh/babylon.polygonMesh.js"
             ],
             "dependUpon": [

Tools/Gulp/gulp-addModuleExports.js

@@ -74,7 +74,14 @@ ${afterInitText}
 ${String(file.contents)}
     ${varName.name === 'BABYLON' || varName.name === 'INSPECTOR' ? `
 var globalObject = (typeof global !== 'undefined') ? global : ((typeof window !== 'undefined') ? window : this);
-globalObject["${varName.name}"] = ${varName.name}` : ''}
+globalObject["${varName.name}"] = ${varName.name};
+//backwards compatibility
+if(typeof earcut !== 'undefined') {
+    globalObject["Earcut"] = {
+        earcut: earcut
+    };
+}` : ''}
+
     return ${base}${(config.subModule && !config.extendsRoot) ? '.' + varName.name : ''};
 });
 `;

Tools/Gulp/gulpfile.js

@@ -532,21 +532,6 @@ gulp.task("typescript-libraries", config.modules, function () {
 });
 
 /**
- * Dynamic custom configurations.
- */
-config.buildConfigurations.distributed.map(function (customConfiguration) {
-    gulp.task(customConfiguration, function (cb) {
-        config.build.currentConfig = customConfiguration;
-        config.build.outputDirectory = config.build.outputCustomConfigurationsDirectory + "/" + customConfiguration;
-        runSequence("typescript-compile", "build", cb);
-    });
-});
-
-gulp.task("typescript-customConfigurations", function (cb) {
-    runSequence(config.buildConfigurations.distributed, cb);
-});
-
-/**
  * Custom build with full path file control; used by profile.html
  */
 gulp.task("build-custom", function (cb) {
@@ -557,7 +542,7 @@ gulp.task("build-custom", function (cb) {
  * Do it all.
  */
 gulp.task("typescript-all", function (cb) {
-    runSequence("typescript", "typescript-libraries", "typescript-customConfigurations", cb);
+    runSequence("typescript", "typescript-libraries", cb);
 });
 
 /**
@@ -604,13 +589,12 @@ gulp.task("watch", ["srcTscWatch"], function () {
 
 gulp.task("intellisense", function () {
     gulp.src(config.build.intellisenseSources)
-        .pipe(concat(config.build.intellisenseFile))
-        .pipe(replace(/^\s*_.*?$/gm, ""))
-        .pipe(replace(/^\s*private .*?$/gm, ""))
-        .pipe(replace(/^\s*public _.*?$/gm, ""))
-        .pipe(replace(/^\s*protected .*?$/gm, ""))
-        .pipe(replace(/^\s*public static _.*?$/gm, ""))
-        .pipe(replace(/^\s*static _.*?$/gm, ""))
+        .pipe(concat(config.build.intellisenseFile))    
+        .pipe(replace(/^\s+_.*?;/gm, ""))
+        .pipe(replace(/^\s+_[\S\s]*?}/gm, ""))
+        .pipe(replace(/^\s*readonly _/gm, "protected readonly _"))
+        .pipe(replace(/^\s*static _/gm, "private static _"))
+        .pipe(replace(/^\s*abstract _/gm, ""))
         .pipe(gulp.dest(config.build.playgroundDirectory));
 });
 

Viewer/src/viewer/viewer.ts

@@ -930,9 +930,9 @@ export abstract class AbstractViewer {
 
     /**
      * Alters render settings to reduce features based on hardware feature limitations
-     * @param options Viewer options to modify
+     * @param enableHDR Allows the viewer to run in HDR mode.
      */
-    protected _handleHardwareLimitations() {
+    protected _handleHardwareLimitations(enableHDR = true) {
         //flip rendering settings switches based on hardware support
         let maxVaryingRows = this.engine.getCaps().maxVaryingVectors;
         let maxFragmentSamplers = this.engine.getCaps().maxTexturesImageUnits;
@@ -949,7 +949,7 @@ export abstract class AbstractViewer {
         let linearHalfFloatTargets = caps.textureHalfFloatRender && caps.textureHalfFloatLinearFiltering;
         let linearFloatTargets = caps.textureFloatRender && caps.textureFloatLinearFiltering;
 
-        this._hdrSupport = !!(linearFloatTargets || linearHalfFloatTargets);
+        this._hdrSupport = enableHDR && !!(linearFloatTargets || linearHalfFloatTargets);
 
         if (linearHalfFloatTargets) {
             this._defaultHighpTextureType = Engine.TEXTURETYPE_HALF_FLOAT;

Viewer/webpack.config.js

@@ -26,7 +26,8 @@ module.exports = {
         // until physics will be integrated in the viewer, ignore cannon
         cannon: 'CANNON',
         oimo: 'OIMO',
-        './Oimo': 'OIMO'
+        './Oimo': 'OIMO',
+        "earcut": true
     },
     devtool: 'source-map',
     plugins: [

Viewer/webpack.gulp.config.js

@@ -13,7 +13,8 @@ module.exports = {
         cannon: 'CANNON',
         oimo: 'OIMO',
         vertx: true,
-        "./Oimo": "OIMO"
+        "./Oimo": "OIMO",
+        "earcut": true
     },
     resolve: {
         extensions: ['.ts', '.js'],

dist/preview release/earcut.license

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

dist/preview release/gltf2Interface/package.json

@@ -1,7 +1,7 @@
 {
     "name": "babylonjs-gltf2interface",
     "description": "A typescript declaration of babylon's gltf2 inteface.",
-    "version": "3.2.0-beta.1",
+    "version": "3.2.0-beta.3",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

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

@@ -211,42 +211,34 @@ declare module BABYLON.GUI {
         readonly typeName: string;
         /**
         * An event triggered when the pointer move over the control.
-        * @type {BABYLON.Observable}
         */
         onPointerMoveObservable: Observable<Vector2>;
         /**
         * An event triggered when the pointer move out of the control.
-        * @type {BABYLON.Observable}
         */
         onPointerOutObservable: Observable<Control>;
         /**
         * An event triggered when the pointer taps the control
-        * @type {BABYLON.Observable}
         */
         onPointerDownObservable: Observable<Vector2WithInfo>;
         /**
         * An event triggered when pointer up
-        * @type {BABYLON.Observable}
         */
         onPointerUpObservable: Observable<Vector2WithInfo>;
         /**
         * An event triggered when a control is clicked on
-        * @type {BABYLON.Observable}
         */
         onPointerClickObservable: Observable<Vector2WithInfo>;
         /**
         * An event triggered when pointer enters the control
-        * @type {BABYLON.Observable}
         */
         onPointerEnterObservable: Observable<Control>;
         /**
         * An event triggered when the control is marked as dirty
-        * @type {BABYLON.Observable}
         */
         onDirtyObservable: Observable<Control>;
         /**
        * An event triggered after the control is drawn
-       * @type {BABYLON.Observable}
        */
         onAfterDrawObservable: Observable<Control>;
         alpha: number;
@@ -571,12 +563,10 @@ declare module BABYLON.GUI {
         private _outlineColor;
         /**
         * An event triggered after the text is changed
-        * @type {BABYLON.Observable}
         */
         onTextChangedObservable: Observable<TextBlock>;
         /**
         * An event triggered after the text was broken up into lines
-        * @type {BABYLON.Observable}
         */
         onLinesReadyObservable: Observable<TextBlock>;
         /**

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

@@ -909,42 +909,34 @@ var BABYLON;
                 this._linkOffsetY = new GUI.ValueAndUnit(0);
                 /**
                 * An event triggered when the pointer move over the control.
-                * @type {BABYLON.Observable}
                 */
                 this.onPointerMoveObservable = new BABYLON.Observable();
                 /**
                 * An event triggered when the pointer move out of the control.
-                * @type {BABYLON.Observable}
                 */
                 this.onPointerOutObservable = new BABYLON.Observable();
                 /**
                 * An event triggered when the pointer taps the control
-                * @type {BABYLON.Observable}
                 */
                 this.onPointerDownObservable = new BABYLON.Observable();
                 /**
                 * An event triggered when pointer up
-                * @type {BABYLON.Observable}
                 */
                 this.onPointerUpObservable = new BABYLON.Observable();
                 /**
                 * An event triggered when a control is clicked on
-                * @type {BABYLON.Observable}
                 */
                 this.onPointerClickObservable = new BABYLON.Observable();
                 /**
                 * An event triggered when pointer enters the control
-                * @type {BABYLON.Observable}
                 */
                 this.onPointerEnterObservable = new BABYLON.Observable();
                 /**
                 * An event triggered when the control is marked as dirty
-                * @type {BABYLON.Observable}
                 */
                 this.onDirtyObservable = new BABYLON.Observable();
                 /**
                * An event triggered after the control is drawn
-               * @type {BABYLON.Observable}
                */
                 this.onAfterDrawObservable = new BABYLON.Observable();
             }
@@ -3413,12 +3405,10 @@ var BABYLON;
                 _this._outlineColor = "white";
                 /**
                 * An event triggered after the text is changed
-                * @type {BABYLON.Observable}
                 */
                 _this.onTextChangedObservable = new BABYLON.Observable();
                 /**
                 * An event triggered after the text was broken up into lines
-                * @type {BABYLON.Observable}
                 */
                 _this.onLinesReadyObservable = new BABYLON.Observable();
                 _this.text = text;
@@ -5139,5 +5129,6 @@ var BABYLON;
 })(BABYLON || (BABYLON = {}));
 
     
+
     return BABYLON.GUI;
 });

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

@@ -216,42 +216,34 @@ declare module BABYLON.GUI {
         readonly typeName: string;
         /**
         * An event triggered when the pointer move over the control.
-        * @type {BABYLON.Observable}
         */
         onPointerMoveObservable: Observable<Vector2>;
         /**
         * An event triggered when the pointer move out of the control.
-        * @type {BABYLON.Observable}
         */
         onPointerOutObservable: Observable<Control>;
         /**
         * An event triggered when the pointer taps the control
-        * @type {BABYLON.Observable}
         */
         onPointerDownObservable: Observable<Vector2WithInfo>;
         /**
         * An event triggered when pointer up
-        * @type {BABYLON.Observable}
         */
         onPointerUpObservable: Observable<Vector2WithInfo>;
         /**
         * An event triggered when a control is clicked on
-        * @type {BABYLON.Observable}
         */
         onPointerClickObservable: Observable<Vector2WithInfo>;
         /**
         * An event triggered when pointer enters the control
-        * @type {BABYLON.Observable}
         */
         onPointerEnterObservable: Observable<Control>;
         /**
         * An event triggered when the control is marked as dirty
-        * @type {BABYLON.Observable}
         */
         onDirtyObservable: Observable<Control>;
         /**
        * An event triggered after the control is drawn
-       * @type {BABYLON.Observable}
        */
         onAfterDrawObservable: Observable<Control>;
         alpha: number;
@@ -576,12 +568,10 @@ declare module BABYLON.GUI {
         private _outlineColor;
         /**
         * An event triggered after the text is changed
-        * @type {BABYLON.Observable}
         */
         onTextChangedObservable: Observable<TextBlock>;
         /**
         * An event triggered after the text was broken up into lines
-        * @type {BABYLON.Observable}
         */
         onLinesReadyObservable: Observable<TextBlock>;
         /**

dist/preview 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-beta.1",
+    "version": "3.2.0-beta.3",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/inspector/package.json

@@ -4,7 +4,7 @@
     },
     "name": "babylonjs-inspector",
     "description": "The Babylon.js inspector.",
-    "version": "3.2.0-beta.1",
+    "version": "3.2.0-beta.3",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/loaders/babylonjs.loaders.js

@@ -5571,5 +5571,6 @@ var BABYLON;
 //# sourceMappingURL=KHR_lights.js.map
 
     
+
     return BABYLON;
 });

dist/preview 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-beta.1",
+    "version": "3.2.0-beta.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-beta.1"
+        "babylonjs-gltf2interface": "3.2.0-beta.3"
     },
     "peerDependencies": {
         "babylonjs": ">=3.2.0-alpha"

dist/preview 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-beta.1",
+    "version": "3.2.0-beta.3",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview 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-beta.1",
+    "version": "3.2.0-beta.3",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview 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-beta.1",
+    "version": "3.2.0-beta.3",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/serializers/babylonjs.serializers.js

@@ -1798,5 +1798,6 @@ var BABYLON;
 //# sourceMappingURL=babylon.glTFMaterial.js.map
 
     
+
     return BABYLON;
 });

dist/preview 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-beta.1",
+    "version": "3.2.0-beta.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-beta.1"
+        "babylonjs-gltf2interface": "3.2.0-beta.3"
     },
     "peerDependencies": {
         "babylonjs": ">=3.2.0-alpha"

dist/preview release/typedocValidationBaseline.json

@@ -1,7 +1,7 @@
 {
-  "errors": 7152,
+  "errors": 7080,
   "babylon.typedoc.json": {
-    "errors": 7152,
+    "errors": 7080,
     "AnimationKeyInterpolation": {
       "Enumeration": {
         "Comments": {
@@ -1418,147 +1418,15 @@
       }
     },
     "Action": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Constructor": {
-        "new Action": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "triggerOptions": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "condition": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      },
       "Property": {
-        "_actionManager": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "onBeforeExecuteObservable": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "trigger": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
         "triggerOptions": {
           "Comments": {
             "MissingText": true
           }
-        },
-        "_GetTargetProperty": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_SerializeValueAsString": {
-          "Comments": {
-            "MissingText": true
-          }
         }
       },
       "Method": {
-        "_executeCurrent": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "evt": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_getEffectiveTarget": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "target": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "propertyPath": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_getProperty": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "propertyPath": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_prepare": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "execute": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "evt": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getTriggerParameter": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "serialize": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "parent": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "skipToNextActiveAction": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
         "then": {
-          "Comments": {
-            "MissingText": true
-          },
           "Parameter": {
             "action": {
               "Comments": {
@@ -8024,85 +7892,6 @@
         }
       }
     },
-    "Condition": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Constructor": {
-        "new Condition": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "actionManager": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      },
-      "Property": {
-        "_actionManager": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_currentResult": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "_evaluationId": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "_getEffectiveTarget": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "target": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "propertyPath": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "_getProperty": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "propertyPath": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "isValid": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "serialize": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      }
-    },
     "CubeTexture": {
       "Class": {
         "Comments": {
@@ -8777,55 +8566,15 @@
     },
     "DefaultRenderingPipeline": {
       "Property": {
-        "BlurXPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          }
-        },
-        "BlurYPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          }
-        },
-        "ChromaticAberrationPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          }
-        },
-        "CopyBackPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          }
-        },
-        "FinalMergePostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          }
-        },
         "FxaaPostProcessId": {
           "Naming": {
             "NotCamelCase": true
           }
         },
-        "HighLightsPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          }
-        },
         "ImageProcessingPostProcessId": {
           "Naming": {
             "NotCamelCase": true
           }
-        },
-        "PassPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          }
-        },
-        "SharpenPostProcessId": {
-          "Naming": {
-            "NotCamelCase": true
-          }
         }
       }
     },
@@ -8861,101 +8610,6 @@
         }
       }
     },
-    "DynamicTexture": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
-      "Method": {
-        "clear": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "drawText": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "text": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "x": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "y": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "font": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "color": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "clearColor": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "invertY": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "update": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "getContext": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "scaleTo": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "width": {
-              "Comments": {
-                "MissingText": true
-              }
-            },
-            "height": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        },
-        "update": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "invertY": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
-        }
-      }
-    },
     "EasingFunction": {
       "Class": {
         "Comments": {
@@ -9196,11 +8850,6 @@
             "MissingText": true
           }
         },
-        "enableOfflineSupport": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
         "forcePOTTextures": {
           "Comments": {
             "MissingText": true
@@ -23329,11 +22978,6 @@
       }
     },
     "PredicateCondition": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
       "Property": {
         "predicate": {
           "Comments": {
@@ -31252,11 +30896,6 @@
       }
     },
     "StateCondition": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
       "Property": {
         "value": {
           "Comments": {
@@ -34564,11 +34203,6 @@
       }
     },
     "ValueCondition": {
-      "Class": {
-        "Comments": {
-          "MissingText": true
-        }
-      },
       "Property": {
         "operator": {
           "Comments": {
@@ -34584,40 +34218,6 @@
           "Comments": {
             "MissingText": true
           }
-        },
-        "IsDifferent": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "IsEqual": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "IsGreater": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "IsLesser": {
-          "Comments": {
-            "MissingText": true
-          }
-        }
-      },
-      "Method": {
-        "GetOperatorName": {
-          "Comments": {
-            "MissingText": true
-          },
-          "Parameter": {
-            "operator": {
-              "Comments": {
-                "MissingText": true
-              }
-            }
-          }
         }
       }
     },

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

@@ -1099,10 +1099,10 @@ declare module BabylonViewer {
          */
         protected _initEnvironment(model?: ViewerModel): Promise<BABYLON.Scene>;
         /**
-         * Alters render settings to reduce features based on hardware feature limitations
-         * @param options Viewer options to modify
-         */
-        protected _handleHardwareLimitations(): void;
+		 * Alters render settings to reduce features based on hardware feature limitations
+		 * @param enableHDR Allows the viewer to run in HDR mode.
+		 */
+        protected _handleHardwareLimitations(enableHDR?: boolean): void;
         /**
          * Injects all the spectre shader in the babylon shader store
          */

dist/preview 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-beta.1",
+    "version": "3.2.0-beta.3",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

dist/preview release/what's new.md

@@ -13,7 +13,7 @@
 - Added [VideoDome](http://doc.babylonjs.com/how_to/360videodome) class to easily support 360 videos. Demo [here](https://www.babylonjs-playground.com/frame.html#1E9JQ8#7) ([DavidHGillen](https://github.com/DavidHGillen))
 - Added [GlowLayer](https://doc.babylonjs.com/how_to/glow_layer) to easily support glow from emissive materials. Demo [here](http://www.babylonjs.com/demos/GlowLayer/) ([sebavan](https://github.com/sebavan))
 - 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#5), sharpening, MSAA, chromatic aberration and grain effect to the default pipeline ([trevordev](https://github.com/trevordev))
+- Added [depth of field](https://www.babylonjs-playground.com/frame.html#8F5HYV#9), sharpening, MSAA, chromatic aberration and grain effect 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/#IQN716#9) ([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))
 - 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))
@@ -22,9 +22,12 @@
 - Physics - Latest production version of Oimo.js is being used - 1.0.9 ([RaananW](https://github.com/RaananW))
 - Shadows - 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) support in Webgl 2 ([sebavan](https://github.com/sebavan)))
 
+## Documentation
+- Tons of functions and classes received the code comments they deserved (All the community)
+- Moved the class API documentation to Typedoc ([deltakosh](https://github.com/deltakosh))
+
 ## Updates
 
-- Tons of functions and classes received the code comments they deserved (All the community)
 - New [particle system emitter shapes](http://doc.babylonjs.com/babylon101/particles#particles-shapes): 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))
@@ -99,8 +102,10 @@
 - 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)]
 
 ## Bug fixes
@@ -128,3 +133,4 @@
 - 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))
+- Removed public references to default rendering pipeline's internal post process ([trevordev](https://github.com/trevordev))

gui/src/controls/control.ts

@@ -69,49 +69,41 @@ module BABYLON.GUI {
 
         /**
         * An event triggered when the pointer move over the control.
-        * @type {BABYLON.Observable}
         */
         public onPointerMoveObservable = new Observable<Vector2>();
 
         /**
         * An event triggered when the pointer move out of the control.
-        * @type {BABYLON.Observable}
         */
         public onPointerOutObservable = new Observable<Control>();
 
         /**
         * An event triggered when the pointer taps the control
-        * @type {BABYLON.Observable}
         */
         public onPointerDownObservable = new Observable<Vector2WithInfo>();
 
         /**
         * An event triggered when pointer up
-        * @type {BABYLON.Observable}
         */
         public onPointerUpObservable = new Observable<Vector2WithInfo>();
 
         /**
         * An event triggered when a control is clicked on
-        * @type {BABYLON.Observable}
         */
         public onPointerClickObservable = new Observable<Vector2WithInfo>();
 
         /**
         * An event triggered when pointer enters the control
-        * @type {BABYLON.Observable}
         */
         public onPointerEnterObservable = new Observable<Control>();
 
         /**
         * An event triggered when the control is marked as dirty
-        * @type {BABYLON.Observable}
         */
         public onDirtyObservable = new Observable<Control>();
 
         /**
        * An event triggered after the control is drawn
-       * @type {BABYLON.Observable}
        */
         public onAfterDrawObservable = new Observable<Control>();
 

gui/src/controls/textBlock.ts

@@ -14,13 +14,11 @@ module BABYLON.GUI {
         private _outlineColor: string = "white";
         /**
         * An event triggered after the text is changed
-        * @type {BABYLON.Observable}
         */
         public onTextChangedObservable = new Observable<TextBlock>();
 
         /**
         * An event triggered after the text was broken up into lines
-        * @type {BABYLON.Observable}
         */
         public onLinesReadyObservable = new Observable<TextBlock>();
 

materialsLibrary/src/gradient/gradient.fragment.fx

@@ -12,6 +12,7 @@ uniform float smoothness;
 
 // Input
 varying vec3 vPositionW;
+varying vec3 vPosition;
 
 #ifdef NORMAL
 varying vec3 vNormalW;
@@ -51,7 +52,7 @@ void main(void) {
 
 	vec3 viewDirectionW = normalize(vEyePosition - vPositionW);
 
-    float h = normalize(vPositionW).y + offset;
+    float h = normalize(vPosition).y + offset;
     float mysmoothness = clamp(smoothness, 0.01, max(smoothness, 10.));
 
     vec4 baseColor = mix(bottomColor, topColor, max(pow(max(h, 0.0), mysmoothness), 0.0));

materialsLibrary/src/gradient/gradient.vertex.fx

@@ -35,6 +35,7 @@ uniform float pointSize;
 
 // Output
 varying vec3 vPositionW;
+varying vec3 vPosition;
 #ifdef NORMAL
 varying vec3 vNormalW;
 #endif
@@ -56,6 +57,7 @@ void main(void) {
 
 	vec4 worldPos = finalWorld * vec4(position, 1.0);
 	vPositionW = vec3(worldPos);
+	vPosition = position;
 
 #ifdef NORMAL
 	vNormalW = normalize(vec3(finalWorld * vec4(normal, 0.0)));

package.json

@@ -9,7 +9,7 @@
     ],
     "name": "babylonjs",
     "description": "Babylon.js is a JavaScript 3D engine based on webgl.",
-    "version": "3.2.0-beta.1",
+    "version": "3.2.0-beta.3",
     "repository": {
         "type": "git",
         "url": "https://github.com/BabylonJS/Babylon.js.git"

src/Actions/babylon.action.ts

@@ -1,6 +1,18 @@
 module BABYLON {
+    /**
+     * The action to be carried out following a trigger
+     * @see http://doc.babylonjs.com/how_to/how_to_use_actions#available-actions
+     */
     export class Action {
+        /**
+         * Trigger for the action
+         */
         public trigger: number;
+
+        /**
+         * Internal only - manager for action
+         * @ignore 
+         */
         public _actionManager: ActionManager;
 
         private _nextActiveAction: Action;
@@ -8,8 +20,16 @@
         private _condition?: Condition;
         private _triggerParameter: any;
 
+        /**
+        * An event triggered prior to action being executed.
+        */
         public onBeforeExecuteObservable = new Observable<Action>();
 
+        /**
+         * Creates a new Action
+         * @param triggerOptions the trigger, with or without parameters, for the action
+         * @param condition an optional determinant of action 
+         */
         constructor(public triggerOptions: any, condition?: Condition) {
 
             if (triggerOptions.parameter) {
@@ -23,14 +43,25 @@
             this._condition = condition;
         }
 
-        // Methods
+        /**
+         * Internal only
+         * @ignore 
+         */
         public _prepare(): void {
         }
 
+        /**
+         * Gets the trigger parameters
+         * @returns the trigger parameters
+         */
         public getTriggerParameter(): any {
             return this._triggerParameter;
         }
 
+        /**
+         * Internal only - executes current action event
+         * @ignore 
+         */
         public _executeCurrent(evt?: ActionEvent): void {
             if (this._nextActiveAction._condition) {
                 var condition = this._nextActiveAction._condition;
@@ -59,10 +90,17 @@
             this.skipToNextActiveAction();
         }
 
+        /**
+         * Execute placeholder for child classes
+         * @param evt optional action event
+         */
         public execute(evt?: ActionEvent): void {
 
         }
 
+        /**
+         * Skips to next active action
+         */
         public skipToNextActiveAction(): void {
             if (this._nextActiveAction._child) {
 
@@ -76,6 +114,12 @@
             }
         }
 
+        /**
+         * Adds action to chain of actions, may be a DoNothingAction
+         * @param index The index of the attribute.
+         * @returns The action passed in
+         * @see https://www.babylonjs-playground.com/#1T30HR#0
+         */
         public then(action: Action): Action {
             this._child = action;
 
@@ -85,18 +129,34 @@
             return action;
         }
 
+        /**
+         * Internal only
+         * @ignore 
+         */
         public _getProperty(propertyPath: string): string {
             return this._actionManager._getProperty(propertyPath);
         }
 
+        /**
+         * Internal only
+         * @ignore 
+         */
         public _getEffectiveTarget(target: any, propertyPath: string): any {
             return this._actionManager._getEffectiveTarget(target, propertyPath);
         }
         
+        /**
+         * Serialize placeholder for child classes
+         * @param parent of child
+         * @returns the serialized object
+         */
         public serialize(parent: any): any {
         }
         
-        // Called by BABYLON.Action objects in serialize(...). Internal use
+        /**
+         * Internal only called by serialize
+         * @ignore 
+         */
         protected _serialize(serializedAction: any, parent?: any): any {
             var serializationObject: any = { 
                 type: 1,
@@ -127,6 +187,10 @@
             return serializationObject;
         }
         
+        /**
+         * Internal only
+         * @ignore 
+         */
         public static _SerializeValueAsString = (value: any): string => {
             if (typeof value === "number") {
                 return value.toString();
@@ -152,7 +216,11 @@
             
             return value; // string
         };
-    
+        
+        /**
+         * Internal only
+         * @ignore 
+         */
         public static _GetTargetProperty = (target: Scene | Node) => {
             return {
                 name: "target",

src/Actions/babylon.actionManager.ts

@@ -1,7 +1,7 @@
 module BABYLON {
 
     /**
-     * ActionEvent is the event beint sent when an action is triggered.
+     * ActionEvent is the event being sent when an action is triggered.
      */
     export class ActionEvent {
         /**

src/Actions/babylon.condition.ts

@@ -1,29 +1,69 @@
 module BABYLON {
+    /**
+     * A Condition applied to an Action 
+     */
     export class Condition {
+        /**
+         * Internal only - manager for action
+         * @ignore 
+         */
         public _actionManager: ActionManager;
 
+        /**
+         * Internal only
+         * @ignore 
+         */
         public _evaluationId: number;
+
+        /**
+         * Internal only
+         * @ignore 
+         */
         public _currentResult: boolean;
 
+        /**
+         * Creates a new Condition
+         * @param actionManager the manager of the action the condition is applied to 
+         */
         constructor(actionManager: ActionManager) {
             this._actionManager = actionManager;
         }
 
+        /**
+         * Check if the current condition is valid
+         * @returns a boolean
+         */
         public isValid(): boolean {
             return true;
         }
 
+        /**
+         * Internal only 
+         * @ignore 
+         */
         public _getProperty(propertyPath: string): string {
             return this._actionManager._getProperty(propertyPath);
         }
 
+        /**
+         * Internal only 
+         * @ignore 
+         */
         public _getEffectiveTarget(target: any, propertyPath: string): any {
             return this._actionManager._getEffectiveTarget(target, propertyPath);
         }
         
+        /**
+         * Serialize placeholder for child classes
+         * @returns the serialized object
+         */
         public serialize(): any {
         }
         
+        /**
+         * Internal only 
+         * @ignore 
+         */
         protected _serialize(serializedCondition: any): any {
             return { 
                 type: 2, // Condition
@@ -34,36 +74,95 @@
         }
     }
 
+    /**
+     * Defines specific conditional operators as extensions of Condition
+     */
     export class ValueCondition extends Condition {
-        // Statics
+        
+        /**
+         * Internal only 
+         * @ignore 
+         */
         private static _IsEqual = 0;
+
+        /**
+         * Internal only 
+         * @ignore 
+         */
         private static _IsDifferent = 1;
+
+        /**
+         * Internal only 
+         * @ignore 
+         */
         private static _IsGreater = 2;
+
+        /**
+         * Internal only 
+         * @ignore 
+         */
         private static _IsLesser = 3;
 
+        /**
+         * returns the number for IsEqual
+         */
         public static get IsEqual(): number {
             return ValueCondition._IsEqual;
         }
 
+        /**
+         * Returns the number for IsDifferent
+         */
         public static get IsDifferent(): number {
             return ValueCondition._IsDifferent;
         }
 
+        /**
+         * Returns the number for IsGreater
+         */
         public static get IsGreater(): number {
             return ValueCondition._IsGreater;
         }
 
+        /**
+         * Returns the number for IsLesser
+         */
         public static get IsLesser(): number {
             return ValueCondition._IsLesser;
         }
 
-        // Members
+        /**
+         * Internal only The action manager for the condition
+         * @ignore 
+         */
         public _actionManager: ActionManager;
 
+        /**
+         * Internal only 
+         * @ignore 
+         */
         private _target: any;
+
+        /**
+         * Internal only 
+         * @ignore 
+         */
         private _effectiveTarget: any;
+
+        /**
+         * Internal only 
+         * @ignore 
+         */
         private _property: string;
 
+        /**
+         * Creates a new ValueCondition
+         * @param actionManager manager for the action the condition applies to
+         * @param target for the action
+         * @param propertyPath path to specify the property of the target the conditional operator uses 
+         * @param value the vale compared by the conditional operator against the current value of the property
+         * @param operator the conditional operator, default {BABYLON.ValueCondition.IsEqual}  
+         */
         constructor(actionManager: ActionManager, target: any, public propertyPath: string, public value: any, public operator: number = ValueCondition.IsEqual) {
             super(actionManager);
 
@@ -72,7 +171,10 @@
             this._property = this._getProperty(this.propertyPath);
         }
 
-        // Methods
+        /**
+         * Compares the given value with the property value for the specified conditional operator
+         * @returns the result of the comparison
+         */
         public isValid(): boolean {
             switch (this.operator) {
                 case ValueCondition.IsGreater:
@@ -94,6 +196,10 @@
             return false;
         }
         
+        /**
+         * Serialize the ValueCondition into a JSON compatible object
+         * @returns serialization object
+         */
         public serialize(): any {
             return this._serialize({
                name: "ValueCondition",
@@ -106,6 +212,11 @@
             });
         }
         
+        /**
+         * Gets the name of the conditional operator for the ValueCondition
+         * @param operator the conditional operator
+         * @returns the name 
+         */
         public static GetOperatorName(operator: number): string {
             switch (operator) {
                 case ValueCondition._IsEqual: return "IsEqual";
@@ -117,37 +228,75 @@
         }
     }
 
+    /**
+     * Defines a predicate condition as an extension of Condition
+     */
     export class PredicateCondition extends Condition {
-        // Members
+        
+        /**
+         * Internal only - manager for action
+         * @ignore 
+         */
         public _actionManager: ActionManager;
 
 
+        /**
+         * Creates a new {BABYLON.PredicateCondition}
+         * @param actionManager manager for the action the condition applies to
+         * @param predicate 
+         */
         constructor(actionManager: ActionManager, public predicate: () => boolean) {
             super(actionManager);
         }
 
+        /**
+         * @returns the validity of the predicate condition
+         */
         public isValid(): boolean {
             return this.predicate();
         }
     }
 
+    /**
+     * Defines a state condition as an extension of {BABYLON.Condition}
+     */
     export class StateCondition extends Condition {
-        // Members
+        
+        /**
+         * Internal only - manager for action
+         * @ignore 
+         */
         public _actionManager: ActionManager;
 
+        /**
+         * Internal only
+         * @ignore 
+         */
         private _target: any;
 
+        /**
+         * Creates a new {BABYLON.StateCondition}
+         * @param actionManager manager for the action the condition applies to
+         * @param target of the condition
+         * @param value to compare with target state 
+         */
         constructor(actionManager: ActionManager, target: any, public value: string) {
             super(actionManager);
 
             this._target = target;
         }
 
-        // Methods
+        /**
+         * @returns the validity of the state
+         */
         public isValid(): boolean {
             return this._target.state === this.value;
         }
         
+        /**
+         * Serialize the {BABYLON.StateCondition} into a JSON compatible object
+         * @returns serialization object
+         */
         public serialize(): any {
             return this._serialize({
                name: "StateCondition",

src/Bones/babylon.bone.ts

@@ -189,6 +189,7 @@
 
         public markAsDirty(): void {
             this._currentRenderId++;
+            this._childRenderId++;
             this._skeleton._markAsDirty();
         }
 

src/Bones/babylon.skeleton.ts

@@ -31,7 +31,6 @@
         // Events
         /**
          * An event triggered before computing the skeleton's matrices
-         * @type {BABYLON.Observable}
          */
         public onBeforeComputeObservable = new Observable<Skeleton>();
 

src/Cameras/Inputs/babylon.arcRotateCameraMouseWheelInput.ts

@@ -23,7 +23,16 @@ module BABYLON {
                 var delta = 0;
 
                 if (event.wheelDelta) {
-                    delta = this.wheelDeltaPercentage ? (event.wheelDelta * 0.01) * this.camera.radius * this.wheelDeltaPercentage : event.wheelDelta / (this.wheelPrecision * 40);
+                    if (this.wheelDeltaPercentage) {
+                        var wheelDelta = (event.wheelDelta * 0.01 * this.wheelDeltaPercentage) * this.camera.radius;
+                        if (event.wheelDelta > 0) {
+                            delta = wheelDelta / (1.0 + this.wheelDeltaPercentage);
+                        } else {
+                            delta = wheelDelta * (1.0 + this.wheelDeltaPercentage);
+                        }
+                    } else {
+                        delta = event.wheelDelta / (this.wheelPrecision * 40);
+                    }
                 } else if (event.detail) {
                     delta = -event.detail / this.wheelPrecision;
                 }

src/Cameras/babylon.camera.ts

@@ -252,6 +252,22 @@
             return (this._activeMeshes.indexOf(mesh) !== -1);
         }
 
+        /**
+         * Is this camera ready to be used/rendered
+         * @param completeCheck defines if a complete check (including post processes) has to be done (false by default)
+         * @return true if the camera is ready
+         */
+        public isReady(completeCheck = false): boolean {
+            if (completeCheck) {
+                for (var pp of this._postProcesses) {
+                    if (pp && !pp.isReady()) {
+                        return false;
+                    }
+                }
+            }
+            return super.isReady(completeCheck);
+        }
+
         //Cache
         public _initCache() {
             super._initCache();

src/Cameras/babylon.deviceOrientationCamera.ts

@@ -10,7 +10,7 @@ module BABYLON {
         private _quaternionCache: Quaternion;
 
         /**
-         * Creates a new device orientation camera. @see DeviceOrientationCamera
+         * Creates a new device orientation camera
          * @param name The name of the camera
          * @param position The start position camera
          * @param scene The scene the camera belongs to

src/Engine/babylon.engine.ts

@@ -597,7 +597,7 @@
         }
 
         public static get Version(): string {
-            return "3.2.0-beta.1";
+            return "3.2.0-beta.3";
         }
 
         // Updatable statics so stick with vars here
@@ -612,8 +612,12 @@
         public cullBackFaces = true;
         public renderEvenInBackground = true;
         public preventCacheWipeBetweenFrames = false;
-        // To enable/disable IDB support and avoid XHR on .manifest
+
+        /** 
+         * To enable/disable IDB support and avoid XHR on .manifest
+         **/
         public enableOfflineSupport = false;
+
         public scenes = new Array<Scene>();
         public postProcesses = new Array<PostProcess>();
 

src/Layer/babylon.glowLayer.ts

@@ -169,6 +169,14 @@
             blurTextureWidth = this._engine.needPOTTextures ? Tools.GetExponentOfTwo(blurTextureWidth, this._maxSize) : blurTextureWidth;
             blurTextureHeight = this._engine.needPOTTextures ? Tools.GetExponentOfTwo(blurTextureHeight, this._maxSize) : blurTextureHeight;
 
+            var textureType = 0;
+            if (this._engine.getCaps().textureHalfFloatRender) {
+                textureType = Engine.TEXTURETYPE_HALF_FLOAT;
+            }
+            else {
+                textureType = Engine.TEXTURETYPE_UNSIGNED_INT;
+            }
+
             this._blurTexture1 = new RenderTargetTexture("GlowLayerBlurRTT",
                 {
                     width: blurTextureWidth,
@@ -177,7 +185,7 @@
                 this._scene,
                 false,
                 true,
-                Engine.TEXTURETYPE_HALF_FLOAT);
+                textureType);
             this._blurTexture1.wrapU = Texture.CLAMP_ADDRESSMODE;
             this._blurTexture1.wrapV = Texture.CLAMP_ADDRESSMODE;
             this._blurTexture1.updateSamplingMode(Texture.BILINEAR_SAMPLINGMODE);
@@ -195,7 +203,7 @@
                 this._scene,
                 false,
                 true,
-                Engine.TEXTURETYPE_HALF_FLOAT);
+                textureType);
             this._blurTexture2.wrapU = Texture.CLAMP_ADDRESSMODE;
             this._blurTexture2.wrapV = Texture.CLAMP_ADDRESSMODE;
             this._blurTexture2.updateSamplingMode(Texture.BILINEAR_SAMPLINGMODE);
@@ -208,7 +216,7 @@
                     width:  blurTextureWidth,
                     height: blurTextureHeight
                 },
-                null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, Engine.TEXTURETYPE_HALF_FLOAT);
+                null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
             this._horizontalBlurPostprocess1.width = blurTextureWidth;
             this._horizontalBlurPostprocess1.height = blurTextureHeight;
             this._horizontalBlurPostprocess1.onApplyObservable.add(effect => {
@@ -219,13 +227,13 @@
                     width:  blurTextureWidth,
                     height: blurTextureHeight
                 },
-                null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, Engine.TEXTURETYPE_HALF_FLOAT);
+                null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
 
             this._horizontalBlurPostprocess2 = new BlurPostProcess("GlowLayerHBP2", new Vector2(1.0, 0), this._options.blurKernelSize / 2, {
                     width:  blurTextureWidth2,
                     height: blurTextureHeight2
                 },
-                null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, Engine.TEXTURETYPE_HALF_FLOAT);
+                null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
             this._horizontalBlurPostprocess2.width = blurTextureWidth2;
             this._horizontalBlurPostprocess2.height = blurTextureHeight2;
             this._horizontalBlurPostprocess2.onApplyObservable.add(effect => {
@@ -236,7 +244,7 @@
                     width:  blurTextureWidth2,
                     height: blurTextureHeight2
                 },
-                null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, Engine.TEXTURETYPE_HALF_FLOAT);
+                null, Texture.BILINEAR_SAMPLINGMODE, this._scene.getEngine(), false, textureType);
 
             this._postProcesses = [ this._horizontalBlurPostprocess1, this._verticalBlurPostprocess1, this._horizontalBlurPostprocess2, this._verticalBlurPostprocess2 ];
             this._postProcesses1 = [ this._horizontalBlurPostprocess1, this._verticalBlurPostprocess1 ];

src/Layer/babylon.layer.ts

@@ -20,7 +20,6 @@
 
         /**
         * An event triggered when the layer is disposed.
-        * @type {BABYLON.Observable}
         */
         public onDisposeObservable = new Observable<Layer>();
 
@@ -34,7 +33,6 @@
 
         /**
         * An event triggered before rendering the scene
-        * @type {BABYLON.Observable}
         */
         public onBeforeRenderObservable = new Observable<Layer>();
 
@@ -48,7 +46,6 @@
 
         /**
         * An event triggered after rendering the scene
-        * @type {BABYLON.Observable}
         */
         public onAfterRenderObservable = new Observable<Layer>();
 

src/Lights/Shadows/babylon.shadowGenerator.ts

@@ -76,7 +76,7 @@
     }
 
     /**
-     * Default implementation of @see IShadowGenerator.
+     * Default implementation IShadowGenerator.
      * This is the main object responsible of generating shadows in the framework.
      * Documentation: https://doc.babylonjs.com/babylon101/shadows
      */

src/Lights/babylon.light.ts

@@ -374,7 +374,6 @@ module BABYLON {
         /**
          * Set the enabled state of this node.
          * @param value - the new enabled state
-         * @see isEnabled
          */
         public setEnabled(value: boolean): void {
             super.setEnabled(value);

src/Lights/babylon.shadowLight.ts

@@ -111,7 +111,7 @@
     }
 
     /**
-     * Base implementation of @see IShadowLight
+     * Base implementation IShadowLight
      * It groups all the common behaviour in order to reduce dupplication and better follow the DRY pattern.
      */
     export abstract class ShadowLight extends Light implements IShadowLight {

src/Loading/babylon.sceneLoader.ts

@@ -309,7 +309,21 @@
             }
 
             if (rootUrl.indexOf("file:") === -1) {
-                if (scene.getEngine().enableOfflineSupport) {
+                let canUseOfflineSupport = scene.getEngine().enableOfflineSupport;
+                if (canUseOfflineSupport) {
+                    // Also check for exceptions
+                    let exceptionFound = false;
+                    for (var regex of scene.disableOfflineSupportExceptionRules) {
+                        if (regex.test(rootUrl + sceneFilename)) {
+                            exceptionFound = true;
+                            break;
+                        }
+                    }
+
+                    canUseOfflineSupport = !exceptionFound;
+                }
+
+                if (canUseOfflineSupport) {
                     // Checking if a manifest file has been set for this scene and if offline mode has been requested
                     database = new Database(rootUrl + sceneFilename, manifestChecked);
                 }

src/Materials/Background/babylon.backgroundMaterial.ts

@@ -83,7 +83,6 @@
         public SAMPLER3DBGRMAP = false;
         public IMAGEPROCESSINGPOSTPROCESS = false;
         public EXPOSURE = false;
-        public GRAIN = false;
 
         // Reflection.
         public REFLECTION = false;
@@ -355,7 +354,6 @@
 
         /**
          * Enable the FOV adjustment feature controlled by fovMultiplier.
-         * @type {boolean}
          */
         public useEquirectangularFOV: boolean = false;
 

src/Materials/PBR/babylon.pbrBaseMaterial.ts

@@ -120,7 +120,6 @@
         public SAMPLER3DBGRMAP = false;
         public IMAGEPROCESSINGPOSTPROCESS = false;
         public EXPOSURE = false;
-        public GRAIN = false;
 
         public USEPHYSICALLIGHTFALLOFF = false;
         public TWOSIDEDLIGHTING = false;

src/Materials/Textures/babylon.baseTexture.ts

@@ -137,7 +137,6 @@
 
         /**
         * An event triggered when the texture is disposed.
-        * @type {BABYLON.Observable}
         */
         public onDisposeObservable = new Observable<BaseTexture>();
 

src/Materials/Textures/babylon.dynamicTexture.ts

@@ -1,10 +1,24 @@
 module BABYLON {
+    /**
+     * A class extending {BABYLON.Texture} allowing drawing on a texture
+     * @see http://doc.babylonjs.com/how_to/dynamictexture
+     */
     export class DynamicTexture extends Texture {
         private _generateMipMaps: boolean;
         private _canvas: HTMLCanvasElement;
         private _context: CanvasRenderingContext2D;
         private _engine: Engine;
 
+        /**
+         * Creates a {BABYLON.DynamicTexture}
+         * @param name defines the name of the texture
+         * @param options provides 3 alternatives for width and height of texture, a canvas, object with width and height properties, number for both width and height
+         * @param scene defines the scene where you want the texture
+         * @param generateMipMaps defines the use of MinMaps or not (default is false)
+         * @param samplingMode defines the sampling mode to use (default is BABYLON.Texture.TRILINEAR_SAMPLINGMODE)
+         * @param format defines the texture format to use (default is BABYLON.Engine.TEXTUREFORMAT_RGBA)
+         */
+
         constructor(name: string, options: any, scene: Nullable<Scene> = null, generateMipMaps: boolean, samplingMode: number = Texture.TRILINEAR_SAMPLINGMODE, format: number = Engine.TEXTUREFORMAT_RGBA) {
             super(null, scene, !generateMipMaps, undefined, samplingMode, undefined, undefined, undefined, undefined, format);
 
@@ -35,6 +49,9 @@
             this._context = <CanvasRenderingContext2D>this._canvas.getContext("2d");
         }
 
+        /**
+         * Gets the current state of canRescale
+         */
         public get canRescale(): boolean {
             return true;
         }
@@ -48,6 +65,10 @@
             this._texture = this._engine.createDynamicTexture(textureSize.width, textureSize.height, this._generateMipMaps, this._samplingMode);
         }
 
+        /**
+         * Scales the texture
+         * @param ratio the scale factor to apply to both width and height
+         */
         public scale(ratio: number): void {
             var textureSize = this.getSize();
 
@@ -57,6 +78,11 @@
             this._recreate(textureSize);
         }
 
+        /**
+         * Resizes the texture
+         * @param width the new width
+         * @param height the new height
+         */
         public scaleTo(width: number, height: number): void {
             var textureSize = this.getSize();
 
@@ -66,19 +92,41 @@
             this._recreate(textureSize);
         }
 
+        /**
+         * Gets the context of the canvas used by the texture
+         * @returns the canvas context of the dynamic texture
+         */
         public getContext(): CanvasRenderingContext2D {
             return this._context;
         }
 
+        /**
+         * Clears the texture
+         */
         public clear(): void {
             var size = this.getSize();
             this._context.fillRect(0, 0, size.width, size.height);
         }
 
+        /**
+         * Updates the texture
+         * @param invertY defines the direction for the Y axis (default is true - y increases downwards)
+         */
         public update(invertY?: boolean): void {
             this._engine.updateDynamicTexture(this._texture, this._canvas, invertY === undefined ? true : invertY, undefined, this._format || undefined);
         }
 
+        /**
+         * Draws text onto the texture
+         * @param text defines the text to be drawn
+         * @param x defines the placement of the text from the left
+         * @param y defines the placement of the text from the top when invertY is true and from the bottom when false
+         * @param font defines the font to be used with font-style, font-size, font-name 
+         * @param color defines the color used for the text
+         * @param clearColor defines the color for the canvas, use null to not overwrite canvas 
+         * @param invertY defines the direction for the Y axis (default is true - y increases downwards)
+         * @param update defines whether texture is immediately update (default is true)  
+         */
         public drawText(text: string, x: number, y: number, font: string, color: string, clearColor: string, invertY?: boolean, update = true) {
             var size = this.getSize();
             if (clearColor) {
@@ -104,6 +152,10 @@
             }
         }
 
+        /**
+         * Clones the texture
+         * @returns the clone of the texture.
+         */
         public clone(): DynamicTexture {
             let scene = this.getScene();
 
@@ -125,6 +177,7 @@
             return newTexture;
         }
 
+        /** @ignore */
         public _rebuild(): void {
             this.update();
         }

src/Materials/Textures/babylon.renderTargetTexture.ts

@@ -43,13 +43,11 @@
 
         /**
         * An event triggered when the texture is unbind.
-        * @type {BABYLON.Observable}
         */
         public onBeforeBindObservable = new Observable<RenderTargetTexture>();
 
         /**
         * An event triggered when the texture is unbind.
-        * @type {BABYLON.Observable}
         */
         public onAfterUnbindObservable = new Observable<RenderTargetTexture>();
 
@@ -63,7 +61,6 @@
 
         /**
         * An event triggered before rendering the texture
-        * @type {BABYLON.Observable}
         */
         public onBeforeRenderObservable = new Observable<number>();
 
@@ -77,7 +74,6 @@
 
         /**
         * An event triggered after rendering the texture
-        * @type {BABYLON.Observable}
         */
         public onAfterRenderObservable = new Observable<number>();
 
@@ -91,7 +87,6 @@
 
         /**
         * An event triggered after the texture clear
-        * @type {BABYLON.Observable}
         */
         public onClearObservable = new Observable<Engine>();
 

src/Materials/babylon.effect.ts

@@ -258,7 +258,7 @@
 
                 this._attributesNames = options.attributes;
                 this._uniformsNames = options.uniformsNames.concat(options.samplers);
-                this._samplers = options.samplers;
+                this._samplers = options.samplers.slice();
                 this.defines = options.defines;
                 this.onError = options.onError;
                 this.onCompiled = options.onCompiled;
@@ -275,7 +275,7 @@
                 this._engine = <Engine>engine;
                 this.defines = <string>defines;
                 this._uniformsNames = (<string[]>uniformsNamesOrEngine).concat(<string[]>samplers);
-                this._samplers = <string[]>samplers;
+                this._samplers = samplers ? <string[]>samplers.slice() : [];
                 this._attributesNames = (<string[]>attributesNamesOrOptions);
 
                 this.onError = onError;

src/Materials/babylon.imageProcessingConfiguration.ts

@@ -18,10 +18,6 @@ module BABYLON {
         SAMPLER3DGREENDEPTH: boolean;
         SAMPLER3DBGRMAP: boolean;
         IMAGEPROCESSINGPOSTPROCESS: boolean;
-        /** 
-         * If the grain should be performed in the image processing shader.
-         */
-        GRAIN: boolean;
     }
 
     /**
@@ -221,57 +217,6 @@ module BABYLON {
         public vignetteCameraFov = 0.5;
 
         @serialize()
-        private _grainEnabled = false;
-
-        /**
-         * If the grain effect should be enabled.
-         */
-        public get grainEnabled(): boolean {
-            return this._grainEnabled;
-        }
-        public set grainEnabled(value: boolean) {
-            if (this._grainEnabled === value) {
-                return;
-            }
-
-            this._grainEnabled = value;
-            this._updateParameters();
-        }
-
-        @serialize()
-        private _grainIntensity = 30;
-        /**
-         * Amount of grain to be applied by the grain effect.
-         */
-        public get grainIntensity(): number {
-            return this._grainIntensity;
-        }
-        public set grainIntensity(value: number) {
-            if (this._grainIntensity === value) {
-                return;
-            }
-            this._grainIntensity = value;
-        }
-
-        @serialize()
-        private _grainAnimated = false;
-
-        /**
-         * If the grain effect should be animated.
-         */
-        public get grainAnimated(): boolean {
-            return this._grainAnimated;
-        }
-        public set grainAnimated(value: boolean) {
-            if (this._grainAnimated === value) {
-                return;
-            }
-
-            this._grainAnimated = value;
-            this._updateParameters();
-        }
-
-        @serialize()
         private _vignetteBlendMode = ImageProcessingConfiguration.VIGNETTEMODE_MULTIPLY;
         /**
          * Gets the vignette blend mode allowing different kind of effect.
@@ -353,7 +298,6 @@ module BABYLON {
 
         /**
         * An event triggered when the configuration changes and requires Shader to Update some parameters.
-        * @type {BABYLON.Observable}
         */
         public onUpdateParameters = new Observable<ImageProcessingConfiguration>();
 
@@ -391,10 +335,6 @@ module BABYLON {
             if (defines.COLORCURVES) {
                 ColorCurves.PrepareUniforms(uniforms);
             }
-            if (defines.GRAIN){
-                uniforms.push("grainVarianceAmount");
-                uniforms.push("grainAnimatedSeed");
-            }
         }
 
         /**
@@ -442,8 +382,7 @@ module BABYLON {
             defines.SAMPLER3DGREENDEPTH = this.colorGradingWithGreenDepth;
             defines.SAMPLER3DBGRMAP = this.colorGradingBGR;
             defines.IMAGEPROCESSINGPOSTPROCESS = this.applyByPostProcess;
-            defines.GRAIN = this.grainEnabled;
-            defines.IMAGEPROCESSING = defines.VIGNETTE || defines.TONEMAPPING || defines.CONTRAST || defines.EXPOSURE || defines.COLORCURVES || defines.COLORGRADING || defines.GRAIN;
+            defines.IMAGEPROCESSING = defines.VIGNETTE || defines.TONEMAPPING || defines.CONTRAST || defines.EXPOSURE || defines.COLORCURVES || defines.COLORGRADING;
         }
 
         /**
@@ -501,9 +440,6 @@ module BABYLON {
                     this.colorGradingTexture.level // weight
                 );
             }
-
-            effect.setFloat("grainVarianceAmount", this.grainIntensity);
-            effect.setFloat("grainAnimatedSeed", this.grainAnimated ? Math.random() + 1 : 1);
         }
 
         /**

src/Materials/babylon.material.ts

@@ -493,13 +493,11 @@
 
         /**
         * An event triggered when the material is disposed.
-        * @type {BABYLON.Observable}
         */
         public onDisposeObservable = new Observable<Material>();
 
         /**
          * An observer which watches for dispose events.
-         * @type {BABYLON.Observer}
          */
         private _onDisposeObserver: Nullable<Observer<Material>>;
 
@@ -515,13 +513,11 @@
 
         /**
         * An event triggered when the material is bound.
-        * @type {BABYLON.Observable}
         */
         public onBindObservable = new Observable<AbstractMesh>();
 
         /**
          * An observer which watches for bind events.
-         * @type {BABYLON.Observer}
          */
         private _onBindObserver: Nullable<Observer<AbstractMesh>>;
 
@@ -537,7 +533,6 @@
 
         /**
         * An event triggered when the material is unbound.
-        * @type {BABYLON.Observable}
         */
         public onUnBindObservable = new Observable<Material>();
 
@@ -549,6 +544,21 @@
 
         /**
          * Sets the value of the alpha mode.
+         *
+         * | Value | Type | Description |
+         * | --- | --- | --- |
+         * | 0 | ALPHA_DISABLE |   |
+         * | 1 | ALPHA_ADD |   |
+         * | 2 | ALPHA_COMBINE |   |
+         * | 3 | ALPHA_SUBTRACT |   |
+         * | 4 | ALPHA_MULTIPLY |   |
+         * | 5 | ALPHA_MAXIMIZED |   |
+         * | 6 | ALPHA_ONEONE |   |
+         * | 7 | ALPHA_PREMULTIPLIED |   |
+         * | 8 | ALPHA_PREMULTIPLIED_PORTERDUFF |   |
+         * | 9 | ALPHA_INTERPOLATE |   |
+         * | 10 | ALPHA_SCREENMODE |   |
+         *
          */
         public set alphaMode(value: number) {
             if (this._alphaMode === value) {

src/Materials/babylon.standardMaterial.ts

@@ -88,7 +88,6 @@ module BABYLON {
         public SAMPLER3DBGRMAP = false;
         public IMAGEPROCESSINGPOSTPROCESS = false;
         public EXPOSURE = false;
-        public GRAIN = false;
 
         constructor() {
             super();

src/Mesh/babylon.abstractMesh.ts

@@ -118,7 +118,6 @@
 
         /**
         * An event triggered when this mesh collides with another one
-        * @type {BABYLON.Observable}
         */
         public onCollideObservable = new Observable<AbstractMesh>();
 
@@ -132,7 +131,6 @@
 
         /**
         * An event triggered when the collision's position changes
-        * @type {BABYLON.Observable}
         */
         public onCollisionPositionChangeObservable = new Observable<Vector3>();
 
@@ -146,7 +144,6 @@
 
         /**
         * An event triggered when material is changed
-        * @type {BABYLON.Observable}
         */
         public onMaterialChangedObservable = new Observable<AbstractMesh>();
 
@@ -367,7 +364,6 @@
 
         /**
          * This scene's action manager
-         * @type {BABYLON.ActionManager}
         */
         public actionManager: Nullable<ActionManager> = null;
 

src/Mesh/babylon.mesh.ts

@@ -68,19 +68,16 @@
 
         /**
          * An event triggered before rendering the mesh
-         * @type {BABYLON.Observable}
          */
         public onBeforeRenderObservable = new Observable<Mesh>();
 
         /**
         * An event triggered after rendering the mesh
-        * @type {BABYLON.Observable}
         */
         public onAfterRenderObservable = new Observable<Mesh>();
 
         /**
         * An event triggered before drawing the mesh
-        * @type {BABYLON.Observable}
         */
         public onBeforeDrawObservable = new Observable<Mesh>();
 

src/Mesh/babylon.polygonMesh.ts

@@ -1,4 +1,5 @@
 module BABYLON {
+    declare var earcut: any;
     class IndexedVector2 extends Vector2 {
         constructor(original: Vector2, public index: number) {
             super(original.x, original.y);
@@ -131,6 +132,10 @@ module BABYLON {
 
             this._points.add(points);
             this._outlinepoints.add(points);
+
+            if (typeof earcut === 'undefined') {
+                Tools.Warn("Earcut was not found, the polygon will not be built.")
+            }
         }
 
         addHole(hole: Vector2[]): PolygonMeshBuilder {
@@ -161,7 +166,7 @@ module BABYLON {
 
             var indices = new Array<number>();
 
-            let res = Earcut.earcut(this._epoints, this._eholes, 2);
+            let res = earcut(this._epoints, this._eholes, 2);
 
             for (let i = 0; i < res.length; i++) {
                 indices.push(res[i]);

src/Mesh/babylon.transformNode.ts

@@ -6,6 +6,12 @@ module BABYLON {
         public static BILLBOARDMODE_Y = 2;
         public static BILLBOARDMODE_Z = 4;
         public static BILLBOARDMODE_ALL = 7;
+        
+        private _forward = new Vector3(0, 0, 1);
+        private _forwardInverted = new Vector3(0, 0, -1);
+        private _up = new Vector3(0, 1, 0);
+        private _right = new Vector3(1, 0, 0);
+        private _rightInverted = new Vector3(-1, 0, 0);
 
         // Properties
         @serializeAsVector3()
@@ -20,7 +26,7 @@ module BABYLON {
         private _transformToBoneReferal: Nullable<TransformNode>;
 
         @serialize()
-        public billboardMode = AbstractMesh.BILLBOARDMODE_NONE;
+        public billboardMode = TransformNode.BILLBOARDMODE_NONE;
 
         @serialize()
         public scalingDeterminant = 1;
@@ -45,7 +51,6 @@ module BABYLON {
 
         /**
         * An event triggered after the world matrix is updated
-        * @type {BABYLON.Observable}
         */
         public onAfterWorldMatrixUpdateObservable = new Observable<TransformNode>();
 
@@ -112,6 +117,36 @@ module BABYLON {
         }
 
         /**
+         * The forward direction of that transform in world space.
+         */
+        public get forward(): Vector3 {
+            return Vector3.Normalize(Vector3.TransformNormal(
+                this.getScene().useRightHandedSystem ? this._forwardInverted : this._forward,
+                this.getWorldMatrix()
+            ));
+        }
+
+        /**
+         * The up direction of that transform in world space.
+         */
+        public get up(): Vector3 {
+            return Vector3.Normalize(Vector3.TransformNormal(
+                this._up,
+                this.getWorldMatrix()
+            ));
+        }
+
+        /**
+         * The right direction of that transform in world space.
+         */
+        public get right(): Vector3 {
+            return Vector3.Normalize(Vector3.TransformNormal(
+                this.getScene().useRightHandedSystem ? this._rightInverted : this._right,
+                this.getWorldMatrix()
+            ));
+        }
+
+        /**
          * Returns the latest update of the World matrix
          * Returns a Matrix.  
          */
@@ -139,7 +174,7 @@ module BABYLON {
 
         /**
          * Copies the paramater passed Matrix into the mesh Pose matrix.  
-         * Returns the AbstractMesh.  
+         * Returns the TransformNode.  
          */
         public updatePoseMatrix(matrix: Matrix): TransformNode {
             this._poseMatrix.copyFrom(matrix);
@@ -159,7 +194,7 @@ module BABYLON {
                 return false;
             }
 
-            if (this.billboardMode !== this._cache.billboardMode || this.billboardMode !== AbstractMesh.BILLBOARDMODE_NONE)
+            if (this.billboardMode !== this._cache.billboardMode || this.billboardMode !== TransformNode.BILLBOARDMODE_NONE)
                 return false;
 
             if (this._cache.pivotMatrixUpdated) {
@@ -257,7 +292,7 @@ module BABYLON {
 
         /**
          * Prevents the World matrix to be computed any longer.
-         * Returns the AbstractMesh.  
+         * Returns the TransformNode.  
          */
         public freezeWorldMatrix(): TransformNode {
             this._isWorldMatrixFrozen = false;  // no guarantee world is not already frozen, switch off temporarily
@@ -268,7 +303,7 @@ module BABYLON {
 
         /**
          * Allows back the World matrix computation. 
-         * Returns the AbstractMesh.  
+         * Returns the TransformNode.  
          */
         public unfreezeWorldMatrix() {
             this._isWorldMatrixFrozen = false;
@@ -295,7 +330,7 @@ module BABYLON {
 
         /**
          * Sets the mesh absolute position in the World from a Vector3 or an Array(3).
-         * Returns the AbstractMesh.  
+         * Returns the TransformNode.  
          */
         public setAbsolutePosition(absolutePosition: Vector3): TransformNode {
             if (!absolutePosition) {
@@ -332,7 +367,7 @@ module BABYLON {
 
         /**
            * Sets the mesh position in its local space.  
-           * Returns the AbstractMesh.  
+           * Returns the TransformNode.  
            */
         public setPositionWithLocalVector(vector3: Vector3): TransformNode {
             this.computeWorldMatrix();
@@ -354,7 +389,7 @@ module BABYLON {
 
         /**
          * Translates the mesh along the passed Vector3 in its local space.  
-         * Returns the AbstractMesh. 
+         * Returns the TransformNode. 
          */
         public locallyTranslate(vector3: Vector3): TransformNode {
             this.computeWorldMatrix(true);
@@ -374,7 +409,7 @@ module BABYLON {
          * @returns the TransformNode. 
          */
         public lookAt(targetPoint: Vector3, yawCor: number = 0, pitchCor: number = 0, rollCor: number = 0, space: Space = Space.LOCAL): TransformNode {
-            var dv = AbstractMesh._lookAtVectorCache;
+            var dv = TransformNode._lookAtVectorCache;
             var pos = space === Space.LOCAL ? this.position : this.getAbsolutePosition();
             targetPoint.subtractToRef(pos, dv);
             var yaw = -Math.atan2(dv.z, dv.x) - Math.PI / 2;
@@ -407,7 +442,7 @@ module BABYLON {
          * Sets the Vector3 "result" as the rotated Vector3 "localAxis" in the same rotation than the mesh.
          * localAxis is expressed in the mesh local space.
          * result is computed in the Wordl space from the mesh World matrix.  
-         * Returns the AbstractMesh.  
+         * Returns the TransformNode.  
          */
         public getDirectionToRef(localAxis: Vector3, result: Vector3): TransformNode {
             Vector3.TransformNormalToRef(localAxis, this.getWorldMatrix(), result);
@@ -447,7 +482,7 @@ module BABYLON {
 
         /**
          * Sets the passed Vector3 "result" with the coordinates of the mesh pivot point in the local space.   
-         * Returns the AbstractMesh.   
+         * Returns the TransformNode.   
          */
         public getPivotPointToRef(result: Vector3): TransformNode {
             result.x = -this._pivotMatrix.m[12];
@@ -467,7 +502,7 @@ module BABYLON {
 
         /**
          * Sets the Vector3 "result" coordinates with the mesh pivot point World coordinates.  
-         * Returns the AbstractMesh.  
+         * Returns the TransformNode.  
          */
         public getAbsolutePivotPointToRef(result: Vector3): TransformNode {
             result.x = this._pivotMatrix.m[12];
@@ -590,7 +625,7 @@ module BABYLON {
          * space (default LOCAL) can be either BABYLON.Space.LOCAL, either BABYLON.Space.WORLD.
          * Note that the property `rotationQuaternion` is then automatically updated and the property `rotation` is set to (0,0,0) and no longer used.  
          * The passed axis is also normalized.  
-         * Returns the AbstractMesh.
+         * Returns the TransformNode.
          */
         public rotate(axis: Vector3, amount: number, space?: Space): TransformNode {
             axis.normalize();
@@ -600,7 +635,7 @@ module BABYLON {
             }
             var rotationQuaternion: Quaternion;
             if (!space || (space as any) === Space.LOCAL) {
-                rotationQuaternion = Quaternion.RotationAxisToRef(axis, amount, AbstractMesh._rotationAxisCache);
+                rotationQuaternion = Quaternion.RotationAxisToRef(axis, amount, TransformNode._rotationAxisCache);
                 this.rotationQuaternion.multiplyToRef(rotationQuaternion, this.rotationQuaternion);
             }
             else {
@@ -609,7 +644,7 @@ module BABYLON {
                     invertParentWorldMatrix.invert();
                     axis = Vector3.TransformNormal(axis, invertParentWorldMatrix);
                 }
-                rotationQuaternion = Quaternion.RotationAxisToRef(axis, amount, AbstractMesh._rotationAxisCache);
+                rotationQuaternion = Quaternion.RotationAxisToRef(axis, amount, TransformNode._rotationAxisCache);
                 rotationQuaternion.multiplyToRef(this.rotationQuaternion, this.rotationQuaternion);
             }
             return this;
@@ -619,7 +654,7 @@ module BABYLON {
          * Rotates the mesh around the axis vector for the passed angle (amount) expressed in radians, in world space.  
          * Note that the property `rotationQuaternion` is then automatically updated and the property `rotation` is set to (0,0,0) and no longer used.  
          * The passed axis is also normalized.  
-         * Returns the AbstractMesh.
+         * Returns the TransformNode.
          * Method is based on http://www.euclideanspace.com/maths/geometry/affine/aroundPoint/index.htm
          */
         public rotateAround(point: Vector3, axis: Vector3, amount: number): TransformNode {
@@ -646,7 +681,7 @@ module BABYLON {
         /**
          * Translates the mesh along the axis vector for the passed distance in the given space.  
          * space (default LOCAL) can be either BABYLON.Space.LOCAL, either BABYLON.Space.WORLD.
-         * Returns the AbstractMesh.
+         * Returns the TransformNode.
          */
         public translate(axis: Vector3, distance: number, space?: Space): TransformNode {
             var displacementVector = axis.scale(distance);
@@ -672,7 +707,7 @@ module BABYLON {
          * ```
          * Note that `addRotation()` accumulates the passed rotation values to the current ones and computes the .rotation or .rotationQuaternion updated values.  
          * Under the hood, only quaternions are used. So it's a little faster is you use .rotationQuaternion because it doesn't need to translate them back to Euler angles.   
-         * Returns the AbstractMesh.  
+         * Returns the TransformNode.  
          */
         public addRotation(x: number, y: number, z: number): TransformNode {
             var rotationQuaternion;
@@ -705,6 +740,7 @@ module BABYLON {
             }
 
             if (!force && this.isSynchronized(true)) {
+                this._currentRenderId = this.getScene().getRenderId();
                 return this._worldMatrix;
             }
 
@@ -713,6 +749,7 @@ module BABYLON {
             this._cache.pivotMatrixUpdated = false;
             this._cache.billboardMode = this.billboardMode;
             this._currentRenderId = this.getScene().getRenderId();
+            this._childRenderId = this.getScene().getRenderId();
             this._isDirty = false;
 
             // Scaling
@@ -757,8 +794,8 @@ module BABYLON {
             Tmp.Matrix[4].multiplyToRef(Tmp.Matrix[0], Tmp.Matrix[5]);
 
             // Billboarding (testing PG:http://www.babylonjs-playground.com/#UJEIL#13)
-            if (this.billboardMode !== AbstractMesh.BILLBOARDMODE_NONE && camera) {
-                if ((this.billboardMode & AbstractMesh.BILLBOARDMODE_ALL) !== AbstractMesh.BILLBOARDMODE_ALL) {
+            if (this.billboardMode !== TransformNode.BILLBOARDMODE_NONE && camera) {
+                if ((this.billboardMode & TransformNode.BILLBOARDMODE_ALL) !== TransformNode.BILLBOARDMODE_ALL) {
                     // Need to decompose each rotation here
                     var currentPosition = Tmp.Vector3[3];
 
@@ -776,15 +813,15 @@ module BABYLON {
                     currentPosition.subtractInPlace(camera.globalPosition);
 
                     var finalEuler = Tmp.Vector3[4].copyFromFloats(0, 0, 0);
-                    if ((this.billboardMode & AbstractMesh.BILLBOARDMODE_X) === AbstractMesh.BILLBOARDMODE_X) {
+                    if ((this.billboardMode & TransformNode.BILLBOARDMODE_X) === TransformNode.BILLBOARDMODE_X) {
                         finalEuler.x = Math.atan2(-currentPosition.y, currentPosition.z);
                     }
 
-                    if ((this.billboardMode & AbstractMesh.BILLBOARDMODE_Y) === AbstractMesh.BILLBOARDMODE_Y) {
+                    if ((this.billboardMode & TransformNode.BILLBOARDMODE_Y) === TransformNode.BILLBOARDMODE_Y) {
                         finalEuler.y = Math.atan2(currentPosition.x, currentPosition.z);
                     }
 
-                    if ((this.billboardMode & AbstractMesh.BILLBOARDMODE_Z) === AbstractMesh.BILLBOARDMODE_Z) {
+                    if ((this.billboardMode & TransformNode.BILLBOARDMODE_Z) === TransformNode.BILLBOARDMODE_Z) {
                         finalEuler.z = Math.atan2(currentPosition.y, currentPosition.x);
                     }
 
@@ -805,7 +842,7 @@ module BABYLON {
 
             // Parent
             if (this.parent && this.parent.getWorldMatrix) {
-                if (this.billboardMode !== AbstractMesh.BILLBOARDMODE_NONE) {
+                if (this.billboardMode !== TransformNode.BILLBOARDMODE_NONE) {
                     if (this._transformToBoneReferal) {
                         this.parent.getWorldMatrix().multiplyToRef(this._transformToBoneReferal.getWorldMatrix(), Tmp.Matrix[6]);
                         Tmp.Matrix[5].copyFrom(Tmp.Matrix[6]);
@@ -990,4 +1027,4 @@ module BABYLON {
         }
 
     }
-}
+}

src/Particles/EmitterTypes/babylon.boxParticleEmitter.ts

@@ -24,7 +24,7 @@ module BABYLON {
         public maxEmitBox = new Vector3(0.5, 0.5, 0.5);  
                
         /**
-         * Creates a new instance of @see BoxParticleEmitter
+         * Creates a new instance BoxParticleEmitter
          */
         constructor() {
 

src/Particles/EmitterTypes/babylon.coneParticleEmitter.ts

@@ -29,7 +29,7 @@ module BABYLON {
         }
 
         /**
-         * Creates a new instance of @see ConeParticleEmitter
+         * Creates a new instance ConeParticleEmitter
          * @param radius the radius of the emission cone (1 by default)
          * @param angles the cone base angle (PI by default)
          * @param directionRandomizer defines how much to randomize the particle direction [0-1]

src/Particles/EmitterTypes/babylon.sphereParticleEmitter.ts

@@ -6,7 +6,7 @@ module BABYLON {
     export class SphereParticleEmitter implements IParticleEmitterType {
 
         /**
-         * Creates a new instance of @see SphereParticleEmitter
+         * Creates a new instance SphereParticleEmitter
          * @param radius the radius of the emission sphere (1 by default)
          * @param directionRandomizer defines how much to randomize the particle direction [0-1]
          */
@@ -125,7 +125,7 @@ module BABYLON {
     export class SphereDirectedParticleEmitter extends SphereParticleEmitter {
 
         /**
-         * Creates a new instance of @see SphereDirectedParticleEmitter
+         * Creates a new instance SphereDirectedParticleEmitter
          * @param radius the radius of the emission sphere (1 by default)
          * @param direction1 the min limit of the emission direction (up vector by default)
          * @param direction2 the max limit of the emission direction (up vector by default)

src/Particles/babylon.IParticleSystem.ts

@@ -2,7 +2,7 @@ module BABYLON {
     /**
      * Interface representing a particle system in Babylon.
      * This groups the common functionalities that needs to be implemented in order to create a particle system.
-     * A particle system represents a way to manage particles (@see Particle) from their emission to their animation and rendering.
+     * A particle system represents a way to manage particles from their emission to their animation and rendering.
      */
     export interface IParticleSystem {
         /**

src/Particles/babylon.particle.ts

@@ -58,7 +58,7 @@
         private _currentFrameCounter = 0;
 
         /**
-         * Creates a new instance of @see Particle
+         * Creates a new instance Particle
          * @param particleSystem the particle system the particle belongs to
          */
         constructor(

src/Particles/babylon.solidParticle.ts

@@ -1,7 +1,6 @@
 module BABYLON {
     /**
      * Represents one particle of a solid particle system.
-     * @see SolidParticleSystem
      */
     export class SolidParticle {
         /**
@@ -177,7 +176,6 @@ module BABYLON {
     /**
      * Represents the shape of the model used by one particle of a solid particle system.
      * SPS internal tool, don't use it manually.
-     * @see SolidParticleSystem
      */
     export class ModelShape {
         /**
@@ -223,7 +221,6 @@ module BABYLON {
 
     /**
      * Represents a Depth Sorted Particle in the solid particle system.
-     * @see SolidParticleSystem
      */
     export class DepthSortedParticle {
         /**

src/PostProcess/RenderPipeline/Pipelines/babylon.defaultRenderingPipeline.ts

@@ -9,27 +9,7 @@
         /**
 		 * ID of the sharpen post process,
 		 */
-        readonly SharpenPostProcessId: string = "SharpenPostProcessEffect";
-        /**
-		 * ID of the pass post process used for bloom,
-		 */
-        readonly PassPostProcessId: string = "PassPostProcessEffect";
-        /**
-		 * ID of the highlight post process used for bloom,
-		 */
-        readonly HighLightsPostProcessId: string = "HighLightsPostProcessEffect";
-        /**
-		 * ID of the blurX post process used for bloom,
-		 */
-        readonly BlurXPostProcessId: string = "BlurXPostProcessEffect";
-        /**
-		 * ID of the blurY post process used for bloom,
-		 */
-        readonly BlurYPostProcessId: string = "BlurYPostProcessEffect";
-        /**
-		 * ID of the copy back post process used for bloom,
-		 */
-        readonly CopyBackPostProcessId: string = "CopyBackPostProcessEffect";
+        private readonly SharpenPostProcessId: string = "SharpenPostProcessEffect";
         /**
 		 * ID of the image processing post process;
 		 */
@@ -39,13 +19,13 @@
 		 */
         readonly FxaaPostProcessId: string = "FxaaPostProcessEffect";
         /**
-		 * ID of the final merge post process;
+		 * ID of the chromatic aberration post process,
 		 */
-        readonly FinalMergePostProcessId: string = "FinalMergePostProcessEffect";
+        private readonly ChromaticAberrationPostProcessId: string = "ChromaticAberrationPostProcessEffect";
         /**
-		 * ID of the chromatic aberration post process,
+		 * ID of the grain post process
 		 */
-        readonly ChromaticAberrationPostProcessId: string = "ChromaticAberrationPostProcessEffect";
+        private readonly GrainPostProcessId: string = "GrainPostProcessEffect";
 
         // Post-processes
         /**
@@ -53,26 +33,7 @@
 		 */
         public sharpen: SharpenPostProcess;
         private _sharpenEffect: PostProcessRenderEffect;
-        /**
-		 * First pass of bloom to capture the original image texture for later use.
-		 */
-        public pass: PassPostProcess;
-        /**
-		 * Second pass of bloom used to brighten bright portions of the image.
-		 */
-        public highlights: HighlightsPostProcess;
-        /**
-		 * BlurX post process used in coordination with blurY to guassian blur the highlighted image.
-		 */
-        public blurX: BlurPostProcess;
-        /**
-		 * BlurY post process used in coordination with blurX to guassian blur the highlighted image.
-		 */
-        public blurY: BlurPostProcess;
-        /**
-		 * Final pass run for bloom to copy the resulting bloom texture back to screen.
-		 */
-        public copyBack: PassPostProcess;
+        private bloom: BloomEffect;
         /**
          * Depth of field effect, applies a blur based on how far away objects are from the focus distance.
          */
@@ -86,31 +47,33 @@
          */
         public imageProcessing: ImageProcessingPostProcess;
         /**
-         * Final post process to merge results of all previous passes
-         */
-        public finalMerge: PassPostProcess;
-        /**
 		 * Chromatic aberration post process which will shift rgb colors in the image
 		 */
         public chromaticAberration: ChromaticAberrationPostProcess;
         private _chromaticAberrationEffect: PostProcessRenderEffect;
+        /**
+		 * Grain post process which add noise to the image
+		 */
+        public grain: GrainPostProcess;
+        private _grainEffect: PostProcessRenderEffect;
 
         /**
          * Animations which can be used to tweak settings over a period of time
          */
         public animations: Animation[] = [];
 
+        private _imageProcessingConfigurationObserver:Nullable<Observer<ImageProcessingConfiguration>> = null;
         // Values   
         private _sharpenEnabled:boolean = false;    
         private _bloomEnabled: boolean = false;
         private _depthOfFieldEnabled: boolean = false;
         private _depthOfFieldBlurLevel = DepthOfFieldEffectBlurLevel.Low;
         private _fxaaEnabled: boolean = false;
-        private _msaaEnabled: boolean = false;
         private _imageProcessingEnabled: boolean = true;
         private _defaultPipelineTextureType: number;
-        private _bloomScale: number = 0.6;
+        private _bloomScale: number = 0.5;
         private _chromaticAberrationEnabled:boolean = false;  
+        private _grainEnabled:boolean = false;  
 
         private _buildAllowed = true;
 
@@ -131,18 +94,31 @@
             return this._sharpenEnabled;
         }
 
-
+        private _resizeObserver:Nullable<Observer<Engine>> = null;
+        private _hardwareScaleLevel = 1.0;
+        private _bloomKernel: number = 64;
         /**
 		 * Specifies the size of the bloom blur kernel, relative to the final output size
 		 */
         @serialize()
-        public bloomKernel: number = 64;
+        public get bloomKernel(): number{
+            return this._bloomKernel;
+        }
+        public set bloomKernel(value: number){
+            this._bloomKernel = value;
+            this.bloom.kernel = value/this._hardwareScaleLevel;
+        }
 
         /**
 		 * Specifies the weight of the bloom in the final rendering
 		 */
         @serialize()
         private _bloomWeight: number = 0.15;
+        /**
+		 * Specifies the luma threshold for the area that will be blurred by the bloom
+		 */
+        @serialize()
+        private _bloomThreshold: number = 0.9;
 
         @serialize()
         private _hdr: boolean;
@@ -154,11 +130,9 @@
             if (this._bloomWeight === value) {
                 return;
             }
+            this.bloom.weight = value;
+            
             this._bloomWeight = value;
-
-            if (this._hdr && this.copyBack) {
-                this.copyBack.alphaConstants = new Color4(value, value, value, value);
-            }
         }
 
         @serialize()
@@ -167,6 +141,22 @@
         }
 
         /**
+         * The strength of the bloom.
+         */
+        public set bloomThreshold(value: number) {
+            if (this._bloomThreshold === value) {
+                return;
+            }
+            this.bloom.threshold = value;
+            this._bloomThreshold = value;
+        }
+
+        @serialize()
+        public get bloomThreshold(): number {
+            return this._bloomThreshold;
+        }
+
+        /**
          * The scale of the bloom, lower value will provide better performance.
          */
         public set bloomScale(value: number) {
@@ -175,6 +165,9 @@
             }
             this._bloomScale = value;
 
+            // recreate bloom and dispose old as this setting is not dynamic
+            this._rebuildBloom();
+
             this._buildPipeline();
         }
 
@@ -200,6 +193,16 @@
             return this._bloomEnabled;
         }
 
+        private _rebuildBloom(){
+            // recreate bloom and dispose old as this setting is not dynamic
+            var oldBloom = this.bloom;
+            this.bloom = new BloomEffect(this._scene, this.bloomScale, this._bloomWeight, this.bloomKernel, this._defaultPipelineTextureType, false);
+            this.bloom.threshold = oldBloom.threshold;
+            for (var i = 0; i < this._cameras.length; i++) {
+                oldBloom.disposeEffects(this._cameras[i]);
+            }
+        }
+
         /**
          * If the depth of field is enabled.
          */
@@ -234,7 +237,7 @@
             // recreate dof and dispose old as this setting is not dynamic
             var oldDof = this.depthOfField;
             
-            this.depthOfField = new DepthOfFieldEffect(this._scene, null, this._depthOfFieldBlurLevel, this._defaultPipelineTextureType);
+            this.depthOfField = new DepthOfFieldEffect(this._scene, null, this._depthOfFieldBlurLevel, this._defaultPipelineTextureType, false);
             this.depthOfField.focalLength = oldDof.focalLength;
             this.depthOfField.focusDistance = oldDof.focusDistance;
             this.depthOfField.fStop = oldDof.fStop;
@@ -264,21 +267,22 @@
             return this._fxaaEnabled;
         }
 
+        private _samples = 1;
         /**
-         * If the multisample anti-aliasing is enabled.
+         * MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
          */
-        public set msaaEnabled(enabled: boolean) {
-            if (this._msaaEnabled === enabled) {
+        public set samples(sampleCount: number) {
+            if (this._samples === sampleCount) {
                 return;
             }
-            this._msaaEnabled = enabled;
+            this._samples = sampleCount;
 
             this._buildPipeline();
         }
 
         @serialize()
-        public get msaaEnabled(): boolean {
-            return this._msaaEnabled;
+        public get samples(): number {
+            return this._samples;
         }
 
         /**
@@ -314,6 +318,22 @@
         public get chromaticAberrationEnabled(): boolean {
             return this._chromaticAberrationEnabled;
         }
+        /**
+         * Enable or disable the grain process from the pipeline
+         */
+        public set grainEnabled(enabled: boolean) {
+            if (this._grainEnabled === enabled) {
+                return;
+            }
+            this._grainEnabled = enabled;
+
+            this._buildPipeline();
+        }
+
+        @serialize()
+        public get grainEnabled(): boolean {
+            return this._grainEnabled;
+        }
 
         /**
          * @constructor
@@ -358,9 +378,23 @@
 
             this.depthOfField = new DepthOfFieldEffect(this._scene, null, this._depthOfFieldBlurLevel, this._defaultPipelineTextureType, true);
             
+            this.bloom = new BloomEffect(this._scene, this._bloomScale, this._bloomWeight, this.bloomKernel, this._defaultPipelineTextureType, true);
+
             this.chromaticAberration = new ChromaticAberrationPostProcess("ChromaticAberration", engine.getRenderWidth(), engine.getRenderHeight(), 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType, true);
             this._chromaticAberrationEffect = new PostProcessRenderEffect(engine, this.ChromaticAberrationPostProcessId, () => { return this.chromaticAberration; }, true);
-            
+
+            this.grain = new GrainPostProcess("Grain", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType, true);
+            this._grainEffect = new PostProcessRenderEffect(engine, this.GrainPostProcessId, () => { return this.grain; }, true);
+
+            this._resizeObserver = engine.onResizeObservable.add(()=>{
+                this._hardwareScaleLevel = engine.getHardwareScalingLevel();
+                this.bloomKernel = this.bloomKernel
+            })
+
+            this._imageProcessingConfigurationObserver = this._scene.imageProcessingConfiguration.onUpdateParameters.add(()=>{
+                this.bloom._downscale._exposure = this._scene.imageProcessingConfiguration.exposure;
+            })
+
             this._buildPipeline();
         }
 
@@ -374,14 +408,17 @@
             this._buildAllowed = previousState;
         }
 
+        private _hasCleared = false;
         private _prevPostProcess:Nullable<PostProcess> = null;
         private _prevPrevPostProcess:Nullable<PostProcess> = null;
 
         private _setAutoClearAndTextureSharing(postProcess:PostProcess, skipTextureSharing = false){
-            if(this._prevPostProcess && this._prevPostProcess.autoClear){
+            if(this._hasCleared){
                 postProcess.autoClear = false;
             }else{
                 postProcess.autoClear = true;
+                this._scene.autoClear = false;
+                this._hasCleared = true;
             }
 
             if(!skipTextureSharing){
@@ -402,7 +439,8 @@
             if (!this._buildAllowed) {
                 return;
             }
-
+            this._scene.autoClear = true;
+            
             var engine = this._scene.getEngine();
 
             this._disposePostProcesses();
@@ -414,14 +452,7 @@
             this._reset();
             this._prevPostProcess = null;
             this._prevPrevPostProcess = null;
-
-            if (this.sharpenEnabled) {
-                if(!this.sharpen.isReady()){
-                    this.sharpen.updateEffect();
-                }
-                this.addEffect(this._sharpenEffect);
-                this._setAutoClearAndTextureSharing(this.sharpen);
-            }
+            this._hasCleared = false;            
 
             if (this.depthOfFieldEnabled) {
                 var depthTexture = this._scene.enableDepthRenderer(this._cameras[0]).getDepthMap();
@@ -430,90 +461,41 @@
                     this.depthOfField._updateEffects();
                 }
                 this.addEffect(this.depthOfField);
-                this._setAutoClearAndTextureSharing(this.depthOfField._depthOfFieldMerge);
+                this._setAutoClearAndTextureSharing(this.depthOfField._effects[0], true);
             }
 
             if (this.bloomEnabled) {
-                this.pass = new PassPostProcess("sceneRenderTarget", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-                this._setAutoClearAndTextureSharing(this.pass, true);
-                this.addEffect(new PostProcessRenderEffect(engine, this.PassPostProcessId, () => { return this.pass; }, true));
-
-                if (!this._hdr) { // Need to enhance highlights if not using float rendering
-                    this.highlights = new HighlightsPostProcess("highlights", this.bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-                    this.addEffect(new PostProcessRenderEffect(engine, this.HighLightsPostProcessId, () => { return this.highlights; }, true));
-                    this.highlights.autoClear = false;
-                    this.highlights.alwaysForcePOT = true;
-                }
-
-                this.blurX = new BlurPostProcess("horizontal blur", new Vector2(1.0, 0), 10.0, this.bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-                this.addEffect(new PostProcessRenderEffect(engine, this.BlurXPostProcessId, () => { return this.blurX; }, true));
-                this.blurX.alwaysForcePOT = true;
-                this.blurX.autoClear = false;
-                this.blurX.onActivateObservable.add(() => {
-                    let dw = this.blurX.width / engine.getRenderWidth(true);
-                    this.blurX.kernel = this.bloomKernel * dw;
-                });
-
-                this.blurY = new BlurPostProcess("vertical blur", new Vector2(0, 1.0), 10.0, this.bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-                this.addEffect(new PostProcessRenderEffect(engine, this.BlurYPostProcessId, () => { return this.blurY; }, true));
-                this.blurY.alwaysForcePOT = true;
-                this.blurY.autoClear = false;
-                this.blurY.onActivateObservable.add(() => {
-                    let dh = this.blurY.height / engine.getRenderHeight(true);
-                    this.blurY.kernel = this.bloomKernel * dh;
-                });
-
-                this.copyBack = new PassPostProcess("bloomBlendBlit", this.bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-                this.addEffect(new PostProcessRenderEffect(engine, this.CopyBackPostProcessId, () => { return this.copyBack; }, true));
-                this.copyBack.alwaysForcePOT = true;
-                if (this._hdr) {
-                    this.copyBack.alphaMode = Engine.ALPHA_INTERPOLATE;
-                    let w = this.bloomWeight;
-                    this.copyBack.alphaConstants = new Color4(w, w, w, w);
-                } else {
-                    this.copyBack.alphaMode = Engine.ALPHA_SCREENMODE;
-                }
-                this.copyBack.autoClear = false;
-            }
-
-            if (this._imageProcessingEnabled) {
-                this.imageProcessing = new ImageProcessingPostProcess("imageProcessing", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-                if (this._hdr) {
-                    this.addEffect(new PostProcessRenderEffect(engine, this.ImageProcessingPostProcessId, () => { return this.imageProcessing; }, true));
-                } else {
-                    this._scene.imageProcessingConfiguration.applyByPostProcess = false;
+                if(!this.bloom._isReady()){
+                    this.bloom._updateEffects();
                 }
+                this.addEffect(this.bloom);
+                this._setAutoClearAndTextureSharing(this.bloom._effects[0], true);
             }
 
-            if (this._hdr && this.imageProcessing) {
-                this.finalMerge = this.imageProcessing;
-            }
-            else {
-                this.finalMerge = new PassPostProcess("finalMerge", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-                this.addEffect(new PostProcessRenderEffect(engine, this.FinalMergePostProcessId, () => { return this.finalMerge; }, true));
-                this._setAutoClearAndTextureSharing(this.finalMerge, true);
-                
-                this.finalMerge.autoClear = !this.bloomEnabled && (!this._hdr || !this.imageProcessing);
+            if (this._imageProcessingEnabled) {	
+                this.imageProcessing = new ImageProcessingPostProcess("imageProcessing", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);	
+                if (this._hdr) {	
+                    this.addEffect(new PostProcessRenderEffect(engine, this.ImageProcessingPostProcessId, () => { return this.imageProcessing; }, true));	
+                    this._setAutoClearAndTextureSharing(this.imageProcessing);	
+                } else {		
+                    this._scene.imageProcessingConfiguration.applyByPostProcess = false;		
+                }		
             }
 
-            if (this.bloomEnabled) {
-                if (this._hdr) { // Share render targets to save memory
-                    this.copyBack.shareOutputWith(this.blurX);
-                    if (this.imageProcessing) {
-                        this.imageProcessing.shareOutputWith(this.pass);
-                        this.imageProcessing.autoClear = false;
-                    } else {
-                        this.finalMerge.shareOutputWith(this.pass);
-                    }
-                } else {
-                    this.finalMerge.shareOutputWith(this.pass);
+            if (this.sharpenEnabled) {
+                if(!this.sharpen.isReady()){
+                    this.sharpen.updateEffect();
                 }
+                this.addEffect(this._sharpenEffect);
+                this._setAutoClearAndTextureSharing(this.sharpen);
             }
 
-            if (this.fxaaEnabled) {
-                this.fxaa = new FxaaPostProcess("fxaa", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
-                this.addEffect(new PostProcessRenderEffect(engine, this.FxaaPostProcessId, () => { return this.fxaa; }, true));
-                this._setAutoClearAndTextureSharing(this.fxaa);
+            if (this.grainEnabled) {
+                if(!this.grain.isReady()){
+                    this.grain.updateEffect();
+                }
+                this.addEffect(this._grainEffect);
+                this._setAutoClearAndTextureSharing(this.grain);
             }
 
             if (this.chromaticAberrationEnabled) {
@@ -524,14 +506,19 @@
                 this._setAutoClearAndTextureSharing(this.chromaticAberration);
             }
 
+            if (this.fxaaEnabled) {
+                this.fxaa = new FxaaPostProcess("fxaa", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, engine, false, this._defaultPipelineTextureType);
+                this.addEffect(new PostProcessRenderEffect(engine, this.FxaaPostProcessId, () => { return this.fxaa; }, true));
+                this._setAutoClearAndTextureSharing(this.fxaa, true);
+            }
+
             if (this._cameras !== null) {
                 this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
             }
 
-            if(this.msaaEnabled){
-                if(!this._enableMSAAOnFirstPostProcess()){
-                    BABYLON.Tools.Warn("MSAA failed to enable, MSAA is only supported in browsers that support webGL >= 2.0");
-                }
+            
+            if(!this._enableMSAAOnFirstPostProcess(this.samples) && this.samples > 1){
+                BABYLON.Tools.Warn("MSAA failed to enable, MSAA is only supported in browsers that support webGL >= 2.0");
             }
         }
 
@@ -539,26 +526,6 @@
             for (var i = 0; i < this._cameras.length; i++) {
                 var camera = this._cameras[i];
 
-                if (this.pass) {
-                    this.pass.dispose(camera);
-                }
-
-                if (this.highlights) {
-                    this.highlights.dispose(camera);
-                }
-
-                if (this.blurX) {
-                    this.blurX.dispose(camera);
-                }
-
-                if (this.blurY) {
-                    this.blurY.dispose(camera);
-                }
-
-                if (this.copyBack) {
-                    this.copyBack.dispose(camera);
-                }
-
                 if (this.imageProcessing) {
                     this.imageProcessing.dispose(camera);
                 }
@@ -567,10 +534,6 @@
                     this.fxaa.dispose(camera);
                 }
 
-                if (this.finalMerge) {
-                    this.finalMerge.dispose(camera);
-                }
-
                 // These are created in the constructor and should not be disposed on every pipeline change
                 if(disposeNonRecreated){
                     if (this.sharpen) {
@@ -580,26 +543,33 @@
                     if(this.depthOfField){
                         this.depthOfField.disposeEffects(camera);
                     }
+
+                    if(this.bloom){
+                        this.bloom.disposeEffects(camera);
+                    }
     
                     if(this.chromaticAberration){
                         this.chromaticAberration.dispose(camera);
                     }
+
+                    if(this.grain){
+                        this.grain.dispose(camera);
+                    }
                 }
             }
-
-            (<any>this.pass) = null;
-            (<any>this.highlights) = null;
-            (<any>this.blurX) = null;
-            (<any>this.blurY) = null;
-            (<any>this.copyBack) = null;
+            
             (<any>this.imageProcessing) = null;
             (<any>this.fxaa) = null;
-            (<any>this.finalMerge) = null;
 
             if(disposeNonRecreated){
                 (<any>this.sharpen) = null;
+                (<any>this._sharpenEffect) = null;
                 (<any>this.depthOfField) = null;
+                (<any>this.bloom) = null;
                 (<any>this.chromaticAberration) = null;
+                (<any>this._chromaticAberrationEffect) = null;
+                (<any>this.grain) = null;
+                (<any>this._grainEffect) = null;
             } 
         }
 
@@ -608,9 +578,13 @@
          */
         public dispose(): void {
             this._disposePostProcesses(true);
-
             this._scene.postProcessRenderPipelineManager.detachCamerasFromRenderPipeline(this._name, this._cameras);
-
+            this._scene.autoClear = true;
+            if(this._resizeObserver){
+                this._scene.getEngine().onResizeObservable.remove(this._resizeObserver);
+                this._resizeObserver = null;
+            }
+            this._scene.imageProcessingConfiguration.onUpdateParameters.remove(this._imageProcessingConfigurationObserver)
             super.dispose();
         }
 

src/PostProcess/RenderPipeline/Pipelines/babylon.lensRenderingPipeline.ts

@@ -21,17 +21,14 @@ module BABYLON {
 
         /**
         * The chromatic aberration PostProcess id in the pipeline
-        * @type {string}
         */
         public LensChromaticAberrationEffect: string = "LensChromaticAberrationEffect";
         /**
         * The highlights enhancing PostProcess id in the pipeline
-        * @type {string}
         */
         public HighlightsEnhancingEffect: string = "HighlightsEnhancingEffect";
         /**
         * The depth-of-field PostProcess id in the pipeline
-        * @type {string}
         */
         public LensDepthOfFieldEffect: string = "LensDepthOfFieldEffect";
 

src/PostProcess/RenderPipeline/Pipelines/babylon.ssao2RenderingPipeline.ts

@@ -4,67 +4,56 @@
 
         /**
         * The PassPostProcess id in the pipeline that contains the original scene color
-        * @type {string}
         */
         public SSAOOriginalSceneColorEffect: string = "SSAOOriginalSceneColorEffect";
         /**
         * The SSAO PostProcess id in the pipeline
-        * @type {string}
         */
         public SSAORenderEffect: string = "SSAORenderEffect";
         /**
         * The horizontal blur PostProcess id in the pipeline
-        * @type {string}
         */
         public SSAOBlurHRenderEffect: string = "SSAOBlurHRenderEffect";
         /**
         * The vertical blur PostProcess id in the pipeline
-        * @type {string}
         */
         public SSAOBlurVRenderEffect: string = "SSAOBlurVRenderEffect";
         /**
         * The PostProcess id in the pipeline that combines the SSAO-Blur output with the original scene color (SSAOOriginalSceneColorEffect)
-        * @type {string}
         */
         public SSAOCombineRenderEffect: string = "SSAOCombineRenderEffect";
 
         /**
         * The output strength of the SSAO post-process. Default value is 1.0.
-        * @type {number}
         */
         @serialize()
         public totalStrength: number = 1.0;
 
         /**
         * Maximum depth value to still render AO. A smooth falloff makes the dimming more natural, so there will be no abrupt shading change.
-        * @type {number}
         */
         @serialize()
         public maxZ: number = 100.0;
 
         /**
         * In order to save performances, SSAO radius is clamped on close geometry. This ratio changes by how much
-        * @type {number}
         */
         @serialize()
         public minZAspect: number = 0.2;
 
         /**
         * Number of samples used for the SSAO calculations. Default value is 8
-        * @type {number}
         */
         @serialize("samples")
         private _samples: number = 8;
 
         /**
         * Dynamically generated sphere sampler.
-        * @type {number[]}
         */
         private _sampleSphere: number[];
 
         /**
         * Blur filter offsets
-        * @type {number[]}
         */
         private _samplerOffsets: number[];
 
@@ -82,7 +71,6 @@
 
         /**
         * Are we using bilateral blur ?
-        * @type {boolean}
         */
         @serialize("expensiveBlur")
         private _expensiveBlur: boolean = true;
@@ -101,7 +89,6 @@
 
         /**
         * The radius around the analyzed pixel used by the SSAO post-process. Default value is 2.0
-        * @type {number}
         */
         @serialize()
         public radius: number = 2.0;
@@ -109,14 +96,12 @@
         /**
         * The base color of the SSAO post-process
         * The final result is "base + ssao" between [0, 1]
-        * @type {number}
         */
         @serialize()
         public base: number = 0.1;
 
         /**
         *  Support test.
-        * @type {boolean}
         */
         public static get IsSupported(): boolean {
             var engine = Engine.LastCreatedEngine;

src/PostProcess/RenderPipeline/Pipelines/babylon.ssaoRenderingPipeline.ts

@@ -4,40 +4,33 @@
 
         /**
         * The PassPostProcess id in the pipeline that contains the original scene color
-        * @type {string}
         */
         public SSAOOriginalSceneColorEffect: string = "SSAOOriginalSceneColorEffect";
         /**
         * The SSAO PostProcess id in the pipeline
-        * @type {string}
         */
         public SSAORenderEffect: string = "SSAORenderEffect";
         /**
         * The horizontal blur PostProcess id in the pipeline
-        * @type {string}
         */
         public SSAOBlurHRenderEffect: string = "SSAOBlurHRenderEffect";
         /**
         * The vertical blur PostProcess id in the pipeline
-        * @type {string}
         */
         public SSAOBlurVRenderEffect: string = "SSAOBlurVRenderEffect";
         /**
         * The PostProcess id in the pipeline that combines the SSAO-Blur output with the original scene color (SSAOOriginalSceneColorEffect)
-        * @type {string}
         */
         public SSAOCombineRenderEffect: string = "SSAOCombineRenderEffect";
 
         /**
         * The output strength of the SSAO post-process. Default value is 1.0.
-        * @type {number}
         */
         @serialize()
         public totalStrength: number = 1.0;
 
         /**
         * The radius around the analyzed pixel used by the SSAO post-process. Default value is 0.0006
-        * @type {number}
         */
         @serialize()
         public radius: number = 0.0001;
@@ -46,7 +39,6 @@
         * Related to fallOff, used to interpolate SSAO samples (first interpolate function input) based on the occlusion difference of each pixel
         * Must not be equal to fallOff and superior to fallOff.
         * Default value is 0.975
-        * @type {number}
         */
         @serialize()
         public area: number = 0.0075;
@@ -55,7 +47,6 @@
         * Related to area, used to interpolate SSAO samples (second interpolate function input) based on the occlusion difference of each pixel
         * Must not be equal to area and inferior to area.
         * Default value is 0.0
-        * @type {number}
         */
         @serialize()
         public fallOff: number = 0.000001;
@@ -63,7 +54,6 @@
         /**
         * The base color of the SSAO post-process
         * The final result is "base + ssao" between [0, 1]
-        * @type {number}
         */
         @serialize()
         public base: number = 0.5;

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipeline.ts

@@ -143,13 +143,13 @@ module BABYLON {
             this._renderEffectsForIsolatedPass = new Array<PostProcessRenderEffect>();
         }
 
-        protected _enableMSAAOnFirstPostProcess():boolean{
+        protected _enableMSAAOnFirstPostProcess(sampleCount: number):boolean{
             // Set samples of the very first post process to 4 to enable native anti-aliasing in browsers that support webGL 2.0 (See: https://github.com/BabylonJS/Babylon.js/issues/3754)
             var effectKeys = Object.keys(this._renderEffects);
             if(this.engine.webGLVersion >= 2 && effectKeys.length > 0){
                 var postProcesses = this._renderEffects[effectKeys[0]].getPostProcesses();
                 if(postProcesses){
-                    postProcesses[0].samples = 4;
+                    postProcesses[0].samples = sampleCount;
                     return true;
                 }
             }

src/PostProcess/RenderPipeline/babylon.postProcessRenderPipelineManager.ts

@@ -1,7 +1,7 @@
 module BABYLON {
     export class PostProcessRenderPipelineManager {
-        private _renderPipelines: any;
-
+        private _renderPipelines: {[Key:string]:PostProcessRenderPipeline};
+        
         constructor() {
             this._renderPipelines = {};
         }

src/PostProcess/babylon.bloomEffect.ts

@@ -0,0 +1,114 @@
+module BABYLON {
+    /**
+     * The bloom effect spreads bright areas of an image to simulate artifacts seen in cameras
+     */
+    export class BloomEffect extends PostProcessRenderEffect{
+        /**
+         * Internal
+         */
+        public _effects: Array<PostProcess> = [];
+
+        /**
+         * Internal
+         */
+        public _downscale:ExtractHighlightsPostProcess;
+        private _blurX:BlurPostProcess;
+        private _blurY:BlurPostProcess;
+        private _merge:BloomMergePostProcess;
+        
+        /**
+         * The luminance threshold to find bright areas of the image to bloom. 
+         */
+        public get threshold():number{
+            return this._downscale.threshold;
+        }
+        public set threshold(value: number){
+            this._downscale.threshold = value;
+        }
+
+        /**
+         * The strength of the bloom.
+         */
+        public get weight():number{
+            return this._merge.weight;
+        }
+        public set weight(value: number){
+            this._merge.weight = value;
+        }
+
+        /**
+         * Specifies the size of the bloom blur kernel, relative to the final output size
+         */
+        public get kernel():number{
+            return this._blurX.kernel / this.bloomScale;
+        }
+        public set kernel(value: number){
+            this._blurX.kernel = value * this.bloomScale;
+            this._blurY.kernel = value * this.bloomScale;
+        }
+        
+        /**
+         * Creates a new instance of @see BloomEffect
+         * @param scene The scene the effect belongs to.
+         * @param bloomScale The ratio of the blur texture to the input texture that should be used to compute the bloom.
+         * @param bloomKernel The size of the kernel to be used when applying the blur.
+         * @param bloomWeight The the strength of bloom.
+         * @param pipelineTextureType The type of texture to be used when performing the post processing.
+         * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
+         */
+        constructor(scene: Scene, private bloomScale:number, bloomWeight:number, bloomKernel:number, pipelineTextureType = 0, blockCompilation = false) {
+            super(scene.getEngine(), "bloom", ()=>{
+                return this._effects;
+            }, true);
+            this._downscale = new ExtractHighlightsPostProcess("highlights", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, blockCompilation);
+
+            this._blurX = new BlurPostProcess("horizontal blur", new Vector2(1.0, 0), 10.0, bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, undefined, blockCompilation);
+            this._blurX.alwaysForcePOT = true;
+            this._blurX.autoClear = false;
+
+            this._blurY = new BlurPostProcess("vertical blur", new Vector2(0, 1.0), 10.0, bloomScale, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, undefined, blockCompilation);
+            this._blurY.alwaysForcePOT = true;
+            this._blurY.autoClear = false;
+
+            this.kernel = bloomKernel;
+
+            this._effects = [this._downscale, this._blurX, this._blurY];
+
+            this._merge = new BloomMergePostProcess("bloomMerge", this._downscale, this._blurY, bloomWeight, bloomScale, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, pipelineTextureType, blockCompilation);
+            this._merge.autoClear = false;
+            this._effects.push(this._merge);
+        }
+
+        /**
+         * Disposes each of the internal effects for a given camera.
+         * @param camera The camera to dispose the effect on.
+         */
+        public disposeEffects(camera:Camera){
+            for(var effect in this._effects){
+                this._effects[effect].dispose(camera);
+            }
+        }
+        
+        /**
+         * Internal
+         */
+        public _updateEffects(){
+            for(var effect in this._effects){
+                this._effects[effect].updateEffect();
+            }
+        }
+
+        /**
+         * Internal
+         * @returns if all the contained post processes are ready.
+         */
+        public _isReady(){
+            for(var effect in this._effects){
+                if(!this._effects[effect].isReady()){
+                    return false;
+                }
+            }
+            return true;
+        }
+    }
+}

src/PostProcess/babylon.bloomMergePostProcess.ts

@@ -0,0 +1,33 @@
+module BABYLON {
+    /**
+     * The BloomMergePostProcess merges blurred images with the original based on the values of the circle of confusion.
+     */
+    export class BloomMergePostProcess extends PostProcess {
+        /**
+         * Creates a new instance of @see BloomMergePostProcess
+         * @param name The name of the effect.
+         * @param originalFromInput Post process which's input will be used for the merge.
+         * @param blurred Blurred highlights post process which's output will be used.
+         * @param weight Weight of the bloom to be added to the original input.
+         * @param options The required width/height ratio to downsize to before computing the render pass.
+         * @param camera The camera to apply the render pass to.
+         * @param samplingMode The sampling mode to be used when computing the pass. (default: 0)
+         * @param engine The engine which the post process will be applied. (default: current engine)
+         * @param reusable If the post process can be reused on the same frame. (default: false)
+         * @param textureType Type of textures used when performing the post process. (default: 0)
+         * @param blockCompilation If compilation of the shader should not be done in the constructor. The updateEffect method can be used to compile the shader at a later time. (default: false)
+         */
+        constructor(name: string, originalFromInput:PostProcess, blurred:PostProcess, /** Weight of the bloom to be added to the original input. */ public weight:number, options: number | PostProcessOptions, camera: Nullable<Camera>, samplingMode?: number, engine?: Engine, reusable?: boolean, textureType: number = Engine.TEXTURETYPE_UNSIGNED_INT, blockCompilation = false) {
+            super(name, "bloomMerge", ["bloomWeight"], ["circleOfConfusionSampler", "blurStep0", "blurStep1", "blurStep2", "bloomBlur"], options, camera, samplingMode, engine, reusable, null, textureType, undefined, null, true);
+            this.onApplyObservable.add((effect: Effect) => {
+                effect.setTextureFromPostProcess("textureSampler", originalFromInput);
+                effect.setTextureFromPostProcessOutput("bloomBlur", blurred);
+                effect.setFloat("bloomWeight", this.weight);   
+            });
+
+            if(!blockCompilation){
+                this.updateEffect();
+            }
+        }
+    }
+}

src/PostProcess/babylon.blurPostProcess.ts

@@ -52,7 +52,7 @@
 		}
 
 		/**
-         * Creates a new instance of @see BlurPostProcess
+         * Creates a new instance BlurPostProcess
          * @param name The name of the effect.
          * @param direction The direction in which to blur the image.
 		 * @param kernel The size of the kernel to be used when computing the blur. eg. Size of 3 will blur the center pixel by 2 pixels surrounding it.
@@ -174,6 +174,7 @@
 				defines += `#define PACKEDFLOAT 1`;
 			}
 
+			this.blockCompilation = false;
             super.updateEffect(defines, null, null, {
 				varyingCount: varyingCount,
 				depCount: depCount

src/PostProcess/babylon.chromaticAberrationPostProcess.ts

@@ -24,7 +24,7 @@ module BABYLON {
         centerPosition = new Vector2(0.5,0.5);
         
         /**
-         * Creates a new instance of @see ChromaticAberrationPostProcess
+         * Creates a new instance ChromaticAberrationPostProcess
          * @param name The name of the effect.
          * @param screenWidth The width of the screen to apply the effect on.
          * @param screenHeight The height of the screen to apply the effect on.

src/PostProcess/babylon.circleOfConfusionPostProcess.ts

@@ -22,7 +22,7 @@ module BABYLON {
         
         private _depthTexture:Nullable<RenderTargetTexture> = null;
         /**
-         * Creates a new instance of @see CircleOfConfusionPostProcess
+         * Creates a new instance CircleOfConfusionPostProcess
          * @param name The name of the effect.
          * @param depthTexture The depth texture of the scene to compute the circle of confusion. This must be set in order for this to function but may be set after initialization if needed.
          * @param options The required width/height ratio to downsize to before computing the render pass.

src/PostProcess/babylon.convolutionPostProcess.ts

@@ -6,7 +6,7 @@
      */
     export class ConvolutionPostProcess extends PostProcess{
         /**
-         * Creates a new instance of @see ConvolutionPostProcess
+         * Creates a new instance ConvolutionPostProcess
          * @param name The name of the effect.
          * @param kernel Array of 9 values corrisponding to the 3x3 kernel to be applied
          * @param options The required width/height ratio to downsize to before computing the render pass.

src/PostProcess/babylon.depthOfFieldBlurPostProcess.ts

@@ -7,7 +7,7 @@ module BABYLON {
      */
     export class DepthOfFieldBlurPostProcess extends BlurPostProcess {
         /**
-         * Creates a new instance of @see CircleOfConfusionPostProcess
+         * Creates a new instance CircleOfConfusionPostProcess
          * @param name The name of the effect.
          * @param scene The scene the effect belongs to.
          * @param direction The direction the blur should be applied.