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

Viewer/tests/validation/karma.conf.browserstack.js

@@ -81,8 +81,8 @@ module.exports = function (config) {
                 real_mobile: 'true'
             }
         },
-        browsers: ['bs_chrome_android'],
+        browsers: ['bs_chrome_win'],
         reporters: ['dots', 'BrowserStack'],
         singleRun: true
     });
-};
+};

dist/preview release/babylon.max.js

@@ -79090,62 +79090,203 @@ var BABYLON;
         function StandardRenderingPipeline(name, scene, ratio, originalPostProcess, cameras) {
             if (originalPostProcess === void 0) { originalPostProcess = null; }
             var _this = _super.call(this, scene.getEngine(), name) || this;
+            /**
+             * Post-process used to down scale an image x4
+             */
             _this.downSampleX4PostProcess = null;
+            /**
+             * Post-process used to calculate the illuminated surfaces controlled by a threshold
+             */
             _this.brightPassPostProcess = null;
+            /**
+             * Post-process array storing all the horizontal blur post-processes used by the pipeline
+             */
             _this.blurHPostProcesses = [];
+            /**
+             * Post-process array storing all the vertical blur post-processes used by the pipeline
+             */
             _this.blurVPostProcesses = [];
+            /**
+             * Post-process used to add colors of 2 textures (typically brightness + real scene color)
+             */
             _this.textureAdderPostProcess = null;
+            /**
+             * Post-process used to create volumetric lighting effect
+             */
             _this.volumetricLightPostProcess = null;
+            /**
+             * Post-process used to smooth the previous volumetric light post-process on the X axis
+             */
             _this.volumetricLightSmoothXPostProcess = null;
+            /**
+             * Post-process used to smooth the previous volumetric light post-process on the Y axis
+             */
             _this.volumetricLightSmoothYPostProcess = null;
+            /**
+             * Post-process used to merge the volumetric light effect and the real scene color
+             */
             _this.volumetricLightMergePostProces = null;
+            /**
+             * Post-process used to store the final volumetric light post-process (attach/detach for debug purpose)
+             */
             _this.volumetricLightFinalPostProcess = null;
+            /**
+             * Base post-process used to calculate the average luminance of the final image for HDR
+             */
             _this.luminancePostProcess = null;
+            /**
+             * Post-processes used to create down sample post-processes in order to get
+             * the average luminance of the final image for HDR
+             * Array of length "StandardRenderingPipeline.LuminanceSteps"
+             */
             _this.luminanceDownSamplePostProcesses = [];
+            /**
+             * Post-process used to create a HDR effect (light adaptation)
+             */
             _this.hdrPostProcess = null;
+            /**
+             * Post-process used to store the final texture adder post-process (attach/detach for debug purpose)
+             */
             _this.textureAdderFinalPostProcess = null;
+            /**
+             * Post-process used to store the final lens flare post-process (attach/detach for debug purpose)
+             */
             _this.lensFlareFinalPostProcess = null;
+            /**
+             * Post-process used to merge the final HDR post-process and the real scene color
+             */
             _this.hdrFinalPostProcess = null;
+            /**
+             * Post-process used to create a lens flare effect
+             */
             _this.lensFlarePostProcess = null;
+            /**
+             * Post-process that merges the result of the lens flare post-process and the real scene color
+             */
             _this.lensFlareComposePostProcess = null;
+            /**
+             * Post-process used to create a motion blur effect
+             */
             _this.motionBlurPostProcess = null;
+            /**
+             * Post-process used to create a depth of field effect
+             */
             _this.depthOfFieldPostProcess = null;
+            /**
+             * The Fast Approximate Anti-Aliasing post process which attemps to remove aliasing from an image.
+             */
+            _this.fxaaPostProcess = null;
             // Values
+            /**
+             * Represents the brightness threshold in order to configure the illuminated surfaces
+             */
             _this.brightThreshold = 1.0;
+            /**
+             * Configures the blur intensity used for surexposed surfaces are highlighted surfaces (light halo)
+             */
             _this.blurWidth = 512.0;
+            /**
+             * Sets if the blur for highlighted surfaces must be only horizontal
+             */
             _this.horizontalBlur = false;
+            /**
+             * Sets the overall exposure used by the pipeline
+             */
             _this.exposure = 1.0;
+            /**
+             * Texture used typically to simulate "dirty" on camera lens
+             */
             _this.lensTexture = null;
+            /**
+             * Represents the offset coefficient based on Rayleigh principle. Typically in interval [-0.2, 0.2]
+             */
             _this.volumetricLightCoefficient = 0.2;
+            /**
+             * The overall power of volumetric lights, typically in interval [0, 10] maximum
+             */
             _this.volumetricLightPower = 4.0;
+            /**
+             * Used the set the blur intensity to smooth the volumetric lights
+             */
             _this.volumetricLightBlurScale = 64.0;
+            /**
+             * Light (spot or directional) used to generate the volumetric lights rays
+             * The source light must have a shadow generate so the pipeline can get its
+             * depth map
+             */
             _this.sourceLight = null;
+            /**
+             * For eye adaptation, represents the minimum luminance the eye can see
+             */
             _this.hdrMinimumLuminance = 1.0;
+            /**
+             * For eye adaptation, represents the decrease luminance speed
+             */
             _this.hdrDecreaseRate = 0.5;
+            /**
+             * For eye adaptation, represents the increase luminance speed
+             */
             _this.hdrIncreaseRate = 0.5;
+            /**
+             * Lens color texture used by the lens flare effect. Mandatory if lens flare effect enabled
+             */
             _this.lensColorTexture = null;
+            /**
+             * The overall strengh for the lens flare effect
+             */
             _this.lensFlareStrength = 20.0;
+            /**
+             * Dispersion coefficient for lens flare ghosts
+             */
             _this.lensFlareGhostDispersal = 1.4;
+            /**
+             * Main lens flare halo width
+             */
             _this.lensFlareHaloWidth = 0.7;
+            /**
+             * Based on the lens distortion effect, defines how much the lens flare result
+             * is distorted
+             */
             _this.lensFlareDistortionStrength = 16.0;
+            /**
+             * Lens star texture must be used to simulate rays on the flares and is available
+             * in the documentation
+             */
             _this.lensStarTexture = null;
+            /**
+             * As the "lensTexture" (can be the same texture or different), it is used to apply the lens
+             * flare effect by taking account of the dirt texture
+             */
             _this.lensFlareDirtTexture = null;
+            /**
+             * Represents the focal length for the depth of field effect
+             */
             _this.depthOfFieldDistance = 10.0;
+            /**
+             * Represents the blur intensity for the blurred part of the depth of field effect
+             */
             _this.depthOfFieldBlurWidth = 64.0;
+            /**
+             * For motion blur, defines how much the image is blurred by the movement
+             */
             _this.motionStrength = 1.0;
-            // IAnimatable
+            /**
+             * List of animations for the pipeline (IAnimatable implementation)
+             */
             _this.animations = [];
             _this._currentDepthOfFieldSource = null;
             _this._hdrCurrentLuminance = 1.0;
             // Getters and setters
-            _this._bloomEnabled = true;
+            _this._bloomEnabled = false;
             _this._depthOfFieldEnabled = false;
             _this._vlsEnabled = false;
             _this._lensFlareEnabled = false;
             _this._hdrEnabled = false;
             _this._motionBlurEnabled = false;
+            _this._fxaaEnabled = false;
             _this._motionBlurSamples = 64.0;
             _this._volumetricLightStepsCount = 50.0;
+            _this._samples = 1;
             _this._cameras = cameras || [];
             // Initialize
             _this._scene = scene;
@@ -79159,6 +79300,9 @@ var BABYLON;
             return _this;
         }
         Object.defineProperty(StandardRenderingPipeline.prototype, "BloomEnabled", {
+            /**
+             * Specifies if the bloom pipeline is enabled
+             */
             get: function () {
                 return this._bloomEnabled;
             },
@@ -79173,6 +79317,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "DepthOfFieldEnabled", {
+            /**
+             * Specifies if the depth of field pipeline is enabed
+             */
             get: function () {
                 return this._depthOfFieldEnabled;
             },
@@ -79187,6 +79334,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "LensFlareEnabled", {
+            /**
+             * Specifies if the lens flare pipeline is enabed
+             */
             get: function () {
                 return this._lensFlareEnabled;
             },
@@ -79201,6 +79351,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "HDREnabled", {
+            /**
+             * Specifies if the HDR pipeline is enabled
+             */
             get: function () {
                 return this._hdrEnabled;
             },
@@ -79215,6 +79368,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "VLSEnabled", {
+            /**
+             * Specifies if the volumetric lights scattering effect is enabled
+             */
             get: function () {
                 return this._vlsEnabled;
             },
@@ -79236,6 +79392,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "MotionBlurEnabled", {
+            /**
+             * Specifies if the motion blur effect is enabled
+             */
             get: function () {
                 return this._motionBlurEnabled;
             },
@@ -79249,7 +79408,28 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(StandardRenderingPipeline.prototype, "fxaaEnabled", {
+            /**
+             * Specifies if anti-aliasing is enabled
+             */
+            get: function () {
+                return this._fxaaEnabled;
+            },
+            set: function (enabled) {
+                if (this._fxaaEnabled === enabled) {
+                    return;
+                }
+                this._fxaaEnabled = enabled;
+                this._buildPipeline();
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(StandardRenderingPipeline.prototype, "volumetricLightStepsCount", {
+            /**
+             * Specifies the number of steps used to calculate the volumetric lights
+             * Typically in interval [50, 200]
+             */
             get: function () {
                 return this._volumetricLightStepsCount;
             },
@@ -79263,6 +79443,10 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "motionBlurSamples", {
+            /**
+             * Specifies the number of samples used for the motion blur effect
+             * Typically in interval [16, 64]
+             */
             get: function () {
                 return this._motionBlurSamples;
             },
@@ -79275,6 +79459,23 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(StandardRenderingPipeline.prototype, "samples", {
+            /**
+             * Specifies MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+             */
+            get: function () {
+                return this._samples;
+            },
+            set: function (sampleCount) {
+                if (this._samples === sampleCount) {
+                    return;
+                }
+                this._samples = sampleCount;
+                this._buildPipeline();
+            },
+            enumerable: true,
+            configurable: true
+        });
         StandardRenderingPipeline.prototype._buildPipeline = function () {
             var _this = this;
             var ratio = this._ratio;
@@ -79339,9 +79540,17 @@ var BABYLON;
                 // Create motion blur post-process
                 this._createMotionBlurPostProcess(scene, ratio);
             }
+            if (this._fxaaEnabled) {
+                // Create fxaa post-process
+                this.fxaaPostProcess = new BABYLON.FxaaPostProcess("fxaa", 1.0, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, BABYLON.Engine.TEXTURETYPE_UNSIGNED_INT);
+                this.addEffect(new BABYLON.PostProcessRenderEffect(scene.getEngine(), "HDRFxaa", function () { return _this.fxaaPostProcess; }, true));
+            }
             if (this._cameras !== null) {
                 this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
             }
+            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");
+            }
         };
         // Down Sample X4 Post-Processs
         StandardRenderingPipeline.prototype._createDownSampleX4PostProcess = function (scene, ratio) {
@@ -79697,6 +79906,9 @@ var BABYLON;
                 if (this.motionBlurPostProcess) {
                     this.motionBlurPostProcess.dispose(camera);
                 }
+                if (this.fxaaPostProcess) {
+                    this.fxaaPostProcess.dispose(camera);
+                }
                 for (var j = 0; j < this.blurHPostProcesses.length; j++) {
                     this.blurHPostProcesses[j].dispose(camera);
                 }
@@ -79721,6 +79933,7 @@ var BABYLON;
             this.hdrFinalPostProcess = null;
             this.depthOfFieldPostProcess = null;
             this.motionBlurPostProcess = null;
+            this.fxaaPostProcess = null;
             this.luminanceDownSamplePostProcesses = [];
             this.blurHPostProcesses = [];
             this.blurVPostProcesses = [];
@@ -79847,10 +80060,16 @@ var BABYLON;
         ], StandardRenderingPipeline.prototype, "MotionBlurEnabled", null);
         __decorate([
             BABYLON.serialize()
+        ], StandardRenderingPipeline.prototype, "fxaaEnabled", null);
+        __decorate([
+            BABYLON.serialize()
         ], StandardRenderingPipeline.prototype, "volumetricLightStepsCount", null);
         __decorate([
             BABYLON.serialize()
         ], StandardRenderingPipeline.prototype, "motionBlurSamples", null);
+        __decorate([
+            BABYLON.serialize()
+        ], StandardRenderingPipeline.prototype, "samples", null);
         return StandardRenderingPipeline;
     }(BABYLON.PostProcessRenderPipeline));
     BABYLON.StandardRenderingPipeline = StandardRenderingPipeline;

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

@@ -79057,62 +79057,203 @@ var BABYLON;
         function StandardRenderingPipeline(name, scene, ratio, originalPostProcess, cameras) {
             if (originalPostProcess === void 0) { originalPostProcess = null; }
             var _this = _super.call(this, scene.getEngine(), name) || this;
+            /**
+             * Post-process used to down scale an image x4
+             */
             _this.downSampleX4PostProcess = null;
+            /**
+             * Post-process used to calculate the illuminated surfaces controlled by a threshold
+             */
             _this.brightPassPostProcess = null;
+            /**
+             * Post-process array storing all the horizontal blur post-processes used by the pipeline
+             */
             _this.blurHPostProcesses = [];
+            /**
+             * Post-process array storing all the vertical blur post-processes used by the pipeline
+             */
             _this.blurVPostProcesses = [];
+            /**
+             * Post-process used to add colors of 2 textures (typically brightness + real scene color)
+             */
             _this.textureAdderPostProcess = null;
+            /**
+             * Post-process used to create volumetric lighting effect
+             */
             _this.volumetricLightPostProcess = null;
+            /**
+             * Post-process used to smooth the previous volumetric light post-process on the X axis
+             */
             _this.volumetricLightSmoothXPostProcess = null;
+            /**
+             * Post-process used to smooth the previous volumetric light post-process on the Y axis
+             */
             _this.volumetricLightSmoothYPostProcess = null;
+            /**
+             * Post-process used to merge the volumetric light effect and the real scene color
+             */
             _this.volumetricLightMergePostProces = null;
+            /**
+             * Post-process used to store the final volumetric light post-process (attach/detach for debug purpose)
+             */
             _this.volumetricLightFinalPostProcess = null;
+            /**
+             * Base post-process used to calculate the average luminance of the final image for HDR
+             */
             _this.luminancePostProcess = null;
+            /**
+             * Post-processes used to create down sample post-processes in order to get
+             * the average luminance of the final image for HDR
+             * Array of length "StandardRenderingPipeline.LuminanceSteps"
+             */
             _this.luminanceDownSamplePostProcesses = [];
+            /**
+             * Post-process used to create a HDR effect (light adaptation)
+             */
             _this.hdrPostProcess = null;
+            /**
+             * Post-process used to store the final texture adder post-process (attach/detach for debug purpose)
+             */
             _this.textureAdderFinalPostProcess = null;
+            /**
+             * Post-process used to store the final lens flare post-process (attach/detach for debug purpose)
+             */
             _this.lensFlareFinalPostProcess = null;
+            /**
+             * Post-process used to merge the final HDR post-process and the real scene color
+             */
             _this.hdrFinalPostProcess = null;
+            /**
+             * Post-process used to create a lens flare effect
+             */
             _this.lensFlarePostProcess = null;
+            /**
+             * Post-process that merges the result of the lens flare post-process and the real scene color
+             */
             _this.lensFlareComposePostProcess = null;
+            /**
+             * Post-process used to create a motion blur effect
+             */
             _this.motionBlurPostProcess = null;
+            /**
+             * Post-process used to create a depth of field effect
+             */
             _this.depthOfFieldPostProcess = null;
+            /**
+             * The Fast Approximate Anti-Aliasing post process which attemps to remove aliasing from an image.
+             */
+            _this.fxaaPostProcess = null;
             // Values
+            /**
+             * Represents the brightness threshold in order to configure the illuminated surfaces
+             */
             _this.brightThreshold = 1.0;
+            /**
+             * Configures the blur intensity used for surexposed surfaces are highlighted surfaces (light halo)
+             */
             _this.blurWidth = 512.0;
+            /**
+             * Sets if the blur for highlighted surfaces must be only horizontal
+             */
             _this.horizontalBlur = false;
+            /**
+             * Sets the overall exposure used by the pipeline
+             */
             _this.exposure = 1.0;
+            /**
+             * Texture used typically to simulate "dirty" on camera lens
+             */
             _this.lensTexture = null;
+            /**
+             * Represents the offset coefficient based on Rayleigh principle. Typically in interval [-0.2, 0.2]
+             */
             _this.volumetricLightCoefficient = 0.2;
+            /**
+             * The overall power of volumetric lights, typically in interval [0, 10] maximum
+             */
             _this.volumetricLightPower = 4.0;
+            /**
+             * Used the set the blur intensity to smooth the volumetric lights
+             */
             _this.volumetricLightBlurScale = 64.0;
+            /**
+             * Light (spot or directional) used to generate the volumetric lights rays
+             * The source light must have a shadow generate so the pipeline can get its
+             * depth map
+             */
             _this.sourceLight = null;
+            /**
+             * For eye adaptation, represents the minimum luminance the eye can see
+             */
             _this.hdrMinimumLuminance = 1.0;
+            /**
+             * For eye adaptation, represents the decrease luminance speed
+             */
             _this.hdrDecreaseRate = 0.5;
+            /**
+             * For eye adaptation, represents the increase luminance speed
+             */
             _this.hdrIncreaseRate = 0.5;
+            /**
+             * Lens color texture used by the lens flare effect. Mandatory if lens flare effect enabled
+             */
             _this.lensColorTexture = null;
+            /**
+             * The overall strengh for the lens flare effect
+             */
             _this.lensFlareStrength = 20.0;
+            /**
+             * Dispersion coefficient for lens flare ghosts
+             */
             _this.lensFlareGhostDispersal = 1.4;
+            /**
+             * Main lens flare halo width
+             */
             _this.lensFlareHaloWidth = 0.7;
+            /**
+             * Based on the lens distortion effect, defines how much the lens flare result
+             * is distorted
+             */
             _this.lensFlareDistortionStrength = 16.0;
+            /**
+             * Lens star texture must be used to simulate rays on the flares and is available
+             * in the documentation
+             */
             _this.lensStarTexture = null;
+            /**
+             * As the "lensTexture" (can be the same texture or different), it is used to apply the lens
+             * flare effect by taking account of the dirt texture
+             */
             _this.lensFlareDirtTexture = null;
+            /**
+             * Represents the focal length for the depth of field effect
+             */
             _this.depthOfFieldDistance = 10.0;
+            /**
+             * Represents the blur intensity for the blurred part of the depth of field effect
+             */
             _this.depthOfFieldBlurWidth = 64.0;
+            /**
+             * For motion blur, defines how much the image is blurred by the movement
+             */
             _this.motionStrength = 1.0;
-            // IAnimatable
+            /**
+             * List of animations for the pipeline (IAnimatable implementation)
+             */
             _this.animations = [];
             _this._currentDepthOfFieldSource = null;
             _this._hdrCurrentLuminance = 1.0;
             // Getters and setters
-            _this._bloomEnabled = true;
+            _this._bloomEnabled = false;
             _this._depthOfFieldEnabled = false;
             _this._vlsEnabled = false;
             _this._lensFlareEnabled = false;
             _this._hdrEnabled = false;
             _this._motionBlurEnabled = false;
+            _this._fxaaEnabled = false;
             _this._motionBlurSamples = 64.0;
             _this._volumetricLightStepsCount = 50.0;
+            _this._samples = 1;
             _this._cameras = cameras || [];
             // Initialize
             _this._scene = scene;
@@ -79126,6 +79267,9 @@ var BABYLON;
             return _this;
         }
         Object.defineProperty(StandardRenderingPipeline.prototype, "BloomEnabled", {
+            /**
+             * Specifies if the bloom pipeline is enabled
+             */
             get: function () {
                 return this._bloomEnabled;
             },
@@ -79140,6 +79284,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "DepthOfFieldEnabled", {
+            /**
+             * Specifies if the depth of field pipeline is enabed
+             */
             get: function () {
                 return this._depthOfFieldEnabled;
             },
@@ -79154,6 +79301,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "LensFlareEnabled", {
+            /**
+             * Specifies if the lens flare pipeline is enabed
+             */
             get: function () {
                 return this._lensFlareEnabled;
             },
@@ -79168,6 +79318,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "HDREnabled", {
+            /**
+             * Specifies if the HDR pipeline is enabled
+             */
             get: function () {
                 return this._hdrEnabled;
             },
@@ -79182,6 +79335,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "VLSEnabled", {
+            /**
+             * Specifies if the volumetric lights scattering effect is enabled
+             */
             get: function () {
                 return this._vlsEnabled;
             },
@@ -79203,6 +79359,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "MotionBlurEnabled", {
+            /**
+             * Specifies if the motion blur effect is enabled
+             */
             get: function () {
                 return this._motionBlurEnabled;
             },
@@ -79216,7 +79375,28 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(StandardRenderingPipeline.prototype, "fxaaEnabled", {
+            /**
+             * Specifies if anti-aliasing is enabled
+             */
+            get: function () {
+                return this._fxaaEnabled;
+            },
+            set: function (enabled) {
+                if (this._fxaaEnabled === enabled) {
+                    return;
+                }
+                this._fxaaEnabled = enabled;
+                this._buildPipeline();
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(StandardRenderingPipeline.prototype, "volumetricLightStepsCount", {
+            /**
+             * Specifies the number of steps used to calculate the volumetric lights
+             * Typically in interval [50, 200]
+             */
             get: function () {
                 return this._volumetricLightStepsCount;
             },
@@ -79230,6 +79410,10 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "motionBlurSamples", {
+            /**
+             * Specifies the number of samples used for the motion blur effect
+             * Typically in interval [16, 64]
+             */
             get: function () {
                 return this._motionBlurSamples;
             },
@@ -79242,6 +79426,23 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(StandardRenderingPipeline.prototype, "samples", {
+            /**
+             * Specifies MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+             */
+            get: function () {
+                return this._samples;
+            },
+            set: function (sampleCount) {
+                if (this._samples === sampleCount) {
+                    return;
+                }
+                this._samples = sampleCount;
+                this._buildPipeline();
+            },
+            enumerable: true,
+            configurable: true
+        });
         StandardRenderingPipeline.prototype._buildPipeline = function () {
             var _this = this;
             var ratio = this._ratio;
@@ -79306,9 +79507,17 @@ var BABYLON;
                 // Create motion blur post-process
                 this._createMotionBlurPostProcess(scene, ratio);
             }
+            if (this._fxaaEnabled) {
+                // Create fxaa post-process
+                this.fxaaPostProcess = new BABYLON.FxaaPostProcess("fxaa", 1.0, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, BABYLON.Engine.TEXTURETYPE_UNSIGNED_INT);
+                this.addEffect(new BABYLON.PostProcessRenderEffect(scene.getEngine(), "HDRFxaa", function () { return _this.fxaaPostProcess; }, true));
+            }
             if (this._cameras !== null) {
                 this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
             }
+            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");
+            }
         };
         // Down Sample X4 Post-Processs
         StandardRenderingPipeline.prototype._createDownSampleX4PostProcess = function (scene, ratio) {
@@ -79664,6 +79873,9 @@ var BABYLON;
                 if (this.motionBlurPostProcess) {
                     this.motionBlurPostProcess.dispose(camera);
                 }
+                if (this.fxaaPostProcess) {
+                    this.fxaaPostProcess.dispose(camera);
+                }
                 for (var j = 0; j < this.blurHPostProcesses.length; j++) {
                     this.blurHPostProcesses[j].dispose(camera);
                 }
@@ -79688,6 +79900,7 @@ var BABYLON;
             this.hdrFinalPostProcess = null;
             this.depthOfFieldPostProcess = null;
             this.motionBlurPostProcess = null;
+            this.fxaaPostProcess = null;
             this.luminanceDownSamplePostProcesses = [];
             this.blurHPostProcesses = [];
             this.blurVPostProcesses = [];
@@ -79814,10 +80027,16 @@ var BABYLON;
         ], StandardRenderingPipeline.prototype, "MotionBlurEnabled", null);
         __decorate([
             BABYLON.serialize()
+        ], StandardRenderingPipeline.prototype, "fxaaEnabled", null);
+        __decorate([
+            BABYLON.serialize()
         ], StandardRenderingPipeline.prototype, "volumetricLightStepsCount", null);
         __decorate([
             BABYLON.serialize()
         ], StandardRenderingPipeline.prototype, "motionBlurSamples", null);
+        __decorate([
+            BABYLON.serialize()
+        ], StandardRenderingPipeline.prototype, "samples", null);
         return StandardRenderingPipeline;
     }(BABYLON.PostProcessRenderPipeline));
     BABYLON.StandardRenderingPipeline = StandardRenderingPipeline;

dist/preview release/es6.js

@@ -79057,62 +79057,203 @@ var BABYLON;
         function StandardRenderingPipeline(name, scene, ratio, originalPostProcess, cameras) {
             if (originalPostProcess === void 0) { originalPostProcess = null; }
             var _this = _super.call(this, scene.getEngine(), name) || this;
+            /**
+             * Post-process used to down scale an image x4
+             */
             _this.downSampleX4PostProcess = null;
+            /**
+             * Post-process used to calculate the illuminated surfaces controlled by a threshold
+             */
             _this.brightPassPostProcess = null;
+            /**
+             * Post-process array storing all the horizontal blur post-processes used by the pipeline
+             */
             _this.blurHPostProcesses = [];
+            /**
+             * Post-process array storing all the vertical blur post-processes used by the pipeline
+             */
             _this.blurVPostProcesses = [];
+            /**
+             * Post-process used to add colors of 2 textures (typically brightness + real scene color)
+             */
             _this.textureAdderPostProcess = null;
+            /**
+             * Post-process used to create volumetric lighting effect
+             */
             _this.volumetricLightPostProcess = null;
+            /**
+             * Post-process used to smooth the previous volumetric light post-process on the X axis
+             */
             _this.volumetricLightSmoothXPostProcess = null;
+            /**
+             * Post-process used to smooth the previous volumetric light post-process on the Y axis
+             */
             _this.volumetricLightSmoothYPostProcess = null;
+            /**
+             * Post-process used to merge the volumetric light effect and the real scene color
+             */
             _this.volumetricLightMergePostProces = null;
+            /**
+             * Post-process used to store the final volumetric light post-process (attach/detach for debug purpose)
+             */
             _this.volumetricLightFinalPostProcess = null;
+            /**
+             * Base post-process used to calculate the average luminance of the final image for HDR
+             */
             _this.luminancePostProcess = null;
+            /**
+             * Post-processes used to create down sample post-processes in order to get
+             * the average luminance of the final image for HDR
+             * Array of length "StandardRenderingPipeline.LuminanceSteps"
+             */
             _this.luminanceDownSamplePostProcesses = [];
+            /**
+             * Post-process used to create a HDR effect (light adaptation)
+             */
             _this.hdrPostProcess = null;
+            /**
+             * Post-process used to store the final texture adder post-process (attach/detach for debug purpose)
+             */
             _this.textureAdderFinalPostProcess = null;
+            /**
+             * Post-process used to store the final lens flare post-process (attach/detach for debug purpose)
+             */
             _this.lensFlareFinalPostProcess = null;
+            /**
+             * Post-process used to merge the final HDR post-process and the real scene color
+             */
             _this.hdrFinalPostProcess = null;
+            /**
+             * Post-process used to create a lens flare effect
+             */
             _this.lensFlarePostProcess = null;
+            /**
+             * Post-process that merges the result of the lens flare post-process and the real scene color
+             */
             _this.lensFlareComposePostProcess = null;
+            /**
+             * Post-process used to create a motion blur effect
+             */
             _this.motionBlurPostProcess = null;
+            /**
+             * Post-process used to create a depth of field effect
+             */
             _this.depthOfFieldPostProcess = null;
+            /**
+             * The Fast Approximate Anti-Aliasing post process which attemps to remove aliasing from an image.
+             */
+            _this.fxaaPostProcess = null;
             // Values
+            /**
+             * Represents the brightness threshold in order to configure the illuminated surfaces
+             */
             _this.brightThreshold = 1.0;
+            /**
+             * Configures the blur intensity used for surexposed surfaces are highlighted surfaces (light halo)
+             */
             _this.blurWidth = 512.0;
+            /**
+             * Sets if the blur for highlighted surfaces must be only horizontal
+             */
             _this.horizontalBlur = false;
+            /**
+             * Sets the overall exposure used by the pipeline
+             */
             _this.exposure = 1.0;
+            /**
+             * Texture used typically to simulate "dirty" on camera lens
+             */
             _this.lensTexture = null;
+            /**
+             * Represents the offset coefficient based on Rayleigh principle. Typically in interval [-0.2, 0.2]
+             */
             _this.volumetricLightCoefficient = 0.2;
+            /**
+             * The overall power of volumetric lights, typically in interval [0, 10] maximum
+             */
             _this.volumetricLightPower = 4.0;
+            /**
+             * Used the set the blur intensity to smooth the volumetric lights
+             */
             _this.volumetricLightBlurScale = 64.0;
+            /**
+             * Light (spot or directional) used to generate the volumetric lights rays
+             * The source light must have a shadow generate so the pipeline can get its
+             * depth map
+             */
             _this.sourceLight = null;
+            /**
+             * For eye adaptation, represents the minimum luminance the eye can see
+             */
             _this.hdrMinimumLuminance = 1.0;
+            /**
+             * For eye adaptation, represents the decrease luminance speed
+             */
             _this.hdrDecreaseRate = 0.5;
+            /**
+             * For eye adaptation, represents the increase luminance speed
+             */
             _this.hdrIncreaseRate = 0.5;
+            /**
+             * Lens color texture used by the lens flare effect. Mandatory if lens flare effect enabled
+             */
             _this.lensColorTexture = null;
+            /**
+             * The overall strengh for the lens flare effect
+             */
             _this.lensFlareStrength = 20.0;
+            /**
+             * Dispersion coefficient for lens flare ghosts
+             */
             _this.lensFlareGhostDispersal = 1.4;
+            /**
+             * Main lens flare halo width
+             */
             _this.lensFlareHaloWidth = 0.7;
+            /**
+             * Based on the lens distortion effect, defines how much the lens flare result
+             * is distorted
+             */
             _this.lensFlareDistortionStrength = 16.0;
+            /**
+             * Lens star texture must be used to simulate rays on the flares and is available
+             * in the documentation
+             */
             _this.lensStarTexture = null;
+            /**
+             * As the "lensTexture" (can be the same texture or different), it is used to apply the lens
+             * flare effect by taking account of the dirt texture
+             */
             _this.lensFlareDirtTexture = null;
+            /**
+             * Represents the focal length for the depth of field effect
+             */
             _this.depthOfFieldDistance = 10.0;
+            /**
+             * Represents the blur intensity for the blurred part of the depth of field effect
+             */
             _this.depthOfFieldBlurWidth = 64.0;
+            /**
+             * For motion blur, defines how much the image is blurred by the movement
+             */
             _this.motionStrength = 1.0;
-            // IAnimatable
+            /**
+             * List of animations for the pipeline (IAnimatable implementation)
+             */
             _this.animations = [];
             _this._currentDepthOfFieldSource = null;
             _this._hdrCurrentLuminance = 1.0;
             // Getters and setters
-            _this._bloomEnabled = true;
+            _this._bloomEnabled = false;
             _this._depthOfFieldEnabled = false;
             _this._vlsEnabled = false;
             _this._lensFlareEnabled = false;
             _this._hdrEnabled = false;
             _this._motionBlurEnabled = false;
+            _this._fxaaEnabled = false;
             _this._motionBlurSamples = 64.0;
             _this._volumetricLightStepsCount = 50.0;
+            _this._samples = 1;
             _this._cameras = cameras || [];
             // Initialize
             _this._scene = scene;
@@ -79126,6 +79267,9 @@ var BABYLON;
             return _this;
         }
         Object.defineProperty(StandardRenderingPipeline.prototype, "BloomEnabled", {
+            /**
+             * Specifies if the bloom pipeline is enabled
+             */
             get: function () {
                 return this._bloomEnabled;
             },
@@ -79140,6 +79284,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "DepthOfFieldEnabled", {
+            /**
+             * Specifies if the depth of field pipeline is enabed
+             */
             get: function () {
                 return this._depthOfFieldEnabled;
             },
@@ -79154,6 +79301,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "LensFlareEnabled", {
+            /**
+             * Specifies if the lens flare pipeline is enabed
+             */
             get: function () {
                 return this._lensFlareEnabled;
             },
@@ -79168,6 +79318,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "HDREnabled", {
+            /**
+             * Specifies if the HDR pipeline is enabled
+             */
             get: function () {
                 return this._hdrEnabled;
             },
@@ -79182,6 +79335,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "VLSEnabled", {
+            /**
+             * Specifies if the volumetric lights scattering effect is enabled
+             */
             get: function () {
                 return this._vlsEnabled;
             },
@@ -79203,6 +79359,9 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "MotionBlurEnabled", {
+            /**
+             * Specifies if the motion blur effect is enabled
+             */
             get: function () {
                 return this._motionBlurEnabled;
             },
@@ -79216,7 +79375,28 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(StandardRenderingPipeline.prototype, "fxaaEnabled", {
+            /**
+             * Specifies if anti-aliasing is enabled
+             */
+            get: function () {
+                return this._fxaaEnabled;
+            },
+            set: function (enabled) {
+                if (this._fxaaEnabled === enabled) {
+                    return;
+                }
+                this._fxaaEnabled = enabled;
+                this._buildPipeline();
+            },
+            enumerable: true,
+            configurable: true
+        });
         Object.defineProperty(StandardRenderingPipeline.prototype, "volumetricLightStepsCount", {
+            /**
+             * Specifies the number of steps used to calculate the volumetric lights
+             * Typically in interval [50, 200]
+             */
             get: function () {
                 return this._volumetricLightStepsCount;
             },
@@ -79230,6 +79410,10 @@ var BABYLON;
             configurable: true
         });
         Object.defineProperty(StandardRenderingPipeline.prototype, "motionBlurSamples", {
+            /**
+             * Specifies the number of samples used for the motion blur effect
+             * Typically in interval [16, 64]
+             */
             get: function () {
                 return this._motionBlurSamples;
             },
@@ -79242,6 +79426,23 @@ var BABYLON;
             enumerable: true,
             configurable: true
         });
+        Object.defineProperty(StandardRenderingPipeline.prototype, "samples", {
+            /**
+             * Specifies MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+             */
+            get: function () {
+                return this._samples;
+            },
+            set: function (sampleCount) {
+                if (this._samples === sampleCount) {
+                    return;
+                }
+                this._samples = sampleCount;
+                this._buildPipeline();
+            },
+            enumerable: true,
+            configurable: true
+        });
         StandardRenderingPipeline.prototype._buildPipeline = function () {
             var _this = this;
             var ratio = this._ratio;
@@ -79306,9 +79507,17 @@ var BABYLON;
                 // Create motion blur post-process
                 this._createMotionBlurPostProcess(scene, ratio);
             }
+            if (this._fxaaEnabled) {
+                // Create fxaa post-process
+                this.fxaaPostProcess = new BABYLON.FxaaPostProcess("fxaa", 1.0, null, BABYLON.Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, BABYLON.Engine.TEXTURETYPE_UNSIGNED_INT);
+                this.addEffect(new BABYLON.PostProcessRenderEffect(scene.getEngine(), "HDRFxaa", function () { return _this.fxaaPostProcess; }, true));
+            }
             if (this._cameras !== null) {
                 this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
             }
+            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");
+            }
         };
         // Down Sample X4 Post-Processs
         StandardRenderingPipeline.prototype._createDownSampleX4PostProcess = function (scene, ratio) {
@@ -79664,6 +79873,9 @@ var BABYLON;
                 if (this.motionBlurPostProcess) {
                     this.motionBlurPostProcess.dispose(camera);
                 }
+                if (this.fxaaPostProcess) {
+                    this.fxaaPostProcess.dispose(camera);
+                }
                 for (var j = 0; j < this.blurHPostProcesses.length; j++) {
                     this.blurHPostProcesses[j].dispose(camera);
                 }
@@ -79688,6 +79900,7 @@ var BABYLON;
             this.hdrFinalPostProcess = null;
             this.depthOfFieldPostProcess = null;
             this.motionBlurPostProcess = null;
+            this.fxaaPostProcess = null;
             this.luminanceDownSamplePostProcesses = [];
             this.blurHPostProcesses = [];
             this.blurVPostProcesses = [];
@@ -79814,10 +80027,16 @@ var BABYLON;
         ], StandardRenderingPipeline.prototype, "MotionBlurEnabled", null);
         __decorate([
             BABYLON.serialize()
+        ], StandardRenderingPipeline.prototype, "fxaaEnabled", null);
+        __decorate([
+            BABYLON.serialize()
         ], StandardRenderingPipeline.prototype, "volumetricLightStepsCount", null);
         __decorate([
             BABYLON.serialize()
         ], StandardRenderingPipeline.prototype, "motionBlurSamples", null);
+        __decorate([
+            BABYLON.serialize()
+        ], StandardRenderingPipeline.prototype, "samples", null);
         return StandardRenderingPipeline;
     }(BABYLON.PostProcessRenderPipeline));
     BABYLON.StandardRenderingPipeline = StandardRenderingPipeline;

dist/preview release/typedocValidationBaseline.json

@@ -1,7 +1,7 @@
 {
-  "errors": 3950,
+  "errors": 3899,
   "babylon.typedoc.json": {
-    "errors": 3950,
+    "errors": 3899,
     "AnimationGroup": {
       "Constructor": {
         "new AnimationGroup": {
@@ -15979,274 +15979,31 @@
         "BloomEnabled": {
           "Naming": {
             "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
           }
         },
         "DepthOfFieldEnabled": {
           "Naming": {
             "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
           }
         },
         "HDREnabled": {
           "Naming": {
             "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
           }
         },
         "LensFlareEnabled": {
           "Naming": {
             "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
           }
         },
         "MotionBlurEnabled": {
           "Naming": {
             "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
           }
         },
         "VLSEnabled": {
           "Naming": {
             "NotCamelCase": true
-          },
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "animations": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "blurHPostProcesses": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "blurVPostProcesses": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "blurWidth": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "brightPassPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "brightThreshold": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "depthOfFieldBlurWidth": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "depthOfFieldDistance": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "depthOfFieldPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "downSampleX4PostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "exposure": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "hdrDecreaseRate": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "hdrFinalPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "hdrIncreaseRate": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "hdrMinimumLuminance": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "hdrPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "horizontalBlur": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensColorTexture": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensFlareComposePostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensFlareDirtTexture": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensFlareDistortionStrength": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensFlareFinalPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensFlareGhostDispersal": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensFlareHaloWidth": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensFlarePostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensFlareStrength": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensStarTexture": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "lensTexture": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "luminanceDownSamplePostProcesses": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "luminancePostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "motionBlurPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "motionBlurSamples": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "motionStrength": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "sourceLight": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "textureAdderFinalPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "textureAdderPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightBlurScale": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightCoefficient": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightFinalPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightMergePostProces": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightPower": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightSmoothXPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightSmoothYPostProcess": {
-          "Comments": {
-            "MissingText": true
-          }
-        },
-        "volumetricLightStepsCount": {
-          "Comments": {
-            "MissingText": true
           }
         },
         "LuminanceSteps": {

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

@@ -924,7 +924,7 @@ declare module BabylonViewer {
       * @param name the name of the custom optimizer configuration
       * @param upgrade set to true if you want to upgrade optimizer and false if you want to degrade
       */
-    export function getCustomOptimizerByName(name: string, upgrade?: boolean): typeof extendedUpgrade;
+    export function getCustomOptimizerByName(name: string, upgrade?: boolean): (sceneManager: SceneManager) => boolean;
     export function registerCustomOptimizer(name: string, optimizer: (sceneManager: SceneManager) => boolean): void;
 }
 declare module BabylonViewer {
@@ -1558,20 +1558,6 @@ declare module BabylonViewer {
     export function addLoaderPlugin(name: string, plugin: ILoaderPlugin): void;
 }
 declare module BabylonViewer {
-    /**
-        * A custom upgrade-oriented function configuration for the scene optimizer.
-        *
-        * @param viewer the viewer to optimize
-        */
-    export function extendedUpgrade(sceneManager: SceneManager): boolean;
-    /**
-        * A custom degrade-oriented function configuration for the scene optimizer.
-        *
-        * @param viewer the viewer to optimize
-        */
-    export function extendedDegrade(sceneManager: SceneManager): boolean;
-}
-declare module BabylonViewer {
 }
 declare module BabylonViewer {
     export interface IEnvironmentMapConfiguration {
@@ -2093,26 +2079,6 @@ declare module BabylonViewer {
     }
 }
 declare module BabylonViewer {
-    export interface ISkyboxConfiguration {
-        cubeTexture?: {
-            noMipMap?: boolean;
-            gammaSpace?: boolean;
-            url?: string | Array<string>;
-        };
-        color?: {
-            r: number;
-            g: number;
-            b: number;
-        };
-        pbr?: boolean;
-        scale?: number;
-        blur?: number;
-        material?: {
-            imageProcessingConfiguration?: IImageProcessingConfiguration;
-            [propName: string]: any;
-        };
-        infiniteDistance?: boolean;
-    }
 }
 declare module BabylonViewer {
     /**

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

@@ -985,14 +985,13 @@ declare module 'babylonjs-viewer/templating/viewerTemplatePlugin' {
 }
 
 declare module 'babylonjs-viewer/optimizer/custom' {
-    import { extendedUpgrade } from "babylonjs-viewer/optimizer/custom/extended";
     import { SceneManager } from "babylonjs-viewer/managers/sceneManager";
     /**
       *
       * @param name the name of the custom optimizer configuration
       * @param upgrade set to true if you want to upgrade optimizer and false if you want to degrade
       */
-    export function getCustomOptimizerByName(name: string, upgrade?: boolean): typeof extendedUpgrade;
+    export function getCustomOptimizerByName(name: string, upgrade?: boolean): (sceneManager: SceneManager) => boolean;
     export function registerCustomOptimizer(name: string, optimizer: (sceneManager: SceneManager) => boolean): void;
 }
 
@@ -1663,22 +1662,6 @@ declare module 'babylonjs-viewer/loader/plugins' {
     export function addLoaderPlugin(name: string, plugin: ILoaderPlugin): void;
 }
 
-declare module 'babylonjs-viewer/optimizer/custom/extended' {
-    import { SceneManager } from 'babylonjs-viewer/managers/sceneManager';
-    /**
-        * A custom upgrade-oriented function configuration for the scene optimizer.
-        *
-        * @param viewer the viewer to optimize
-        */
-    export function extendedUpgrade(sceneManager: SceneManager): boolean;
-    /**
-        * A custom degrade-oriented function configuration for the scene optimizer.
-        *
-        * @param viewer the viewer to optimize
-        */
-    export function extendedDegrade(sceneManager: SceneManager): boolean;
-}
-
 declare module 'babylonjs-viewer/configuration/interfaces' {
     export * from 'babylonjs-viewer/configuration/interfaces/cameraConfiguration';
     export * from 'babylonjs-viewer/configuration/interfaces/colorGradingConfiguration';
@@ -2253,27 +2236,7 @@ declare module 'babylonjs-viewer/configuration/interfaces/sceneOptimizerConfigur
 }
 
 declare module 'babylonjs-viewer/configuration/interfaces/skyboxConfiguration' {
-    import { IImageProcessingConfiguration } from "babylonjs-viewer/configuration/interfaces/imageProcessingConfiguration";
-    export interface ISkyboxConfiguration {
-        cubeTexture?: {
-            noMipMap?: boolean;
-            gammaSpace?: boolean;
-            url?: string | Array<string>;
-        };
-        color?: {
-            r: number;
-            g: number;
-            b: number;
-        };
-        pbr?: boolean;
-        scale?: number;
-        blur?: number;
-        material?: {
-            imageProcessingConfiguration?: IImageProcessingConfiguration;
-            [propName: string]: any;
-        };
-        infiniteDistance?: boolean;
-    }
+    
 }
 
 declare module 'babylonjs-viewer/configuration/interfaces/templateConfiguration' {

dist/preview release/what's new.md

@@ -118,6 +118,7 @@
 - Improved _isSyncronized performance and reduced GC in TransformNode.computeWorldMatrix by directly reading property. ([Bolloxim](https://github.com/Bolloxim))
 - Added supports for reflectionMatrix in Skybox Mode Cube Texture allowing offsetting the world center or rotating the matrix ([sebavan](http://www.github.com/sebavan))
 - Improved performance of cached nodes but ensuring parent always updates cache. This removes failed isSynchronized test that meant computeWorldMatrix would always have to rebuild. On large scenes this could double framerate. ([Bolloxim](https://github.com/Bolloxim))
+- Added FXAA and MSAA support to the StandardRenderingPipeline ([julien-moreau](https://github.com/julien-moreau))
 
 ### glTF Loader
 

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

@@ -4,89 +4,227 @@
         * Public members
         */
         // Post-processes
+        /**
+         * Post-process which contains the original scene color before the pipeline applies all the effects
+         */
         public originalPostProcess: Nullable<PostProcess>;
+        /**
+         * Post-process used to down scale an image x4
+         */
         public downSampleX4PostProcess: Nullable<PostProcess> = null;
+        /**
+         * Post-process used to calculate the illuminated surfaces controlled by a threshold
+         */
         public brightPassPostProcess: Nullable<PostProcess> = null;
+        /**
+         * Post-process array storing all the horizontal blur post-processes used by the pipeline
+         */
         public blurHPostProcesses: PostProcess[] = [];
+        /**
+         * Post-process array storing all the vertical blur post-processes used by the pipeline
+         */
         public blurVPostProcesses: PostProcess[] = [];
+        /**
+         * Post-process used to add colors of 2 textures (typically brightness + real scene color)
+         */
         public textureAdderPostProcess: Nullable<PostProcess> = null;
 
+        /**
+         * Post-process used to create volumetric lighting effect
+         */
         public volumetricLightPostProcess: Nullable<PostProcess> = null;
+        /**
+         * Post-process used to smooth the previous volumetric light post-process on the X axis
+         */
         public volumetricLightSmoothXPostProcess: Nullable<BlurPostProcess> = null;
+        /**
+         * Post-process used to smooth the previous volumetric light post-process on the Y axis
+         */
         public volumetricLightSmoothYPostProcess: Nullable<BlurPostProcess> = null;
+        /**
+         * Post-process used to merge the volumetric light effect and the real scene color
+         */
         public volumetricLightMergePostProces: Nullable<PostProcess> = null;
+        /**
+         * Post-process used to store the final volumetric light post-process (attach/detach for debug purpose)
+         */
         public volumetricLightFinalPostProcess: Nullable<PostProcess> = null;
 
+        /**
+         * Base post-process used to calculate the average luminance of the final image for HDR
+         */
         public luminancePostProcess: Nullable<PostProcess> = null;
+        /**
+         * Post-processes used to create down sample post-processes in order to get
+         * the average luminance of the final image for HDR
+         * Array of length "StandardRenderingPipeline.LuminanceSteps"
+         */
         public luminanceDownSamplePostProcesses: PostProcess[] = [];
+        /**
+         * Post-process used to create a HDR effect (light adaptation)
+         */
         public hdrPostProcess: Nullable<PostProcess> = null;
-
+        /**
+         * Post-process used to store the final texture adder post-process (attach/detach for debug purpose)
+         */
         public textureAdderFinalPostProcess: Nullable<PostProcess> = null;
+        /**
+         * Post-process used to store the final lens flare post-process (attach/detach for debug purpose)
+         */
         public lensFlareFinalPostProcess: Nullable<PostProcess> = null;
+        /**
+         * Post-process used to merge the final HDR post-process and the real scene color
+         */
         public hdrFinalPostProcess: Nullable<PostProcess> = null;
-
+        /**
+         * Post-process used to create a lens flare effect
+         */
         public lensFlarePostProcess: Nullable<PostProcess> = null;
+        /**
+         * Post-process that merges the result of the lens flare post-process and the real scene color
+         */
         public lensFlareComposePostProcess: Nullable<PostProcess> = null;
-
+        /**
+         * Post-process used to create a motion blur effect
+         */
         public motionBlurPostProcess: Nullable<PostProcess> = null;
-
+        /**
+         * Post-process used to create a depth of field effect
+         */
         public depthOfFieldPostProcess: Nullable<PostProcess> = null;
+        /**
+         * The Fast Approximate Anti-Aliasing post process which attemps to remove aliasing from an image.
+         */
+        public fxaaPostProcess: Nullable<FxaaPostProcess> = null;
 
         // Values
+
+        /**
+         * Represents the brightness threshold in order to configure the illuminated surfaces
+         */
         @serialize()
         public brightThreshold: number = 1.0;
 
+        /**
+         * Configures the blur intensity used for surexposed surfaces are highlighted surfaces (light halo)
+         */
         @serialize()
         public blurWidth: number = 512.0;
+        /**
+         * Sets if the blur for highlighted surfaces must be only horizontal
+         */
         @serialize()
         public horizontalBlur: boolean = false;
 
+        /**
+         * Sets the overall exposure used by the pipeline
+         */
         @serialize()
         public exposure: number = 1.0;
+
+        /**
+         * Texture used typically to simulate "dirty" on camera lens
+         */
         @serializeAsTexture("lensTexture")
         public lensTexture: Nullable<Texture> = null;
 
+        /**
+         * Represents the offset coefficient based on Rayleigh principle. Typically in interval [-0.2, 0.2]
+         */
         @serialize()
         public volumetricLightCoefficient: number = 0.2;
+        /**
+         * The overall power of volumetric lights, typically in interval [0, 10] maximum
+         */
         @serialize()
         public volumetricLightPower: number = 4.0;
+        /**
+         * Used the set the blur intensity to smooth the volumetric lights
+         */
         @serialize()
         public volumetricLightBlurScale: number = 64.0;
-
+        /**
+         * Light (spot or directional) used to generate the volumetric lights rays
+         * The source light must have a shadow generate so the pipeline can get its 
+         * depth map
+         */
         public sourceLight: Nullable<SpotLight |  DirectionalLight> = null;
 
+        /**
+         * For eye adaptation, represents the minimum luminance the eye can see
+         */
         @serialize()
         public hdrMinimumLuminance: number = 1.0;
+        /**
+         * For eye adaptation, represents the decrease luminance speed
+         */
         @serialize()
         public hdrDecreaseRate: number = 0.5;
+        /**
+         * For eye adaptation, represents the increase luminance speed
+         */
         @serialize()
         public hdrIncreaseRate: number = 0.5;
 
+        /**
+         * Lens color texture used by the lens flare effect. Mandatory if lens flare effect enabled
+         */
         @serializeAsTexture("lensColorTexture")
         public lensColorTexture: Nullable<Texture> = null;
+        /**
+         * The overall strengh for the lens flare effect
+         */
         @serialize()
         public lensFlareStrength: number = 20.0;
+        /**
+         * Dispersion coefficient for lens flare ghosts
+         */
         @serialize()
         public lensFlareGhostDispersal: number = 1.4;
+        /**
+         * Main lens flare halo width
+         */
         @serialize()
         public lensFlareHaloWidth: number = 0.7;
+        /**
+         * Based on the lens distortion effect, defines how much the lens flare result
+         * is distorted
+         */
         @serialize()
         public lensFlareDistortionStrength: number = 16.0;
+        /**
+         * Lens star texture must be used to simulate rays on the flares and is available
+         * in the documentation
+         */
         @serializeAsTexture("lensStarTexture")
         public lensStarTexture: Nullable<Texture> = null;
+        /**
+         * As the "lensTexture" (can be the same texture or different), it is used to apply the lens
+         * flare effect by taking account of the dirt texture
+         */
         @serializeAsTexture("lensFlareDirtTexture")
         public lensFlareDirtTexture: Nullable<Texture> = null;
 
+        /**
+         * Represents the focal length for the depth of field effect
+         */
         @serialize()
         public depthOfFieldDistance: number = 10.0;
-
+        /**
+         * Represents the blur intensity for the blurred part of the depth of field effect
+         */
         @serialize()
         public depthOfFieldBlurWidth: number = 64.0;
 
+        /**
+         * For motion blur, defines how much the image is blurred by the movement
+         */
         @serialize()
         public motionStrength: number = 1.0;
 
-        // IAnimatable
+        /**
+         * List of animations for the pipeline (IAnimatable implementation)
+         */
         public animations: Animation[] = [];
 
         /**
@@ -104,16 +242,21 @@
         private _ratio: number;
 
         // Getters and setters
-        private _bloomEnabled: boolean = true;
+        private _bloomEnabled: boolean = false;
         private _depthOfFieldEnabled: boolean = false;
         private _vlsEnabled: boolean = false;
         private _lensFlareEnabled: boolean = false;
         private _hdrEnabled: boolean = false;
         private _motionBlurEnabled: boolean = false;
+        private _fxaaEnabled: boolean = false;
 
         private _motionBlurSamples: number = 64.0;
         private _volumetricLightStepsCount: number = 50.0;
+        private _samples: number = 1;
 
+        /**
+         * Specifies if the bloom pipeline is enabled
+         */
         @serialize()
         public get BloomEnabled(): boolean {
             return this._bloomEnabled;
@@ -128,6 +271,9 @@
             this._buildPipeline();
         }
 
+        /**
+         * Specifies if the depth of field pipeline is enabed
+         */
         @serialize()
         public get DepthOfFieldEnabled(): boolean {
             return this._depthOfFieldEnabled;
@@ -142,6 +288,9 @@
             this._buildPipeline();
         }
 
+        /**
+         * Specifies if the lens flare pipeline is enabed
+         */
         @serialize()
         public get LensFlareEnabled(): boolean {
             return this._lensFlareEnabled;
@@ -156,6 +305,9 @@
             this._buildPipeline();
         }
 
+        /**
+         * Specifies if the HDR pipeline is enabled
+         */
         @serialize()
         public get HDREnabled(): boolean {
             return this._hdrEnabled;
@@ -170,6 +322,9 @@
             this._buildPipeline();
         }
 
+        /**
+         * Specifies if the volumetric lights scattering effect is enabled
+         */
         @serialize()
         public get VLSEnabled(): boolean {
             return this._vlsEnabled;
@@ -192,6 +347,9 @@
             this._buildPipeline();
         }
 
+        /**
+         * Specifies if the motion blur effect is enabled
+         */
         @serialize()
         public get MotionBlurEnabled(): boolean {
             return this._motionBlurEnabled;
@@ -206,6 +364,27 @@
             this._buildPipeline();
         }
 
+        /**
+         * Specifies if anti-aliasing is enabled
+         */
+        @serialize()
+        public get fxaaEnabled(): boolean {
+            return this._fxaaEnabled;
+        }
+
+        public set fxaaEnabled(enabled: boolean) {
+            if (this._fxaaEnabled === enabled) {
+                return;
+            }
+
+            this._fxaaEnabled = enabled;
+            this._buildPipeline();
+        }
+
+        /**
+         * Specifies the number of steps used to calculate the volumetric lights
+         * Typically in interval [50, 200]
+         */
         @serialize()
         public get volumetricLightStepsCount(): number {
             return this._volumetricLightStepsCount;
@@ -219,6 +398,10 @@
             this._volumetricLightStepsCount = count;
         }
 
+        /**
+         * Specifies the number of samples used for the motion blur effect
+         * Typically in interval [16, 64]
+         */
         @serialize()
         public get motionBlurSamples(): number {
             return this._motionBlurSamples;
@@ -233,6 +416,23 @@
         }
 
         /**
+         * Specifies MSAA sample count, setting this to 4 will provide 4x anti aliasing. (default: 1)
+         */
+        @serialize()
+        public get samples(): number {
+            return this._samples;
+        }
+
+        public set samples(sampleCount: number) {
+            if (this._samples === sampleCount) {
+                return;
+            }
+
+            this._samples = sampleCount;
+            this._buildPipeline();
+        }
+
+        /**
          * @constructor
          * @param {string} name - The rendering pipeline name
          * @param {BABYLON.Scene} scene - The scene linked to this pipeline
@@ -340,9 +540,19 @@
                 this._createMotionBlurPostProcess(scene, ratio);
             }
 
+            if (this._fxaaEnabled) {
+                // Create fxaa post-process
+                this.fxaaPostProcess = new FxaaPostProcess("fxaa", 1.0, null, Texture.BILINEAR_SAMPLINGMODE, scene.getEngine(), false, Engine.TEXTURETYPE_UNSIGNED_INT);
+                this.addEffect(new PostProcessRenderEffect(scene.getEngine(), "HDRFxaa", () => { return this.fxaaPostProcess; }, true));
+            }
+
             if (this._cameras !== null) {
                 this._scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(this._name, this._cameras);
             }
+
+            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");
+            }
         }
 
         // Down Sample X4 Post-Processs
@@ -780,6 +990,8 @@
 
                 if (this.motionBlurPostProcess) { this.motionBlurPostProcess.dispose(camera); }
 
+                if (this.fxaaPostProcess) { this.fxaaPostProcess.dispose(camera); }
+
                 for (var j = 0; j < this.blurHPostProcesses.length; j++) {
                     this.blurHPostProcesses[j].dispose(camera);
                 }
@@ -806,6 +1018,7 @@
             this.hdrFinalPostProcess = null;
             this.depthOfFieldPostProcess = null;
             this.motionBlurPostProcess = null;
+            this.fxaaPostProcess = null;
 
             this.luminanceDownSamplePostProcesses = [];
             this.blurHPostProcesses = [];