nightly

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' {