function LensRenderingPipeline(name, parameters, scene, ratio, cameras) {
            if (ratio === void 0) { ratio = 1.0; }
            var _this = _super.call(this, scene.getEngine(), name) || this;
            // Lens effects can be of the following:
            // - chromatic aberration (slight shift of RGB colors)
            // - blur on the edge of the lens
            // - lens distortion
            // - depth-of-field blur & highlights enhancing
            // - depth-of-field 'bokeh' effect (shapes appearing in blurred areas)
            // - grain effect (noise or custom texture)
            // Two additional texture samplers are needed:
            // - depth map (for depth-of-field)
            // - grain texture
            /**
            * The chromatic aberration PostProcess id in the pipeline
            * @type {string}
            */
            _this.LensChromaticAberrationEffect = "LensChromaticAberrationEffect";
            /**
            * The highlights enhancing PostProcess id in the pipeline
            * @type {string}
            */
            _this.HighlightsEnhancingEffect = "HighlightsEnhancingEffect";
            /**
            * The depth-of-field PostProcess id in the pipeline
            * @type {string}
            */
            _this.LensDepthOfFieldEffect = "LensDepthOfFieldEffect";
            _this._scene = scene;
            // Fetch texture samplers
            _this._depthTexture = scene.enableDepthRenderer().getDepthMap(); // Force depth renderer "on"
            if (parameters.grain_texture) {
                _this._grainTexture = parameters.grain_texture;
            }
            else {
                _this._createGrainTexture();
            }
            // save parameters
            _this._edgeBlur = parameters.edge_blur ? parameters.edge_blur : 0;
            _this._grainAmount = parameters.grain_amount ? parameters.grain_amount : 0;
            _this._chromaticAberration = parameters.chromatic_aberration ? parameters.chromatic_aberration : 0;
            _this._distortion = parameters.distortion ? parameters.distortion : 0;
            _this._highlightsGain = parameters.dof_gain !== undefined ? parameters.dof_gain : -1;
            _this._highlightsThreshold = parameters.dof_threshold ? parameters.dof_threshold : 1;
            _this._dofDistance = parameters.dof_focus_distance !== undefined ? parameters.dof_focus_distance : -1;
            _this._dofAperture = parameters.dof_aperture ? parameters.dof_aperture : 1;
            _this._dofDarken = parameters.dof_darken ? parameters.dof_darken : 0;
            _this._dofPentagon = parameters.dof_pentagon !== undefined ? parameters.dof_pentagon : true;
            _this._blurNoise = parameters.blur_noise !== undefined ? parameters.blur_noise : true;
            // Create effects
            _this._createChromaticAberrationPostProcess(ratio);
            _this._createHighlightsPostProcess(ratio);
            _this._createDepthOfFieldPostProcess(ratio / 4);
            // Set up pipeline
            _this.addEffect(new BABYLON.PostProcessRenderEffect(scene.getEngine(), _this.LensChromaticAberrationEffect, function () { return _this._chromaticAberrationPostProcess; }, true));
            _this.addEffect(new BABYLON.PostProcessRenderEffect(scene.getEngine(), _this.HighlightsEnhancingEffect, function () { return _this._highlightsPostProcess; }, true));
            _this.addEffect(new BABYLON.PostProcessRenderEffect(scene.getEngine(), _this.LensDepthOfFieldEffect, function () { return _this._depthOfFieldPostProcess; }, true));
            if (_this._highlightsGain === -1) {
                _this._disableEffect(_this.HighlightsEnhancingEffect, null);
            }
            // Finish
            scene.postProcessRenderPipelineManager.addPipeline(_this);
            if (cameras) {
                scene.postProcessRenderPipelineManager.attachCamerasToRenderPipeline(name, cameras);
            }
            return _this;
        }
@constructor

Effect parameters are as follow:
{
     chromatic_aberration: number;       // from 0 to x (1 for realism)
     edge_blur: number;                  // from 0 to x (1 for realism)
     distortion: number;                 // from 0 to x (1 for realism)
     grain_amount: number;               // from 0 to 1
     grain_texture: BABYLON.Texture;     // texture to use for grain effect; if unset, use random B&W noise
     dof_focus_distance: number;         // depth-of-field: focus distance; unset to disable (disabled by default)
     dof_aperture: number;               // depth-of-field: focus blur bias (default: 1)
     dof_darken: number;                 // depth-of-field: darken that which is out of focus (from 0 to 1, disabled by default)
     dof_pentagon: boolean;              // depth-of-field: makes a pentagon-like "bokeh" effect
     dof_gain: number;                   // depth-of-field: highlights gain; unset to disable (disabled by default)
     dof_threshold: number;              // depth-of-field: highlights threshold (default: 1)
     blur_noise: boolean;                // add a little bit of noise to the blur (default: true)
}
Note: if an effect parameter is unset, effect is disabled

@param {string} name - The rendering pipeline name
@param {object} parameters - An object containing all parameters (see above)
@param {BABYLON.Scene} scene - The scene linked to this pipeline
@param {number} ratio - The size of the postprocesses (0.5 means that your postprocess will have a width = canvas.width 0.5 and a height = canvas.height 0.5)
@param {BABYLON.Camera[]} cameras - The array of cameras that the rendering pipeline will be attached to