function OutlinePass(scene, camera) {
	    var _this;

	    var options = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {};

	    classCallCheck(this, OutlinePass);

	    _this = possibleConstructorReturn(this, getPrototypeOf$2(OutlinePass).call(this, "OutlinePass"));
	    /**
	     * The main scene.
	     *
	     * @type {Scene}
	     * @private
	     */

	    _this.mainScene = scene;
	    /**
	     * The main camera.
	     *
	     * @type {Camera}
	     * @private
	     */

	    _this.mainCamera = camera;
	    /**
	     * A render target for depth information.
	     *
	     * @type {WebGLRenderTarget}
	     * @private
	     */

	    _this.renderTargetDepth = new WebGLRenderTarget(1, 1, {
	      minFilter: LinearFilter,
	      magFilter: LinearFilter
	    });
	    _this.renderTargetDepth.texture.name = "Outline.Depth";
	    _this.renderTargetDepth.texture.generateMipmaps = false;
	    /**
	     * A render target for the outline mask.
	     *
	     * @type {WebGLRenderTarget}
	     * @private
	     */

	    _this.renderTargetMask = _this.renderTargetDepth.clone();
	    _this.renderTargetMask.texture.format = RGBFormat;
	    _this.renderTargetMask.texture.name = "Outline.Mask";
	    /**
	     * A render target for the edge detection.
	     *
	     * @type {WebGLRenderTarget}
	     * @private
	     */

	    _this.renderTargetEdges = new WebGLRenderTarget(1, 1, {
	      minFilter: LinearFilter,
	      magFilter: LinearFilter,
	      stencilBuffer: false,
	      depthBuffer: false,
	      format: RGBFormat
	    });
	    _this.renderTargetEdges.texture.name = "Outline.Edges";
	    _this.renderTargetEdges.texture.generateMipmaps = false;
	    /**
	     * A render target for the blurred outline overlay.
	     *
	     * @type {WebGLRenderTarget}
	     * @private
	     */

	    _this.renderTargetBlurredEdges = _this.renderTargetEdges.clone();
	    _this.renderTargetBlurredEdges.texture.name = "Outline.BlurredEdges";
	    /**
	     * A depth pass.
	     *
	     * @type {RenderPass}
	     * @private
	     */

	    _this.renderPassDepth = new RenderPass(_this.mainScene, _this.mainCamera, {
	      overrideMaterial: new MeshDepthMaterial({
	        depthPacking: RGBADepthPacking,
	        morphTargets: true,
	        skinning: true
	      }),
	      clearColor: new Color(0xffffff),
	      clearAlpha: 1.0
	    });
	    /**
	     * A depth comparison mask pass.
	     *
	     * @type {RenderPass}
	     * @private
	     */

	    _this.renderPassMask = new RenderPass(_this.mainScene, _this.mainCamera, {
	      overrideMaterial: new DepthComparisonMaterial(_this.renderTargetDepth.texture, _this.mainCamera),
	      clearColor: new Color(0xffffff),
	      clearAlpha: 1.0
	    });
	    /**
	     * A blur pass.
	     *
	     * @type {BlurPass}
	     * @private
	     */

	    _this.blurPass = new BlurPass(options);
	    _this.kernelSize = options.kernelSize;
	    /**
	     * A copy pass that renders the read buffer to screen if needed.
	     *
	     * @type {ShaderPass}
	     * @private
	     */

	    _this.copyPass = new ShaderPass(new CopyMaterial());
	    _this.copyPass.renderToScreen = true;
	    /**
	     * An outline edge detection material.
	     *
	     * @type {OutlineEdgesMaterial}
	     * @private
	     */

	    _this.outlineEdgesMaterial = new OutlineEdgesMaterial(options);
	    _this.outlineEdgesMaterial.uniforms.tMask.value = _this.renderTargetMask.texture;
	    /**
	     * An outline blend material.
	     *
	     * @type {OutlineBlendMaterial}
	     * @private
	     */

	    _this.outlineBlendMaterial = new OutlineBlendMaterial(options);
	    _this.outlineBlendMaterial.uniforms.tMask.value = _this.renderTargetMask.texture;
	    _this.blur = options.blur !== undefined ? options.blur : true;
	    /**
	     * A list of objects to outline.
	     *
	     * @type {Object3D[]}
	     * @private
	     */

	    _this.selection = [];
	    /**
	     * The current animation time.
	     *
	     * @type {Number}
	     * @private
	     */

	    _this.time = 0.0;
	    /**
	     * The pulse speed. A value of zero disables the pulse effect.
	     *
	     * @type {Number}
	     */

	    _this.pulseSpeed = options.pulseSpeed !== undefined ? options.pulseSpeed : 0.0;
	    /**
	     * A dedicated render layer for selected objects.
	     *
	     * This layer is set to 10 by default. If this collides with your own custom
	     * layers, please change it to a free layer before rendering!
	     *
	     * @type {Number}
	     */

	    _this.selectionLayer = 10;
	    return _this;
	  }
Constructs a new outline pass.

@param {Scene} scene - The main scene.
@param {Camera} camera - The main camera.
@param {Object} [options] - Additional parameters. See {@link BlurPass}, {@link OutlineBlendMaterial} and {@link OutlineEdgesMaterial} for details.
@param {Number} [options.pulseSpeed=0.0] - The pulse speed. A value of zero disables the pulse effect.
@param {Boolean} [options.blur=true] - Whether the outline should be blurred.