{"version":3,"sources":["webpack:///./node_modules/postprocessing/build/postprocessing.esm.js"],"names":["_createForOfIteratorHelper","o","allowArrayLike","it","Symbol","iterator","Array","isArray","minLen","_arrayLikeToArray","n","Object","prototype","toString","call","slice","constructor","name","from","test","_unsupportedIterableToArray","length","i","F","s","done","value","e","_e","f","TypeError","err","normalCompletion","didErr","step","next","_e2","arr","len","arr2","_createSuper","Derived","hasNativeReflectConstruct","Reflect","construct","sham","Proxy","Date","_isNativeReflectConstruct","result","Super","NewTarget","this","arguments","apply","vertexShader","fragmentShader$1","vertexShader$1","ColorEdgesMaterial","_ShaderMaterial2","_super2","texelSize","undefined","type","defines","LOCAL_CONTRAST_ADAPTATION_FACTOR","EDGE_THRESHOLD","uniforms","inputBuffer","fragmentShader","depthWrite","depthTest","key","factor","toFixed","needsUpdate","threshold","Math","min","max","fragmentShader$2","vertexShader$2","kernelPresets","Float32Array","KernelSize","VERY_SMALL","SMALL","MEDIUM","LARGE","VERY_LARGE","HUGE","CopyMaterial","_ShaderMaterial4","_super4","opacity","fragmentShader$4","vertexShader$3","EffectMaterial","_ShaderMaterial7","_super7","_this3","shaderParts","camera","dithering","DEPTH_PACKING","depthBuffer","resolution","cameraNear","cameraFar","aspect","time","setShaderParts","setDefines","setUniforms","adoptCameraSettings","replace","Section","FRAGMENT_HEAD","get","FRAGMENT_MAIN_UV","FRAGMENT_MAIN_IMAGE","VERTEX_HEAD","VERTEX_MAIN_SUPPORT","_step","_iterator","entries","entry","_step2","_iterator2","near","far","PERSPECTIVE_CAMERA","width","height","set","Number","parseInt","fragmentShader$7","fragmentShader$8","vertexShader$4","fragmentShader$9","vertexShader$5","SMAAWeightsMaterial","_ShaderMaterial11","_super11","MAX_SEARCH_STEPS_INT","MAX_SEARCH_STEPS_FLOAT","MAX_SEARCH_STEPS_DIAG_INT","MAX_SEARCH_STEPS_DIAG_FLOAT","CORNER_ROUNDING","CORNER_ROUNDING_NORM","AREATEX_MAX_DISTANCE","AREATEX_MAX_DISTANCE_DIAG","AREATEX_PIXEL_SIZE","AREATEX_SUBTEX_SIZE","SEARCHTEX_SIZE","SEARCHTEX_PACKED_SIZE","areaTexture","searchTexture","steps","rounding","DISABLE_DIAG_DETECTION","DISABLE_CORNER_DETECTION","Resizer","resizable","base","target","scale","x","y","round","setSize","geometry","Pass","scene","screen","needsSwap","needsDepthTexture","renderToScreen","enabled","material","vertices","uvs","setAttribute","addAttribute","getFullscreenTriangle","frustumCulled","add","depthTexture","renderer","outputBuffer","deltaTime","stencilTest","Error","alpha","getFullscreenMaterial","dispose","_i","_Object$keys","keys","ClearMaskPass","_Pass2","_super13","_this7","stencil","state","buffers","setLocked","setTest","color","ClearPass","_Pass3","_super14","_this8","depth","overrideClearColor","overrideClearAlpha","clearAlpha","getClearAlpha","hasOverrideClearColor","hasOverrideClearAlpha","copy","getClearColor","setClearColor","setClearAlpha","setRenderTarget","clear","RenderPass","_Pass4","_super15","_this9","overrideMaterial","clearPass","renderTarget","render","BlendFunction","SKIP","ADD","ALPHA","AVERAGE","COLOR_BURN","COLOR_DODGE","DARKEN","DIFFERENCE","EXCLUSION","LIGHTEN","MULTIPLY","DIVIDE","NEGATION","NORMAL","OVERLAY","REFLECT","SCREEN","SOFT_LIGHT","SUBTRACT","blendFunctions","Map","BlendMode","blendFunction","Effect","_ref3","_ref3$attributes","attributes","EffectAttribute","NONE","_ref3$blendFunction","_ref3$defines","_ref3$uniforms","_ref3$extensions","extensions","_ref3$vertexShader","blendMode","_i2","_Object$keys2","CONVOLUTION","DEPTH","findSubstrings","regExp","string","substrings","exec","push","prefixSubstrings","prefix","strings","prefixed","_step3","_iterator3","substring","charAt","toUpperCase","RegExp","_step4","_iterator4","integrateEffect","effect","blendModes","functionRegExp","shaders","mainImageExists","indexOf","mainUvExists","varyings","names","transformedUv","readDepth","console","error","concat","forEach","_string","blendOpacity","EffectPass","_Pass6","_super17","_this11","setFullscreenMaterial","_len","effects","_key","sort","a","b","skipRendering","minTime","maxTime","_step5","blendRegExp","Set","id","_iterator5","_step8","_iterator8","_extension","_step6","_iterator6","values","getShaderCode","getDepthTexture","map","trim","size","_step7","_iterator7","extension","updateMaterial","depthPacking","_step9","_iterator9","setDepthTexture","_step10","_iterator10","update","texture","_step11","_iterator11","_step12","_iterator12","initialize","capabilities","maxFragmentUniforms","maxVertexUniforms","warn","maxVaryings","_step13","_iterator13","MaskPass","_Pass7","_super18","_this12","inverse","context","getContext","writeValue","clearValue","setMask","setOp","REPLACE","setFunc","ALWAYS","setClear","EQUAL","KEEP","NormalPass","_Pass8","_super19","_this13","_ref4","_ref4$resolutionScale","resolutionScale","_ref4$width","AUTO_SIZE","_ref4$height","renderPass","morphTargets","morphNormals","skinning","getClearPass","minFilter","magFilter","format","stencilBuffer","originalSize","ShaderPass","_Pass10","_super21","_this15","input","uniform","setInput","EffectComposer","_ref5","_ref5$depthBuffer","_ref5$stencilBuffer","autoClear","createBuffer","clone","copyPass","passes","updateDOM","oldRenderer","oldSize","getSize","newSize","parent","domElement","parentNode","equals","removeChild","appendChild","drawingBufferSize","getDrawingBufferSize","getContextAttributes","generateMipmaps","pass","index","splice","_step14","createDepthTexture","_iterator14","reduce","_step15","_iterator15","buffer","_step16","_iterator16","NOTEQUAL","updateStyle","_step17","_iterator17","_step18","_iterator18","PI","fragmentShader$t","vertexShader$9","SMAAEffect","_Effect21","_super44","searchImage","areaImage","_this32","preset","SMAAPreset","HIGH","renderTargetColorEdges","renderTargetWeights","colorEdgesPass","weightsPass","flipY","applyPreset","setEdgeDetectionThreshold","setOrthogonalSearchSteps","colorEdgesMaterial","weightsMaterial","LOW","diagonalDetection","cornerRounding","setDiagonalSearchSteps","setCornerRounding","ULTRA","fragmentShader$u","SSAOEffect","_Effect22","_super45","normalBuffer","_this33","_ref24","_ref24$blendFunction","_ref24$samples","samples","_ref24$rings","rings","_ref24$distanceThresh","distanceThreshold","_ref24$distanceFallof","distanceFalloff","_ref24$rangeThreshold","rangeThreshold","_ref24$rangeFalloff","rangeFalloff","_ref24$luminanceInflu","luminanceInfluence","_ref24$radius","radius","_ref24$scale","_ref24$bias","bias","random","r","setDistanceCutoff","setProximityCutoff","divide","falloff","updateRadiusStep","getInverse","projectionMatrix","floor","updateAngleStep","RawImageData","data","document","canvas","createElementNS","imageData","createImageData","putImageData","workerProgram","generate","disableCache","workerURL","URL","createObjectURL","Blob","worker","Worker","Promise","resolve","reject","addEventListener","event","searchImageData","areaImageData","urls","toCanvas","toDataURL","window","localStorage","setItem","revokeObjectURL","postMessage","SMAAImageLoader","loadingManager","_this37","onLoad","onError","externalManager","internalManager","itemStart","cachedURLs","getItem","then","Image","itemEnd","src","itemError","Vector2","v","Box2","Uint8Array","bilinear","lerp$1","p"],"mappings":"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","file":"4bdf9057-906c85a0256053154f0a.js","sourcesContent":["import \"core-js/modules/es6.typed.uint8-clamped-array\";\nimport \"core-js/modules/es6.math.trunc\";\nimport \"core-js/modules/es6.math.sign\";\nimport \"core-js/modules/es6.promise\";\nimport \"core-js/modules/es6.object.assign\";\nimport \"core-js/modules/es6.math.log2\";\nimport \"core-js/modules/es6.string.sub\";\nimport \"core-js/modules/es6.typed.uint8-array\";\nimport _wrapNativeSuper from \"/datadrive/gatsby/pfas/node_modules/@babel/runtime/helpers/esm/wrapNativeSuper\";\nimport \"core-js/modules/es6.array.reduce\";\nimport \"core-js/modules/es6.string.trim\";\nimport \"core-js/modules/es6.set\";\nimport \"core-js/modules/es6.array.sort\";\nimport _get from \"/datadrive/gatsby/pfas/node_modules/@babel/runtime/helpers/esm/get\";\nimport \"core-js/modules/es6.array.for-each\";\nimport \"core-js/modules/es6.array.index-of\";\nimport \"core-js/modules/es6.regexp.constructor\";\nimport \"core-js/modules/es6.map\";\nimport _assertThisInitialized from \"/datadrive/gatsby/pfas/node_modules/@babel/runtime/helpers/esm/assertThisInitialized\";\nimport \"core-js/modules/es6.object.keys\";\nimport \"core-js/modules/es6.array.is-array\";\nimport \"core-js/modules/es7.symbol.async-iterator\";\nimport \"core-js/modules/es6.symbol\";\nimport \"core-js/modules/es6.string.iterator\";\nimport \"core-js/modules/es6.array.from\";\nimport \"core-js/modules/es6.function.name\";\nimport \"core-js/modules/es6.number.constructor\";\nimport \"core-js/modules/es6.number.parse-int\";\nimport \"core-js/modules/web.dom.iterable\";\nimport \"core-js/modules/es6.array.iterator\";\nimport \"core-js/modules/es6.regexp.replace\";\nimport \"core-js/modules/es6.typed.float32-array\";\nimport \"core-js/modules/es6.regexp.to-string\";\nimport \"core-js/modules/es6.date.to-string\";\nimport \"core-js/modules/es6.object.to-string\";\nimport \"core-js/modules/es6.reflect.construct\";\nimport _inherits from \"/datadrive/gatsby/pfas/node_modules/@babel/runtime/helpers/esm/inherits\";\nimport _possibleConstructorReturn from \"/datadrive/gatsby/pfas/node_modules/@babel/runtime/helpers/esm/possibleConstructorReturn\";\nimport _getPrototypeOf from \"/datadrive/gatsby/pfas/node_modules/@babel/runtime/helpers/esm/getPrototypeOf\";\nimport _classCallCheck from \"/datadrive/gatsby/pfas/node_modules/@babel/runtime/helpers/esm/classCallCheck\";\nimport _createClass from \"/datadrive/gatsby/pfas/node_modules/@babel/runtime/helpers/esm/createClass\";\n\nfunction _createForOfIteratorHelper(o, allowArrayLike) { var it; if (typeof Symbol === \"undefined\" || o[Symbol.iterator] == null) { if (Array.isArray(o) || (it = _unsupportedIterableToArray(o)) || allowArrayLike && o && typeof o.length === \"number\") { if (it) o = it; var i = 0; var F = function F() {}; return { s: F, n: function n() { if (i >= o.length) return { done: true }; return { done: false, value: o[i++] }; }, e: function e(_e) { throw _e; }, f: F }; } throw new TypeError(\"Invalid attempt to iterate non-iterable instance.\\nIn order to be iterable, non-array objects must have a [Symbol.iterator]() method.\"); } var normalCompletion = true, didErr = false, err; return { s: function s() { it = o[Symbol.iterator](); }, n: function n() { var step = it.next(); normalCompletion = step.done; return step; }, e: function e(_e2) { didErr = true; err = _e2; }, f: function f() { try { if (!normalCompletion && it[\"return\"] != null) it[\"return\"](); } finally { if (didErr) throw err; } } }; }\n\nfunction _unsupportedIterableToArray(o, minLen) { if (!o) return; if (typeof o === \"string\") return _arrayLikeToArray(o, minLen); var n = Object.prototype.toString.call(o).slice(8, -1); if (n === \"Object\" && o.constructor) n = o.constructor.name; if (n === \"Map\" || n === \"Set\") return Array.from(o); if (n === \"Arguments\" || /^(?:Ui|I)nt(?:8|16|32)(?:Clamped)?Array$/.test(n)) return _arrayLikeToArray(o, minLen); }\n\nfunction _arrayLikeToArray(arr, len) { if (len == null || len > arr.length) len = arr.length; for (var i = 0, arr2 = new Array(len); i < len; i++) { arr2[i] = arr[i]; } return arr2; }\n\nfunction _createSuper(Derived) { var hasNativeReflectConstruct = _isNativeReflectConstruct(); return function _createSuperInternal() { var Super = _getPrototypeOf(Derived), result; if (hasNativeReflectConstruct) { var NewTarget = _getPrototypeOf(this).constructor; result = Reflect.construct(Super, arguments, NewTarget); } else { result = Super.apply(this, arguments); } return _possibleConstructorReturn(this, result); }; }\n\nfunction _isNativeReflectConstruct() { if (typeof Reflect === \"undefined\" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === \"function\") return true; try { Date.prototype.toString.call(Reflect.construct(Date, [], function () {})); return true; } catch (e) { return false; } }\n\n/**\n * postprocessing v6.10.0 build Fri Jan 17 2020\n * https://github.com/vanruesc/postprocessing\n * Copyright 2020 Raoul van Rüschen\n * @license Zlib\n */\nimport { ShaderMaterial, Uniform, Vector2 as Vector2$1, PerspectiveCamera, Scene, OrthographicCamera, Mesh, BufferGeometry, BufferAttribute, WebGLRenderTarget, LinearFilter, RGBFormat, Color, MeshDepthMaterial, RGBADepthPacking, MeshNormalMaterial, DepthTexture, DepthStencilFormat, UnsignedInt248Type, RGBAFormat, RepeatWrapping, NearestFilter, DataTexture, Vector3, Matrix4, Vector4, MeshBasicMaterial, Texture, LinearMipmapLinearFilter, LinearMipMapLinearFilter, LoadingManager } from 'three';\n/**\r\n * The Disposable contract.\r\n *\r\n * Implemented by objects that can free internal resources.\r\n *\r\n * @interface\r\n */\n\nvar Disposable = /*#__PURE__*/function () {\n  function Disposable() {\n    _classCallCheck(this, Disposable);\n  }\n\n  _createClass(Disposable, [{\n    key: \"dispose\",\n\n    /**\r\n     * Frees internal resources.\r\n     */\n    value: function dispose() {}\n  }]);\n\n  return Disposable;\n}();\n/**\r\n * The initializable contract.\r\n *\r\n * Implemented by objects that can be initialized.\r\n *\r\n * @interface\r\n */\n\n\nvar Initializable = /*#__PURE__*/function () {\n  function Initializable() {\n    _classCallCheck(this, Initializable);\n  }\n\n  _createClass(Initializable, [{\n    key: \"initialize\",\n\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - A renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel.\r\n     */\n    value: function initialize(renderer, alpha) {}\n  }]);\n\n  return Initializable;\n}();\n\nvar fragmentShader = \"uniform sampler2D previousLuminanceBuffer;uniform sampler2D currentLuminanceBuffer;uniform float minLuminance;uniform float deltaTime;uniform float tau;varying vec2 vUv;void main(){float previousLuminance=texture2D(previousLuminanceBuffer,vUv,MIP_LEVEL_1X1).r;float currentLuminance=texture2D(currentLuminanceBuffer,vUv,MIP_LEVEL_1X1).r;previousLuminance=max(minLuminance,previousLuminance);currentLuminance=max(minLuminance,currentLuminance);float adaptedLum=previousLuminance+(currentLuminance-previousLuminance)*(1.0-exp(-deltaTime*tau));gl_FragColor.r=adaptedLum;}\";\nvar vertexShader = \"varying vec2 vUv;void main(){vUv=position.xy*0.5+0.5;gl_Position=vec4(position.xy,1.0,1.0);}\";\n/**\r\n * An adaptive luminance shader material.\r\n */\n\nvar AdaptiveLuminanceMaterial = /*#__PURE__*/function (_ShaderMaterial) {\n  _inherits(AdaptiveLuminanceMaterial, _ShaderMaterial);\n\n  var _super = _createSuper(AdaptiveLuminanceMaterial);\n\n  /**\r\n   * Constructs a new adaptive luminance material.\r\n   */\n  function AdaptiveLuminanceMaterial() {\n    _classCallCheck(this, AdaptiveLuminanceMaterial);\n\n    return _super.call(this, {\n      type: \"AdaptiveLuminanceMaterial\",\n      defines: {\n        MIP_LEVEL_1X1: \"0.0\"\n      },\n      uniforms: {\n        previousLuminanceBuffer: new Uniform(null),\n        currentLuminanceBuffer: new Uniform(null),\n        minLuminance: new Uniform(0.01),\n        deltaTime: new Uniform(0.0),\n        tau: new Uniform(1.0)\n      },\n      fragmentShader: fragmentShader,\n      vertexShader: vertexShader,\n      depthWrite: false,\n      depthTest: false\n    });\n  }\n\n  return AdaptiveLuminanceMaterial;\n}(ShaderMaterial);\n\nvar fragmentShader$1 = \"uniform sampler2D inputBuffer;varying vec2 vUv;varying vec2 vUv0;varying vec2 vUv1;varying vec2 vUv2;varying vec2 vUv3;varying vec2 vUv4;varying vec2 vUv5;void main(){const vec2 threshold=vec2(EDGE_THRESHOLD);vec4 delta;vec3 c=texture2D(inputBuffer,vUv).rgb;vec3 cLeft=texture2D(inputBuffer,vUv0).rgb;vec3 t=abs(c-cLeft);delta.x=max(max(t.r,t.g),t.b);vec3 cTop=texture2D(inputBuffer,vUv1).rgb;t=abs(c-cTop);delta.y=max(max(t.r,t.g),t.b);vec2 edges=step(threshold,delta.xy);if(dot(edges,vec2(1.0))==0.0){discard;}vec3 cRight=texture2D(inputBuffer,vUv2).rgb;t=abs(c-cRight);delta.z=max(max(t.r,t.g),t.b);vec3 cBottom=texture2D(inputBuffer,vUv3).rgb;t=abs(c-cBottom);delta.w=max(max(t.r,t.g),t.b);float maxDelta=max(max(max(delta.x,delta.y),delta.z),delta.w);vec3 cLeftLeft=texture2D(inputBuffer,vUv4).rgb;t=abs(c-cLeftLeft);delta.z=max(max(t.r,t.g),t.b);vec3 cTopTop=texture2D(inputBuffer,vUv5).rgb;t=abs(c-cTopTop);delta.w=max(max(t.r,t.g),t.b);maxDelta=max(max(maxDelta,delta.z),delta.w);edges*=step(maxDelta,LOCAL_CONTRAST_ADAPTATION_FACTOR*delta.xy);gl_FragColor=vec4(edges,0.0,1.0);}\";\nvar vertexShader$1 = \"uniform vec2 texelSize;varying vec2 vUv;varying vec2 vUv0;varying vec2 vUv1;varying vec2 vUv2;varying vec2 vUv3;varying vec2 vUv4;varying vec2 vUv5;void main(){vUv=position.xy*0.5+0.5;vUv0=vUv+texelSize*vec2(-1.0,0.0);vUv1=vUv+texelSize*vec2(0.0,-1.0);vUv2=vUv+texelSize*vec2(1.0,0.0);vUv3=vUv+texelSize*vec2(0.0,1.0);vUv4=vUv+texelSize*vec2(-2.0,0.0);vUv5=vUv+texelSize*vec2(0.0,-2.0);gl_Position=vec4(position.xy,1.0,1.0);}\";\n/**\r\n * A material that detects edges in a color texture.\r\n *\r\n * Mainly used for Subpixel Morphological Antialiasing.\r\n */\n\nvar ColorEdgesMaterial = /*#__PURE__*/function (_ShaderMaterial2) {\n  _inherits(ColorEdgesMaterial, _ShaderMaterial2);\n\n  var _super2 = _createSuper(ColorEdgesMaterial);\n\n  /**\r\n   * Constructs a new color edges material.\r\n   *\r\n   * @param {Vector2} [texelSize] - The absolute screen texel size.\r\n   */\n  function ColorEdgesMaterial() {\n    var texelSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Vector2$1();\n\n    _classCallCheck(this, ColorEdgesMaterial);\n\n    return _super2.call(this, {\n      type: \"ColorEdgesMaterial\",\n      defines: {\n        LOCAL_CONTRAST_ADAPTATION_FACTOR: \"2.0\",\n        EDGE_THRESHOLD: \"0.1\"\n      },\n      uniforms: {\n        inputBuffer: new Uniform(null),\n        texelSize: new Uniform(texelSize)\n      },\n      fragmentShader: fragmentShader$1,\n      vertexShader: vertexShader$1,\n      depthWrite: false,\n      depthTest: false\n    });\n  }\n  /**\r\n   * Sets the local contrast adaptation factor.\r\n   *\r\n   * If there is a neighbor edge that has _factor_ times bigger contrast than\r\n   * the current edge, the edge will be discarded.\r\n   *\r\n   * This allows to eliminate spurious crossing edges and is based on the fact\r\n   * that if there is too much contrast in a direction, the perceptual contrast\r\n   * in the other neighbors will be hidden.\r\n   *\r\n   * @param {Number} factor - The local contrast adaptation factor. Default is 2.0.\r\n   */\n\n\n  _createClass(ColorEdgesMaterial, [{\n    key: \"setLocalContrastAdaptationFactor\",\n    value: function setLocalContrastAdaptationFactor(factor) {\n      this.defines.LOCAL_CONTRAST_ADAPTATION_FACTOR = factor.toFixed(\"2\");\n      this.needsUpdate = true;\n    }\n    /**\r\n     * Sets the edge detection sensitivity.\r\n     *\r\n     * A lower value results in more edges being detected at the expense of\r\n     * performance.\r\n     *\r\n     * 0.1 is a reasonable value, and allows to catch most visible edges.\r\n     * 0.05 is a rather overkill value, that allows to catch 'em all.\r\n     *\r\n     * If temporal supersampling is used, 0.2 could be a reasonable value, as low\r\n     * contrast edges are properly filtered by just 2x.\r\n     *\r\n     * @param {Number} threshold - The edge detection sensitivity. Range: [0.05, 0.5].\r\n     */\n\n  }, {\n    key: \"setEdgeDetectionThreshold\",\n    value: function setEdgeDetectionThreshold(threshold) {\n      threshold = Math.min(Math.max(threshold, 0.05), 0.5);\n      this.defines.EDGE_THRESHOLD = threshold.toFixed(\"2\");\n      this.needsUpdate = true;\n    }\n  }]);\n\n  return ColorEdgesMaterial;\n}(ShaderMaterial);\n\nvar fragmentShader$2 = \"#include <common>\\n#include <dithering_pars_fragment>\\nuniform sampler2D inputBuffer;varying vec2 vUv0;varying vec2 vUv1;varying vec2 vUv2;varying vec2 vUv3;void main(){vec4 sum=texture2D(inputBuffer,vUv0);sum+=texture2D(inputBuffer,vUv1);sum+=texture2D(inputBuffer,vUv2);sum+=texture2D(inputBuffer,vUv3);gl_FragColor=sum*0.25;\\n#include <dithering_fragment>\\n}\";\nvar vertexShader$2 = \"uniform vec2 texelSize;uniform vec2 halfTexelSize;uniform float kernel;uniform float scale;/*Packing multiple texture coordinates into one varying and using a swizzle toextract them in the fragment shader still causes a dependent texture read.*/varying vec2 vUv0;varying vec2 vUv1;varying vec2 vUv2;varying vec2 vUv3;void main(){vec2 uv=position.xy*0.5+0.5;vec2 dUv=(texelSize*vec2(kernel)+halfTexelSize)*scale;vUv0=vec2(uv.x-dUv.x,uv.y+dUv.y);vUv1=vec2(uv.x+dUv.x,uv.y+dUv.y);vUv2=vec2(uv.x+dUv.x,uv.y-dUv.y);vUv3=vec2(uv.x-dUv.x,uv.y-dUv.y);gl_Position=vec4(position.xy,1.0,1.0);}\";\n/**\r\n * An optimised convolution shader material.\r\n *\r\n * This material supports dithering.\r\n *\r\n * Based on the GDC2003 Presentation by Masaki Kawase, Bunkasha Games:\r\n *  Frame Buffer Postprocessing Effects in DOUBLE-S.T.E.A.L (Wreckless)\r\n * and an article by Filip Strugar, Intel:\r\n *  An investigation of fast real-time GPU-based image blur algorithms\r\n *\r\n * Further modified according to Apple's\r\n * [Best Practices for Shaders](https://goo.gl/lmRoM5).\r\n */\n\nvar ConvolutionMaterial = /*#__PURE__*/function (_ShaderMaterial3) {\n  _inherits(ConvolutionMaterial, _ShaderMaterial3);\n\n  var _super3 = _createSuper(ConvolutionMaterial);\n\n  /**\r\n   * Constructs a new convolution material.\r\n   *\r\n   * @param {Vector2} [texelSize] - The absolute screen texel size.\r\n   */\n  function ConvolutionMaterial() {\n    var _this;\n\n    var texelSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Vector2$1();\n\n    _classCallCheck(this, ConvolutionMaterial);\n\n    _this = _super3.call(this, {\n      type: \"ConvolutionMaterial\",\n      uniforms: {\n        inputBuffer: new Uniform(null),\n        texelSize: new Uniform(new Vector2$1()),\n        halfTexelSize: new Uniform(new Vector2$1()),\n        kernel: new Uniform(0.0),\n        scale: new Uniform(1.0)\n      },\n      fragmentShader: fragmentShader$2,\n      vertexShader: vertexShader$2,\n      depthWrite: false,\n      depthTest: false\n    });\n\n    _this.setTexelSize(texelSize.x, texelSize.y);\n    /**\r\n     * The current kernel size.\r\n     *\r\n     * @type {KernelSize}\r\n     */\n\n\n    _this.kernelSize = KernelSize.LARGE;\n    return _this;\n  }\n  /**\r\n   * Returns the kernel.\r\n   *\r\n   * @return {Float32Array} The kernel.\r\n   */\n\n\n  _createClass(ConvolutionMaterial, [{\n    key: \"getKernel\",\n    value: function getKernel() {\n      return kernelPresets[this.kernelSize];\n    }\n    /**\r\n     * Sets the texel size.\r\n     *\r\n     * @param {Number} x - The texel width.\r\n     * @param {Number} y - The texel height.\r\n     */\n\n  }, {\n    key: \"setTexelSize\",\n    value: function setTexelSize(x, y) {\n      this.uniforms.texelSize.value.set(x, y);\n      this.uniforms.halfTexelSize.value.set(x, y).multiplyScalar(0.5);\n    }\n  }]);\n\n  return ConvolutionMaterial;\n}(ShaderMaterial);\n/**\r\n * The Kawase blur kernel presets.\r\n *\r\n * @type {Float32Array[]}\r\n * @private\r\n */\n\n\nvar kernelPresets = [new Float32Array([0.0, 0.0]), new Float32Array([0.0, 1.0, 1.0]), new Float32Array([0.0, 1.0, 1.0, 2.0]), new Float32Array([0.0, 1.0, 2.0, 2.0, 3.0]), new Float32Array([0.0, 1.0, 2.0, 3.0, 4.0, 4.0, 5.0]), new Float32Array([0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 7.0, 8.0, 9.0, 10.0])];\n/**\r\n * A kernel size enumeration.\r\n *\r\n * @type {Object}\r\n * @property {Number} VERY_SMALL - A very small kernel that matches a 7x7 Gauss blur kernel.\r\n * @property {Number} SMALL - A small kernel that matches a 15x15 Gauss blur kernel.\r\n * @property {Number} MEDIUM - A medium sized kernel that matches a 23x23 Gauss blur kernel.\r\n * @property {Number} LARGE - A large kernel that matches a 35x35 Gauss blur kernel.\r\n * @property {Number} VERY_LARGE - A very large kernel that matches a 63x63 Gauss blur kernel.\r\n * @property {Number} HUGE - A huge kernel that matches a 127x127 Gauss blur kernel.\r\n */\n\nvar KernelSize = {\n  VERY_SMALL: 0,\n  SMALL: 1,\n  MEDIUM: 2,\n  LARGE: 3,\n  VERY_LARGE: 4,\n  HUGE: 5\n};\nvar fragmentShader$3 = \"uniform sampler2D inputBuffer;uniform float opacity;varying vec2 vUv;void main(){vec4 texel=texture2D(inputBuffer,vUv);gl_FragColor=opacity*texel;}\";\n/**\r\n * A simple copy shader material.\r\n */\n\nvar CopyMaterial = /*#__PURE__*/function (_ShaderMaterial4) {\n  _inherits(CopyMaterial, _ShaderMaterial4);\n\n  var _super4 = _createSuper(CopyMaterial);\n\n  /**\r\n   * Constructs a new copy material.\r\n   */\n  function CopyMaterial() {\n    _classCallCheck(this, CopyMaterial);\n\n    return _super4.call(this, {\n      type: \"CopyMaterial\",\n      uniforms: {\n        inputBuffer: new Uniform(null),\n        opacity: new Uniform(1.0)\n      },\n      fragmentShader: fragmentShader$3,\n      vertexShader: vertexShader,\n      depthWrite: false,\n      depthTest: false\n    });\n  }\n\n  return CopyMaterial;\n}(ShaderMaterial);\n\nvar fragmentShader$4 = \"#include <packing>\\n#include <clipping_planes_pars_fragment>\\nuniform sampler2D depthBuffer;uniform float cameraNear;uniform float cameraFar;varying float vViewZ;varying vec4 vProjTexCoord;void main(){\\n#include <clipping_planes_fragment>\\nvec2 projTexCoord=(vProjTexCoord.xy/vProjTexCoord.w)*0.5+0.5;projTexCoord=clamp(projTexCoord,0.002,0.998);float fragCoordZ=unpackRGBAToDepth(texture2D(depthBuffer,projTexCoord));\\n#ifdef PERSPECTIVE_CAMERA\\nfloat viewZ=perspectiveDepthToViewZ(fragCoordZ,cameraNear,cameraFar);\\n#else\\nfloat viewZ=orthographicDepthToViewZ(fragCoordZ,cameraNear,cameraFar);\\n#endif\\nfloat depthTest=(-vViewZ>-viewZ)? 1.0 : 0.0;gl_FragColor.rg=vec2(0.0,depthTest);}\";\nvar vertexShader$3 = \"#include <common>\\n#include <morphtarget_pars_vertex>\\n#include <skinning_pars_vertex>\\n#include <clipping_planes_pars_vertex>\\nvarying float vViewZ;varying vec4 vProjTexCoord;void main(){\\n#include <skinbase_vertex>\\n#include <begin_vertex>\\n#include <morphtarget_vertex>\\n#include <skinning_vertex>\\n#include <project_vertex>\\nvViewZ=mvPosition.z;vProjTexCoord=gl_Position;\\n#include <clipping_planes_vertex>\\n}\";\n/**\r\n * A depth comparison shader material.\r\n */\n\nvar DepthComparisonMaterial = /*#__PURE__*/function (_ShaderMaterial5) {\n  _inherits(DepthComparisonMaterial, _ShaderMaterial5);\n\n  var _super5 = _createSuper(DepthComparisonMaterial);\n\n  /**\r\n   * Constructs a new depth comparison material.\r\n   *\r\n   * @param {Texture} [depthTexture=null] - A depth texture.\r\n   * @param {PerspectiveCamera} [camera] - A camera.\r\n   */\n  function DepthComparisonMaterial() {\n    var _this2;\n\n    var depthTexture = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n    var camera = arguments.length > 1 ? arguments[1] : undefined;\n\n    _classCallCheck(this, DepthComparisonMaterial);\n\n    _this2 = _super5.call(this, {\n      type: \"DepthComparisonMaterial\",\n      uniforms: {\n        depthBuffer: new Uniform(depthTexture),\n        cameraNear: new Uniform(0.3),\n        cameraFar: new Uniform(1000)\n      },\n      fragmentShader: fragmentShader$4,\n      vertexShader: vertexShader$3,\n      depthWrite: false,\n      depthTest: false,\n      morphTargets: true,\n      skinning: true\n    });\n\n    _this2.adoptCameraSettings(camera);\n\n    return _this2;\n  }\n  /**\r\n   * Adopts the settings of the given camera.\r\n   *\r\n   * @param {Camera} [camera=null] - A camera.\r\n   */\n\n\n  _createClass(DepthComparisonMaterial, [{\n    key: \"adoptCameraSettings\",\n    value: function adoptCameraSettings() {\n      var camera = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n\n      if (camera !== null) {\n        this.uniforms.cameraNear.value = camera.near;\n        this.uniforms.cameraFar.value = camera.far;\n\n        if (camera instanceof PerspectiveCamera) {\n          this.defines.PERSPECTIVE_CAMERA = \"1\";\n        } else {\n          delete this.defines.PERSPECTIVE_CAMERA;\n        }\n      }\n    }\n  }]);\n\n  return DepthComparisonMaterial;\n}(ShaderMaterial);\n\nvar fragmentShader$5 = \"#include <common>\\n#include <packing>\\nuniform sampler2D depthBuffer0;uniform sampler2D depthBuffer1;uniform sampler2D inputBuffer;varying vec2 vUv;void main(){\\n#if DEPTH_PACKING_0 == 3201\\nfloat d0=unpackRGBAToDepth(texture2D(depthBuffer0,vUv));\\n#else\\nfloat d0=texture2D(depthBuffer0,vUv).r;\\n#endif\\n#if DEPTH_PACKING_1 == 3201\\nfloat d1=unpackRGBAToDepth(texture2D(depthBuffer1,vUv));\\n#else\\nfloat d1=texture2D(depthBuffer1,vUv).r;\\n#endif\\nif(d0<d1){discard;}gl_FragColor=texture2D(inputBuffer,vUv);}\";\n/**\r\n * A depth mask shader material.\r\n *\r\n * This material masks a color buffer by comparing two depth textures.\r\n */\n\nvar DepthMaskMaterial = /*#__PURE__*/function (_ShaderMaterial6) {\n  _inherits(DepthMaskMaterial, _ShaderMaterial6);\n\n  var _super6 = _createSuper(DepthMaskMaterial);\n\n  /**\r\n   * Constructs a new depth mask material.\r\n   */\n  function DepthMaskMaterial() {\n    _classCallCheck(this, DepthMaskMaterial);\n\n    return _super6.call(this, {\n      type: \"DepthMaskMaterial\",\n      defines: {\n        DEPTH_PACKING_0: \"0\",\n        DEPTH_PACKING_1: \"0\"\n      },\n      uniforms: {\n        depthBuffer0: new Uniform(null),\n        depthBuffer1: new Uniform(null),\n        inputBuffer: new Uniform(null)\n      },\n      fragmentShader: fragmentShader$5,\n      vertexShader: vertexShader,\n      depthWrite: false,\n      depthTest: false\n    });\n  }\n\n  return DepthMaskMaterial;\n}(ShaderMaterial);\n\nvar fragmentTemplate = \"#include <common>\\n#include <packing>\\n#include <dithering_pars_fragment>\\nuniform sampler2D inputBuffer;uniform sampler2D depthBuffer;uniform vec2 resolution;uniform vec2 texelSize;uniform float cameraNear;uniform float cameraFar;uniform float aspect;uniform float time;varying vec2 vUv;float readDepth(const in vec2 uv){\\n#if DEPTH_PACKING == 3201\\nreturn unpackRGBAToDepth(texture2D(depthBuffer,uv));\\n#else\\nreturn texture2D(depthBuffer,uv).r;\\n#endif\\n}float getViewZ(const in float depth){\\n#ifdef PERSPECTIVE_CAMERA\\nreturn perspectiveDepthToViewZ(depth,cameraNear,cameraFar);\\n#else\\nreturn orthographicDepthToViewZ(depth,cameraNear,cameraFar);\\n#endif\\n}FRAGMENT_HEADvoid main(){FRAGMENT_MAIN_UVvec4 color0=texture2D(inputBuffer,UV);vec4 color1=vec4(0.0);FRAGMENT_MAIN_IMAGEgl_FragColor=color0;\\n#include <dithering_fragment>\\n}\";\nvar vertexTemplate = \"uniform vec2 resolution;uniform vec2 texelSize;uniform float cameraNear;uniform float cameraFar;uniform float aspect;uniform float time;varying vec2 vUv;VERTEX_HEADvoid main(){vUv=position.xy*0.5+0.5;VERTEX_MAIN_SUPPORTgl_Position=vec4(position.xy,1.0,1.0);}\";\n/**\r\n * An effect material for compound shaders.\r\n *\r\n * This material supports dithering.\r\n *\r\n * @implements {Resizable}\r\n */\n\nvar EffectMaterial = /*#__PURE__*/function (_ShaderMaterial7) {\n  _inherits(EffectMaterial, _ShaderMaterial7);\n\n  var _super7 = _createSuper(EffectMaterial);\n\n  /**\r\n   * Constructs a new effect material.\r\n   *\r\n   * @param {Map<String, String>} [shaderParts=null] - A collection of shader snippets. See {@link Section}.\r\n   * @param {Map<String, String>} [defines=null] - A collection of preprocessor macro definitions.\r\n   * @param {Map<String, Uniform>} [uniforms=null] - A collection of uniforms.\r\n   * @param {Camera} [camera=null] - A camera.\r\n   * @param {Boolean} [dithering=false] - Whether dithering should be enabled.\r\n   */\n  function EffectMaterial() {\n    var _this3;\n\n    var shaderParts = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n    var defines = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n    var uniforms = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n    var camera = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : null;\n    var dithering = arguments.length > 4 && arguments[4] !== undefined ? arguments[4] : false;\n\n    _classCallCheck(this, EffectMaterial);\n\n    _this3 = _super7.call(this, {\n      type: \"EffectMaterial\",\n      defines: {\n        DEPTH_PACKING: \"0\"\n      },\n      uniforms: {\n        inputBuffer: new Uniform(null),\n        depthBuffer: new Uniform(null),\n        resolution: new Uniform(new Vector2$1()),\n        texelSize: new Uniform(new Vector2$1()),\n        cameraNear: new Uniform(0.3),\n        cameraFar: new Uniform(1000.0),\n        aspect: new Uniform(1.0),\n        time: new Uniform(0.0)\n      },\n      depthWrite: false,\n      depthTest: false,\n      dithering: dithering\n    });\n\n    if (shaderParts !== null) {\n      _this3.setShaderParts(shaderParts);\n    }\n\n    if (defines !== null) {\n      _this3.setDefines(defines);\n    }\n\n    if (uniforms !== null) {\n      _this3.setUniforms(uniforms);\n    }\n\n    _this3.adoptCameraSettings(camera);\n\n    return _this3;\n  }\n  /**\r\n   * The current depth packing.\r\n   *\r\n   * @type {Number}\r\n   */\n\n\n  _createClass(EffectMaterial, [{\n    key: \"setShaderParts\",\n\n    /**\r\n     * Sets the shader parts.\r\n     *\r\n     * @param {Map<String, String>} shaderParts - A collection of shader snippets. See {@link Section}.\r\n     * @return {EffectMaterial} This material.\r\n     */\n    value: function setShaderParts(shaderParts) {\n      this.fragmentShader = fragmentTemplate.replace(Section.FRAGMENT_HEAD, shaderParts.get(Section.FRAGMENT_HEAD)).replace(Section.FRAGMENT_MAIN_UV, shaderParts.get(Section.FRAGMENT_MAIN_UV)).replace(Section.FRAGMENT_MAIN_IMAGE, shaderParts.get(Section.FRAGMENT_MAIN_IMAGE));\n      this.vertexShader = vertexTemplate.replace(Section.VERTEX_HEAD, shaderParts.get(Section.VERTEX_HEAD)).replace(Section.VERTEX_MAIN_SUPPORT, shaderParts.get(Section.VERTEX_MAIN_SUPPORT));\n      this.needsUpdate = true;\n      return this;\n    }\n    /**\r\n     * Sets the shader macros.\r\n     *\r\n     * @param {Map<String, String>} defines - A collection of preprocessor macro definitions.\r\n     * @return {EffectMaterial} This material.\r\n     */\n\n  }, {\n    key: \"setDefines\",\n    value: function setDefines(defines) {\n      var _iterator = _createForOfIteratorHelper(defines.entries()),\n          _step;\n\n      try {\n        for (_iterator.s(); !(_step = _iterator.n()).done;) {\n          var entry = _step.value;\n          this.defines[entry[0]] = entry[1];\n        }\n      } catch (err) {\n        _iterator.e(err);\n      } finally {\n        _iterator.f();\n      }\n\n      this.needsUpdate = true;\n      return this;\n    }\n    /**\r\n     * Sets the shader uniforms.\r\n     *\r\n     * @param {Map<String, Uniform>} uniforms - A collection of uniforms.\r\n     * @return {EffectMaterial} This material.\r\n     */\n\n  }, {\n    key: \"setUniforms\",\n    value: function setUniforms(uniforms) {\n      var _iterator2 = _createForOfIteratorHelper(uniforms.entries()),\n          _step2;\n\n      try {\n        for (_iterator2.s(); !(_step2 = _iterator2.n()).done;) {\n          var entry = _step2.value;\n          this.uniforms[entry[0]] = entry[1];\n        }\n      } catch (err) {\n        _iterator2.e(err);\n      } finally {\n        _iterator2.f();\n      }\n\n      this.needsUpdate = true;\n      return this;\n    }\n    /**\r\n     * Adopts the settings of the given camera.\r\n     *\r\n     * @param {Camera} [camera=null] - A camera.\r\n     */\n\n  }, {\n    key: \"adoptCameraSettings\",\n    value: function adoptCameraSettings() {\n      var camera = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n\n      if (camera !== null) {\n        this.uniforms.cameraNear.value = camera.near;\n        this.uniforms.cameraFar.value = camera.far;\n\n        if (camera instanceof PerspectiveCamera) {\n          this.defines.PERSPECTIVE_CAMERA = \"1\";\n        } else {\n          delete this.defines.PERSPECTIVE_CAMERA;\n        }\n\n        this.needsUpdate = true;\n      }\n    }\n    /**\r\n     * Sets the resolution.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      width = Math.max(width, 1.0);\n      height = Math.max(height, 1.0);\n      this.uniforms.resolution.value.set(width, height);\n      this.uniforms.texelSize.value.set(1.0 / width, 1.0 / height);\n      this.uniforms.aspect.value = width / height;\n    }\n  }, {\n    key: \"depthPacking\",\n    get: function get() {\n      return Number.parseInt(this.defines.DEPTH_PACKING);\n    }\n    /**\r\n     * Sets the depth packing.\r\n     *\r\n     * Use `BasicDepthPacking` or `RGBADepthPacking` if your depth texture\r\n     * contains packed depth.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.defines.DEPTH_PACKING = value.toFixed(0);\n    }\n  }]);\n\n  return EffectMaterial;\n}(ShaderMaterial);\n/**\r\n * An enumeration of shader code placeholders used by the {@link EffectPass}.\r\n *\r\n * @type {Object}\r\n * @property {String} FRAGMENT_HEAD - A placeholder for function and variable declarations inside the fragment shader.\r\n * @property {String} FRAGMENT_MAIN_UV - A placeholder for UV transformations inside the fragment shader.\r\n * @property {String} FRAGMENT_MAIN_IMAGE - A placeholder for color calculations inside the fragment shader.\r\n * @property {String} VERTEX_HEAD - A placeholder for function and variable declarations inside the vertex shader.\r\n * @property {String} VERTEX_MAIN_SUPPORT - A placeholder for supporting calculations inside the vertex shader.\r\n */\n\n\nvar Section = {\n  FRAGMENT_HEAD: \"FRAGMENT_HEAD\",\n  FRAGMENT_MAIN_UV: \"FRAGMENT_MAIN_UV\",\n  FRAGMENT_MAIN_IMAGE: \"FRAGMENT_MAIN_IMAGE\",\n  VERTEX_HEAD: \"VERTEX_HEAD\",\n  VERTEX_MAIN_SUPPORT: \"VERTEX_MAIN_SUPPORT\"\n};\nvar fragmentShader$6 = \"#include <common>\\n#include <dithering_pars_fragment>\\nuniform sampler2D inputBuffer;uniform vec2 lightPosition;uniform float exposure;uniform float decay;uniform float density;uniform float weight;uniform float clampMax;varying vec2 vUv;void main(){vec2 coord=vUv;vec2 delta=coord-lightPosition;delta*=1.0/SAMPLES_FLOAT*density;float illuminationDecay=1.0;vec4 texel;vec4 color=vec4(0.0);/*Estimate the probability of occlusion at each pixel by summing samplesalong a ray to the light position.*/for(int i=0;i<SAMPLES_INT;++i){coord-=delta;texel=texture2D(inputBuffer,coord);texel*=illuminationDecay*weight;color+=texel;illuminationDecay*=decay;}gl_FragColor=clamp(color*exposure,0.0,clampMax);\\n#include <dithering_fragment>\\n}\";\n/**\r\n * A crepuscular rays shader material.\r\n *\r\n * This material supports dithering.\r\n *\r\n * References:\r\n *\r\n * Thibaut Despoulain, 2012:\r\n *  [(WebGL) Volumetric Light Approximation in Three.js](\r\n *  http://bkcore.com/blog/3d/webgl-three-js-volumetric-light-godrays.html)\r\n *\r\n * Nvidia, GPU Gems 3, 2008:\r\n *  [Chapter 13. Volumetric Light Scattering as a Post-Process](\r\n *  https://developer.nvidia.com/gpugems/GPUGems3/gpugems3_ch13.html)\r\n */\n\nvar GodRaysMaterial = /*#__PURE__*/function (_ShaderMaterial8) {\n  _inherits(GodRaysMaterial, _ShaderMaterial8);\n\n  var _super8 = _createSuper(GodRaysMaterial);\n\n  /**\r\n   * Constructs a new god rays material.\r\n   *\r\n   * @param {Vector2} lightPosition - The light position in screen space.\r\n   */\n  function GodRaysMaterial(lightPosition) {\n    _classCallCheck(this, GodRaysMaterial);\n\n    return _super8.call(this, {\n      type: \"GodRaysMaterial\",\n      defines: {\n        SAMPLES_INT: \"60\",\n        SAMPLES_FLOAT: \"60.0\"\n      },\n      uniforms: {\n        inputBuffer: new Uniform(null),\n        lightPosition: new Uniform(lightPosition),\n        density: new Uniform(1.0),\n        decay: new Uniform(1.0),\n        weight: new Uniform(1.0),\n        exposure: new Uniform(1.0),\n        clampMax: new Uniform(1.0)\n      },\n      fragmentShader: fragmentShader$6,\n      vertexShader: vertexShader,\n      depthWrite: false,\n      depthTest: false\n    });\n  }\n  /**\r\n   * The amount of samples per pixel.\r\n   *\r\n   * @type {Number}\r\n   */\n\n\n  _createClass(GodRaysMaterial, [{\n    key: \"samples\",\n    get: function get() {\n      return Number.parseInt(this.defines.SAMPLES_INT);\n    }\n    /**\r\n     * Sets the amount of samples per pixel.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      value = Math.floor(value);\n      this.defines.SAMPLES_INT = value.toFixed(0);\n      this.defines.SAMPLES_FLOAT = value.toFixed(1);\n      this.needsUpdate = true;\n    }\n  }]);\n\n  return GodRaysMaterial;\n}(ShaderMaterial);\n\nvar fragmentShader$7 = \"#include <common>\\nuniform sampler2D inputBuffer;\\n#ifdef RANGE\\nuniform vec2 range;\\n#elif defined(THRESHOLD)\\nuniform float threshold;uniform float smoothing;\\n#endif\\nvarying vec2 vUv;void main(){vec4 texel=texture2D(inputBuffer,vUv);float l=linearToRelativeLuminance(texel.rgb);\\n#ifdef RANGE\\nfloat low=step(range.x,l);float high=step(l,range.y);l*=low*high;\\n#elif defined(THRESHOLD)\\nl=smoothstep(threshold,threshold+smoothing,l);\\n#endif\\n#ifdef COLOR\\ngl_FragColor=vec4(texel.rgb*l,l);\\n#else\\ngl_FragColor=vec4(l);\\n#endif\\n}\";\n/**\r\n * A luminance shader material.\r\n *\r\n * This shader produces a greyscale luminance map that describes the absolute\r\n * amount of light emitted by a scene. It can also be configured to output\r\n * colours that are scaled with their respective luminance value. Additionally,\r\n * a range may be provided to mask out undesired texels.\r\n *\r\n * The alpha channel always contains the luminance value.\r\n *\r\n * On luminance coefficients:\r\n *  http://www.poynton.com/notes/colour_and_gamma/ColorFAQ.html#RTFToC9\r\n *\r\n * Coefficients for different colour spaces:\r\n *  https://hsto.org/getpro/habr/post_images/2ab/69d/084/2ab69d084f9a597e032624bcd74d57a7.png\r\n *\r\n * Luminance range reference:\r\n *  https://cycling74.com/2007/05/23/your-first-shader/#.Vty9FfkrL4Z\r\n */\n\nvar LuminanceMaterial = /*#__PURE__*/function (_ShaderMaterial9) {\n  _inherits(LuminanceMaterial, _ShaderMaterial9);\n\n  var _super9 = _createSuper(LuminanceMaterial);\n\n  /**\r\n   * Constructs a new luminance material.\r\n   *\r\n   * @param {Boolean} [colorOutput=false] - Defines whether the shader should output colors scaled with their luminance value.\r\n   * @param {Vector2} [luminanceRange] - If provided, the shader will mask out texels that aren't in the specified luminance range.\r\n   */\n  function LuminanceMaterial() {\n    var _this4;\n\n    var colorOutput = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n    var luminanceRange = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : null;\n\n    _classCallCheck(this, LuminanceMaterial);\n\n    var useRange = luminanceRange !== null;\n    _this4 = _super9.call(this, {\n      type: \"LuminanceMaterial\",\n      uniforms: {\n        inputBuffer: new Uniform(null),\n        threshold: new Uniform(0.0),\n        smoothing: new Uniform(1.0),\n        range: new Uniform(useRange ? luminanceRange : new Vector2$1())\n      },\n      fragmentShader: fragmentShader$7,\n      vertexShader: vertexShader,\n      depthWrite: false,\n      depthTest: false\n    });\n    _this4.colorOutput = colorOutput;\n    _this4.useThreshold = true;\n    _this4.useRange = useRange;\n    return _this4;\n  }\n  /**\r\n   * The luminance threshold.\r\n   *\r\n   * @type {Number}\r\n   */\n\n\n  _createClass(LuminanceMaterial, [{\n    key: \"setColorOutputEnabled\",\n\n    /**\r\n     * Enables or disables color output.\r\n     *\r\n     * @deprecated Use colorOutput instead.\r\n     * @param {Boolean} enabled - Whether color output should be enabled.\r\n     */\n    value: function setColorOutputEnabled(enabled) {\n      enabled ? this.defines.COLOR = \"1\" : delete this.defines.COLOR;\n      this.needsUpdate = true;\n    }\n    /**\r\n     * Indicates whether luminance masking is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"setLuminanceRangeEnabled\",\n\n    /**\r\n     * Enables or disables the luminance mask.\r\n     *\r\n     * @deprecated Use luminanceRange instead.\r\n     * @param {Boolean} enabled - Whether the luminance mask should be enabled.\r\n     */\n    value: function setLuminanceRangeEnabled(enabled) {\n      enabled ? this.defines.RANGE = \"1\" : delete this.defines.RANGE;\n      this.needsUpdate = true;\n    }\n  }, {\n    key: \"threshold\",\n    get: function get() {\n      return this.uniforms.threshold.value;\n    }\n    /**\r\n     * Sets the luminance threshold.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.uniforms.threshold.value = value;\n    }\n    /**\r\n     * The luminance threshold smoothing.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"smoothing\",\n    get: function get() {\n      return this.uniforms.smoothing.value;\n    }\n    /**\r\n     * Sets the luminance threshold smoothing.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.uniforms.smoothing.value = value;\n    }\n    /**\r\n     * Indicates whether the luminance threshold is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"useThreshold\",\n    get: function get() {\n      return this.defines.THRESHOLD !== undefined;\n    }\n    /**\r\n     * Enables or disables the luminance threshold.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.THRESHOLD = \"1\" : delete this.defines.THRESHOLD;\n      this.needsUpdate = true;\n    }\n    /**\r\n     * Indicates whether color output is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"colorOutput\",\n    get: function get() {\n      return this.defines.COLOR !== undefined;\n    }\n    /**\r\n     * Enables or disables color output.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.COLOR = \"1\" : delete this.defines.COLOR;\n      this.needsUpdate = true;\n    }\n  }, {\n    key: \"useRange\",\n    get: function get() {\n      return this.defines.RANGE !== undefined;\n    }\n    /**\r\n     * Enables or disables luminance masking.\r\n     *\r\n     * If enabled, the threshold will be ignored.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.RANGE = \"1\" : delete this.defines.RANGE;\n      this.needsUpdate = true;\n    }\n    /**\r\n     * Indicates whether luminance masking is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     * @deprecated Use useRange instead.\r\n     */\n\n  }, {\n    key: \"luminanceRange\",\n    get: function get() {\n      return this.defines.RANGE !== undefined;\n    }\n    /**\r\n     * Enables or disables luminance masking.\r\n     *\r\n     * @type {Boolean}\r\n     * @deprecated Use useRange instead.\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.RANGE = \"1\" : delete this.defines.RANGE;\n      this.needsUpdate = true;\n    }\n  }]);\n\n  return LuminanceMaterial;\n}(ShaderMaterial);\n\nvar fragmentShader$8 = \"uniform sampler2D maskTexture;varying vec2 vUv0;varying vec2 vUv1;varying vec2 vUv2;varying vec2 vUv3;void main(){vec2 c0=texture2D(maskTexture,vUv0).rg;vec2 c1=texture2D(maskTexture,vUv1).rg;vec2 c2=texture2D(maskTexture,vUv2).rg;vec2 c3=texture2D(maskTexture,vUv3).rg;float d0=(c0.x-c1.x)*0.5;float d1=(c2.x-c3.x)*0.5;float d=length(vec2(d0,d1));float a0=min(c0.y,c1.y);float a1=min(c2.y,c3.y);float visibilityFactor=min(a0,a1);gl_FragColor.rg=(1.0-visibilityFactor>0.001)? vec2(d,0.0): vec2(0.0,d);}\";\nvar vertexShader$4 = \"uniform vec2 texelSize;varying vec2 vUv0;varying vec2 vUv1;varying vec2 vUv2;varying vec2 vUv3;void main(){vec2 uv=position.xy*0.5+0.5;vUv0=vec2(uv.x+texelSize.x,uv.y);vUv1=vec2(uv.x-texelSize.x,uv.y);vUv2=vec2(uv.x,uv.y+texelSize.y);vUv3=vec2(uv.x,uv.y-texelSize.y);gl_Position=vec4(position.xy,1.0,1.0);}\";\n/**\r\n * An outline edge detection shader material.\r\n */\n\nvar OutlineEdgesMaterial = /*#__PURE__*/function (_ShaderMaterial10) {\n  _inherits(OutlineEdgesMaterial, _ShaderMaterial10);\n\n  var _super10 = _createSuper(OutlineEdgesMaterial);\n\n  /**\r\n   * Constructs a new outline edge detection material.\r\n   *\r\n   * @param {Vector2} [texelSize] - The absolute screen texel size.\r\n   */\n  function OutlineEdgesMaterial() {\n    var _this5;\n\n    var texelSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Vector2$1();\n\n    _classCallCheck(this, OutlineEdgesMaterial);\n\n    _this5 = _super10.call(this, {\n      type: \"OutlineEdgesMaterial\",\n      uniforms: {\n        maskTexture: new Uniform(null),\n        texelSize: new Uniform(new Vector2$1())\n      },\n      fragmentShader: fragmentShader$8,\n      vertexShader: vertexShader$4,\n      depthWrite: false,\n      depthTest: false\n    });\n\n    _this5.setTexelSize(texelSize.x, texelSize.y);\n\n    return _this5;\n  }\n  /**\r\n   * Sets the texel size.\r\n   *\r\n   * @param {Number} x - The texel width.\r\n   * @param {Number} y - The texel height.\r\n   */\n\n\n  _createClass(OutlineEdgesMaterial, [{\n    key: \"setTexelSize\",\n    value: function setTexelSize(x, y) {\n      this.uniforms.texelSize.value.set(x, y);\n    }\n  }]);\n\n  return OutlineEdgesMaterial;\n}(ShaderMaterial);\n\nvar fragmentShader$9 = \"#define sampleLevelZeroOffset(t, coord, offset) texture2D(t, coord + offset * texelSize)\\n#if __VERSION__ < 300\\n#define round(v) floor(v + 0.5)\\n#endif\\nuniform sampler2D inputBuffer;uniform sampler2D areaTexture;uniform sampler2D searchTexture;uniform vec2 texelSize;uniform vec2 resolution;varying vec2 vUv;varying vec4 vOffset[3];varying vec2 vPixCoord;/***Moves values to a target vector based on a given conditional vector.*/void movec(const in bvec2 c,inout vec2 variable,const in vec2 value){if(c.x){variable.x=value.x;}if(c.y){variable.y=value.y;}}void movec(const in bvec4 c,inout vec4 variable,const in vec4 value){movec(c.xy,variable.xy,value.xy);movec(c.zw,variable.zw,value.zw);}/***Allows to decode two binary values from a bilinear-filtered access.**Bilinear access for fetching 'e' have a 0.25 offset,and we are interested*in the R and G edges:**+---G---+-------+*|x o R   x|*+-------+-------+**Then,if one of these edge is enabled:*Red:(0.75*X+0.25*1)=>0.25 or 1.0*Green:(0.75*1+0.25*X)=>0.75 or 1.0**This function will unpack the values(mad+mul+round):*wolframalpha.com: round(x*abs(5*x-5*0.75))plot 0 to 1*/vec2 decodeDiagBilinearAccess(in vec2 e){e.r=e.r*abs(5.0*e.r-5.0*0.75);return round(e);}vec4 decodeDiagBilinearAccess(in vec4 e){e.rb=e.rb*abs(5.0*e.rb-5.0*0.75);return round(e);}/***Diagonal pattern searches.*/vec2 searchDiag1(const in vec2 texCoord,const in vec2 dir,out vec2 e){vec4 coord=vec4(texCoord,-1.0,1.0);vec3 t=vec3(texelSize,1.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(coord.z<float(MAX_SEARCH_STEPS_DIAG_INT-1)&&coord.w>0.9)){break;}coord.xyz=t*vec3(dir,1.0)+coord.xyz;e=texture2D(inputBuffer,coord.xy).rg;coord.w=dot(e,vec2(0.5));}return coord.zw;}vec2 searchDiag2(const in vec2 texCoord,const in vec2 dir,out vec2 e){vec4 coord=vec4(texCoord,-1.0,1.0);coord.x+=0.25*texelSize.x;vec3 t=vec3(texelSize,1.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(coord.z<float(MAX_SEARCH_STEPS_DIAG_INT-1)&&coord.w>0.9)){break;}coord.xyz=t*vec3(dir,1.0)+coord.xyz;e=texture2D(inputBuffer,coord.xy).rg;e=decodeDiagBilinearAccess(e);coord.w=dot(e,vec2(0.5));}return coord.zw;}/***Calculates the area corresponding to a certain diagonal distance and crossing*edges 'e'.*/vec2 areaDiag(const in vec2 dist,const in vec2 e,const in float offset){vec2 texCoord=vec2(AREATEX_MAX_DISTANCE_DIAG,AREATEX_MAX_DISTANCE_DIAG)*e+dist;texCoord=AREATEX_PIXEL_SIZE*texCoord+0.5*AREATEX_PIXEL_SIZE;texCoord.x+=0.5;texCoord.y+=AREATEX_SUBTEX_SIZE*offset;return texture2D(areaTexture,texCoord).rg;}/***Searches for diagonal patterns and returns the corresponding weights.*/vec2 calculateDiagWeights(const in vec2 texCoord,const in vec2 e,const in vec4 subsampleIndices){vec2 weights=vec2(0.0);vec4 d;vec2 end;if(e.r>0.0){d.xz=searchDiag1(texCoord,vec2(-1.0,1.0),end);d.x+=float(end.y>0.9);}else{d.xz=vec2(0.0);}d.yw=searchDiag1(texCoord,vec2(1.0,-1.0),end);if(d.x+d.y>2.0){vec4 coords=vec4(-d.x+0.25,d.x,d.y,-d.y-0.25)*texelSize.xyxy+texCoord.xyxy;vec4 c;c.xy=sampleLevelZeroOffset(inputBuffer,coords.xy,vec2(-1,0)).rg;c.zw=sampleLevelZeroOffset(inputBuffer,coords.zw,vec2(1,0)).rg;c.yxwz=decodeDiagBilinearAccess(c.xyzw);vec2 cc=vec2(2.0)*c.xz+c.yw;movec(bvec2(step(0.9,d.zw)),cc,vec2(0.0));weights+=areaDiag(d.xy,cc,subsampleIndices.z);}d.xz=searchDiag2(texCoord,vec2(-1.0,-1.0),end);if(sampleLevelZeroOffset(inputBuffer,texCoord,vec2(1,0)).r>0.0){d.yw=searchDiag2(texCoord,vec2(1.0),end);d.y+=float(end.y>0.9);}else{d.yw=vec2(0.0);}if(d.x+d.y>2.0){vec4 coords=vec4(-d.x,-d.x,d.y,d.y)*texelSize.xyxy+texCoord.xyxy;vec4 c;c.x=sampleLevelZeroOffset(inputBuffer,coords.xy,vec2(-1,0)).g;c.y=sampleLevelZeroOffset(inputBuffer,coords.xy,vec2(0,-1)).r;c.zw=sampleLevelZeroOffset(inputBuffer,coords.zw,vec2(1,0)).gr;vec2 cc=vec2(2.0)*c.xz+c.yw;movec(bvec2(step(0.9,d.zw)),cc,vec2(0.0));weights+=areaDiag(d.xy,cc,subsampleIndices.w).gr;}return weights;}/***Determines how much length should be added in the last step of the searches.**Takes the bilinearly interpolated edge(see @PSEUDO_GATHER4),and adds 0,1*or 2 depending on which edges and crossing edges are active.*/float searchLength(const in vec2 e,const in float offset){/*The texture is flipped vertically,with left and right cases taking halfof the space horizontally.*/vec2 scale=SEARCHTEX_SIZE*vec2(0.5,-1.0);vec2 bias=SEARCHTEX_SIZE*vec2(offset,1.0);scale+=vec2(-1.0,1.0);bias+=vec2(0.5,-0.5);scale*=1.0/SEARCHTEX_PACKED_SIZE;bias*=1.0/SEARCHTEX_PACKED_SIZE;return texture2D(searchTexture,scale*e+bias).r;}/***Horizontal search for the second pass.*/float searchXLeft(in vec2 texCoord,const in float end){/*@PSEUDO_GATHER4This texCoord has been offset by(-0.25,-0.125)in the vertex shader tosample between edges,thus fetching four edges in a row.Sampling with different offsets in each direction allows to disambiguatewhich edges are active from the four fetched ones.*/vec2 e=vec2(0.0,1.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(texCoord.x>end&&e.g>0.8281&&e.r==0.0)){break;}e=texture2D(inputBuffer,texCoord).rg;texCoord=vec2(-2.0,0.0)*texelSize+texCoord;}float offset=-(255.0/127.0)*searchLength(e,0.0)+3.25;return texelSize.x*offset+texCoord.x;}float searchXRight(vec2 texCoord,const in float end){vec2 e=vec2(0.0,1.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(texCoord.x<end&&e.g>0.8281&&e.r==0.0)){break;}e=texture2D(inputBuffer,texCoord).rg;texCoord=vec2(2.0,0.0)*texelSize.xy+texCoord;}float offset=-(255.0/127.0)*searchLength(e,0.5)+3.25;return-texelSize.x*offset+texCoord.x;}/***Vertical search for the second pass.*/float searchYUp(vec2 texCoord,const in float end){vec2 e=vec2(1.0,0.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;++i){if(!(texCoord.y>end&&e.r>0.8281&&e.g==0.0)){break;}e=texture2D(inputBuffer,texCoord).rg;texCoord=-vec2(0.0,2.0)*texelSize.xy+texCoord;}float offset=-(255.0/127.0)*searchLength(e.gr,0.0)+3.25;return texelSize.y*offset+texCoord.y;}float searchYDown(vec2 texCoord,const in float end){vec2 e=vec2(1.0,0.0);for(int i=0;i<MAX_SEARCH_STEPS_INT;i++){if(!(texCoord.y<end&&e.r>0.8281&&e.g==0.0)){break;}e=texture2D(inputBuffer,texCoord).rg;texCoord=vec2(0.0,2.0)*texelSize.xy+texCoord;}float offset=-(255.0/127.0)*searchLength(e.gr,0.5)+3.25;return-texelSize.y*offset+texCoord.y;}/***Determines the areas at each side of the current edge.*/vec2 area(const in vec2 dist,const in float e1,const in float e2,const in float offset){vec2 texCoord=vec2(AREATEX_MAX_DISTANCE)*round(4.0*vec2(e1,e2))+dist;texCoord=AREATEX_PIXEL_SIZE*texCoord+0.5*AREATEX_PIXEL_SIZE;texCoord.y=AREATEX_SUBTEX_SIZE*offset+texCoord.y;return texture2D(areaTexture,texCoord).rg;}/***Corner detection.*/void detectHorizontalCornerPattern(inout vec2 weights,const in vec4 texCoord,const in vec2 d){\\n#if !defined(DISABLE_CORNER_DETECTION)\\nvec2 leftRight=step(d.xy,d.yx);vec2 rounding=(1.0-CORNER_ROUNDING_NORM)*leftRight;rounding/=leftRight.x+leftRight.y;vec2 factor=vec2(1.0);factor.x-=rounding.x*sampleLevelZeroOffset(inputBuffer,texCoord.xy,vec2(0,1)).r;factor.x-=rounding.y*sampleLevelZeroOffset(inputBuffer,texCoord.zw,vec2(1,1)).r;factor.y-=rounding.x*sampleLevelZeroOffset(inputBuffer,texCoord.xy,vec2(0,-2)).r;factor.y-=rounding.y*sampleLevelZeroOffset(inputBuffer,texCoord.zw,vec2(1,-2)).r;weights*=saturate(factor);\\n#endif\\n}void detectVerticalCornerPattern(inout vec2 weights,const in vec4 texCoord,const in vec2 d){\\n#if !defined(DISABLE_CORNER_DETECTION)\\nvec2 leftRight=step(d.xy,d.yx);vec2 rounding=(1.0-CORNER_ROUNDING_NORM)*leftRight;rounding/=leftRight.x+leftRight.y;vec2 factor=vec2(1.0);factor.x-=rounding.x*sampleLevelZeroOffset(inputBuffer,texCoord.xy,vec2(1,0)).g;factor.x-=rounding.y*sampleLevelZeroOffset(inputBuffer,texCoord.zw,vec2(1,1)).g;factor.y-=rounding.x*sampleLevelZeroOffset(inputBuffer,texCoord.xy,vec2(-2,0)).g;factor.y-=rounding.y*sampleLevelZeroOffset(inputBuffer,texCoord.zw,vec2(-2,1)).g;weights*=saturate(factor);\\n#endif\\n}void main(){vec4 weights=vec4(0.0);vec4 subsampleIndices=vec4(0.0);vec2 e=texture2D(inputBuffer,vUv).rg;if(e.g>0.0){\\n#if !defined(DISABLE_DIAG_DETECTION)\\n/*Diagonals have both north and west edges,so searching for them in one ofthe boundaries is enough.*/weights.rg=calculateDiagWeights(vUv,e,subsampleIndices);if(weights.r==-weights.g){\\n#endif\\nvec2 d;vec3 coords;coords.x=searchXLeft(vOffset[0].xy,vOffset[2].x);coords.y=vOffset[1].y;d.x=coords.x;/*Now fetch the left crossing edges,two at a time using bilinearfiltering. Sampling at-0.25(see @CROSSING_OFFSET)enables to discern whatvalue each edge has.*/float e1=texture2D(inputBuffer,coords.xy).r;coords.z=searchXRight(vOffset[0].zw,vOffset[2].y);d.y=coords.z;/*Translate distances to pixel units for better interleave arithmetic andmemory accesses.*/d=round(resolution.xx*d+-vPixCoord.xx);vec2 sqrtD=sqrt(abs(d));float e2=sampleLevelZeroOffset(inputBuffer,coords.zy,vec2(1,0)).r;weights.rg=area(sqrtD,e1,e2,subsampleIndices.y);coords.y=vUv.y;detectHorizontalCornerPattern(weights.rg,coords.xyzy,d);\\n#if !defined(DISABLE_DIAG_DETECTION)\\n}else{e.r=0.0;}\\n#endif\\n}if(e.r>0.0){vec2 d;vec3 coords;coords.y=searchYUp(vOffset[1].xy,vOffset[2].z);coords.x=vOffset[0].x;d.x=coords.y;float e1=texture2D(inputBuffer,coords.xy).g;coords.z=searchYDown(vOffset[1].zw,vOffset[2].w);d.y=coords.z;d=round(resolution.yy*d-vPixCoord.yy);vec2 sqrtD=sqrt(abs(d));float e2=sampleLevelZeroOffset(inputBuffer,coords.xz,vec2(0,1)).g;weights.ba=area(sqrtD,e1,e2,subsampleIndices.x);coords.x=vUv.x;detectVerticalCornerPattern(weights.ba,coords.xyxz,d);}gl_FragColor=weights;}\";\nvar vertexShader$5 = \"uniform vec2 texelSize;uniform vec2 resolution;varying vec2 vUv;varying vec4 vOffset[3];varying vec2 vPixCoord;void main(){vUv=position.xy*0.5+0.5;vPixCoord=vUv*resolution;vOffset[0]=vUv.xyxy+texelSize.xyxy*vec4(-0.25,-0.125,1.25,-0.125);vOffset[1]=vUv.xyxy+texelSize.xyxy*vec4(-0.125,-0.25,-0.125,1.25);vOffset[2]=vec4(vOffset[0].xz,vOffset[1].yw)+vec4(-2.0,2.0,-2.0,2.0)*texelSize.xxyy*MAX_SEARCH_STEPS_FLOAT;gl_Position=vec4(position.xy,1.0,1.0);}\";\n/**\r\n * Subpixel Morphological Antialiasing.\r\n *\r\n * This material computes weights for detected edges.\r\n */\n\nvar SMAAWeightsMaterial = /*#__PURE__*/function (_ShaderMaterial11) {\n  _inherits(SMAAWeightsMaterial, _ShaderMaterial11);\n\n  var _super11 = _createSuper(SMAAWeightsMaterial);\n\n  /**\r\n   * Constructs a new SMAA weights material.\r\n   *\r\n   * @param {Vector2} [texelSize] - The absolute screen texel size.\r\n   * @param {Vector2} [resolution] - The resolution.\r\n   */\n  function SMAAWeightsMaterial() {\n    var texelSize = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new Vector2$1();\n    var resolution = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Vector2$1();\n\n    _classCallCheck(this, SMAAWeightsMaterial);\n\n    return _super11.call(this, {\n      type: \"SMAAWeightsMaterial\",\n      defines: {\n        // Configurable settings:\n        MAX_SEARCH_STEPS_INT: \"16\",\n        MAX_SEARCH_STEPS_FLOAT: \"16.0\",\n        MAX_SEARCH_STEPS_DIAG_INT: \"8\",\n        MAX_SEARCH_STEPS_DIAG_FLOAT: \"8.0\",\n        CORNER_ROUNDING: \"25\",\n        CORNER_ROUNDING_NORM: \"0.25\",\n        // Non-configurable settings:\n        AREATEX_MAX_DISTANCE: \"16.0\",\n        AREATEX_MAX_DISTANCE_DIAG: \"20.0\",\n        AREATEX_PIXEL_SIZE: \"(1.0 / vec2(160.0, 560.0))\",\n        AREATEX_SUBTEX_SIZE: \"(1.0 / 7.0)\",\n        SEARCHTEX_SIZE: \"vec2(66.0, 33.0)\",\n        SEARCHTEX_PACKED_SIZE: \"vec2(64.0, 16.0)\"\n      },\n      uniforms: {\n        inputBuffer: new Uniform(null),\n        areaTexture: new Uniform(null),\n        searchTexture: new Uniform(null),\n        texelSize: new Uniform(texelSize),\n        resolution: new Uniform(resolution)\n      },\n      fragmentShader: fragmentShader$9,\n      vertexShader: vertexShader$5,\n      depthWrite: false,\n      depthTest: false\n    });\n  }\n  /**\r\n   * Sets the maximum amount of steps performed in the horizontal/vertical\r\n   * pattern searches, at each side of the pixel.\r\n   *\r\n   * In number of pixels, it's actually the double. So the maximum line length\r\n   * perfectly handled by, for example 16, is 64 (perfectly means that longer\r\n   * lines won't look as good, but are still antialiased).\r\n   *\r\n   * @param {Number} steps - The search steps. Range: [0, 112].\r\n   */\n\n\n  _createClass(SMAAWeightsMaterial, [{\n    key: \"setOrthogonalSearchSteps\",\n    value: function setOrthogonalSearchSteps(steps) {\n      steps = Math.min(Math.max(steps, 0), 112);\n      this.defines.MAX_SEARCH_STEPS_INT = steps.toFixed(\"0\");\n      this.defines.MAX_SEARCH_STEPS_FLOAT = steps.toFixed(\"1\");\n      this.needsUpdate = true;\n    }\n    /**\r\n     * Specifies the maximum steps performed in the diagonal pattern searches, at\r\n     * each side of the pixel. This search jumps one pixel at time.\r\n     *\r\n     * On high-end machines this search is cheap (between 0.8x and 0.9x slower for\r\n     * 16 steps), but it can have a significant impact on older machines.\r\n     *\r\n     * @param {Number} steps - The search steps. Range: [0, 20].\r\n     */\n\n  }, {\n    key: \"setDiagonalSearchSteps\",\n    value: function setDiagonalSearchSteps(steps) {\n      steps = Math.min(Math.max(steps, 0), 20);\n      this.defines.MAX_SEARCH_STEPS_DIAG_INT = steps.toFixed(\"0\");\n      this.defines.MAX_SEARCH_STEPS_DIAG_FLOAT = steps.toFixed(\"1\");\n      this.needsUpdate = true;\n    }\n    /**\r\n     * Specifies how much sharp corners will be rounded.\r\n     *\r\n     * @param {Number} rounding - The corner rounding amount. Range: [0, 100].\r\n     */\n\n  }, {\n    key: \"setCornerRounding\",\n    value: function setCornerRounding(rounding) {\n      rounding = Math.min(Math.max(rounding, 0), 100);\n      this.defines.CORNER_ROUNDING = rounding.toFixed(\"4\");\n      this.defines.CORNER_ROUNDING_NORM = (rounding / 100.0).toFixed(\"4\");\n      this.needsUpdate = true;\n    }\n    /**\r\n     * Indicates whether diagonal pattern detection is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"diagonalDetection\",\n    get: function get() {\n      return this.defines.DISABLE_DIAG_DETECTION === undefined;\n    }\n    /**\r\n     * Enables or disables diagonal pattern detection.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? delete this.defines.DISABLE_DIAG_DETECTION : this.defines.DISABLE_DIAG_DETECTION = \"1\";\n      this.needsUpdate = true;\n    }\n    /**\r\n     * Indicates whether corner rounding is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"cornerRounding\",\n    get: function get() {\n      return this.defines.DISABLE_CORNER_DETECTION === undefined;\n    }\n    /**\r\n     * Enables or disables corner rounding.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? delete this.defines.DISABLE_CORNER_DETECTION : this.defines.DISABLE_CORNER_DETECTION = \"1\";\n      this.needsUpdate = true;\n    }\n  }]);\n\n  return SMAAWeightsMaterial;\n}(ShaderMaterial);\n/**\r\n * An auto sizing constant.\r\n *\r\n * @type {Number}\r\n * @private\r\n */\n\n\nvar AUTO_SIZE = -1;\n/**\r\n * A resizer.\r\n */\n\nvar Resizer = /*#__PURE__*/function () {\n  /**\r\n   * Constructs a new resizer.\r\n   *\r\n   * @param {Resizable} resizeable - A resizable object.\r\n   * @param {Number} [width=Resizer.AUTO_SIZE] - The width.\r\n   * @param {Number} [height=Resizer.AUTO_SIZE] - The height.\r\n   */\n  function Resizer(resizable) {\n    var width = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : AUTO_SIZE;\n    var height = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : AUTO_SIZE;\n\n    _classCallCheck(this, Resizer);\n\n    /**\r\n     * A resizable object.\r\n     *\r\n     * @type {Resizable}\r\n     */\n    this.resizable = resizable;\n    /**\r\n     * The base size.\r\n     *\r\n     * This size will be passed to the resizable object every time the width or\r\n     * height is changed.\r\n     *\r\n     * @type {Vector2}\r\n     */\n\n    this.base = new Vector2$1(1, 1);\n    /**\r\n     * The target size.\r\n     *\r\n     * @type {Vector2}\r\n     * @private\r\n     */\n\n    this.target = new Vector2$1(width, height);\n    /**\r\n     * A scale.\r\n     *\r\n     * If both the width and the height are set to {@link Resizer.AUTO_SIZE},\r\n     * they will be scaled uniformly using this scalar.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Added for internal use only.\r\n     */\n\n    this.scale = 1.0;\n  }\n  /**\r\n   * The calculated width.\r\n   *\r\n   * If both the width and the height are set to {@link Resizer.AUTO_SIZE}, the\r\n   * base width will be returned.\r\n   *\r\n   * @type {Number}\r\n   */\n\n\n  _createClass(Resizer, [{\n    key: \"width\",\n    get: function get() {\n      var base = this.base;\n      var target = this.target;\n      var result;\n\n      if (target.x !== AUTO_SIZE) {\n        result = target.x;\n      } else if (target.y !== AUTO_SIZE) {\n        result = Math.round(target.y * (base.x / base.y));\n      } else {\n        result = Math.round(base.x * this.scale);\n      }\n\n      return result;\n    }\n    /**\r\n     * Sets the target width.\r\n     *\r\n     * Use {@link Resizer.AUTO_SIZE} to automatically calculate the width based\r\n     * on the height and the original aspect ratio.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.target.x = value;\n      this.resizable.setSize(this.base.x, this.base.y);\n    }\n    /**\r\n     * The calculated height.\r\n     *\r\n     * If both the width and the height are set to {@link Resizer.AUTO_SIZE}, the\r\n     * base height will be returned.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"height\",\n    get: function get() {\n      var base = this.base;\n      var target = this.target;\n      var result;\n\n      if (target.y !== AUTO_SIZE) {\n        result = target.y;\n      } else if (target.x !== AUTO_SIZE) {\n        result = Math.round(target.x / (base.x / base.y));\n      } else {\n        result = Math.round(base.y * this.scale);\n      }\n\n      return result;\n    }\n    /**\r\n     * Sets the target height.\r\n     *\r\n     * Use {@link Resizer.AUTO_SIZE} to automatically calculate the height based\r\n     * on the width and the original aspect ratio.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.target.y = value;\n      this.resizable.setSize(this.base.x, this.base.y);\n    }\n    /**\r\n     * An auto sizing constant.\r\n     *\r\n     * Can be used to automatically calculate the width or height based on the\r\n     * original aspect ratio.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }], [{\n    key: \"AUTO_SIZE\",\n    get: function get() {\n      return AUTO_SIZE;\n    }\n  }]);\n\n  return Resizer;\n}();\n/**\r\n * Shared fullscreen geometry.\r\n *\r\n * @type {BufferGeometry}\r\n * @private\r\n */\n\n\nvar geometry = null;\n/**\r\n * Returns a shared fullscreen triangle.\r\n *\r\n * The size of the screen is 2x2 units (NDC). A triangle that fills the screen\r\n * needs to be 4 units wide and 4 units tall.\r\n *\r\n * @private\r\n * @return {BufferGeometry} The fullscreen geometry.\r\n */\n\nfunction getFullscreenTriangle() {\n  if (geometry === null) {\n    var vertices = new Float32Array([-1, -1, 0, 3, -1, 0, -1, 3, 0]);\n    var uvs = new Float32Array([0, 0, 2, 0, 0, 2]);\n    geometry = new BufferGeometry(); // Added for backward compatibility (setAttribute was added in three r110).\n\n    if (geometry.setAttribute !== undefined) {\n      geometry.setAttribute(\"position\", new BufferAttribute(vertices, 3));\n      geometry.setAttribute(\"uv\", new BufferAttribute(uvs, 2));\n    } else {\n      geometry.addAttribute(\"position\", new BufferAttribute(vertices, 3));\n      geometry.addAttribute(\"uv\", new BufferAttribute(uvs, 2));\n    }\n  }\n\n  return geometry;\n}\n/**\r\n * An abstract pass.\r\n *\r\n * Passes that do not rely on the depth buffer should explicitly disable the\r\n * depth test and depth write flags of their fullscreen shader material.\r\n *\r\n * Fullscreen passes use a shared fullscreen triangle:\r\n * https://michaldrobot.com/2014/04/01/gcn-execution-patterns-in-full-screen-passes/\r\n *\r\n * @implements {Initializable}\r\n * @implements {Resizable}\r\n * @implements {Disposable}\r\n */\n\n\nvar Pass = /*#__PURE__*/function () {\n  /**\r\n   * Constructs a new pass.\r\n   *\r\n   * @param {String} [name] - The name of this pass. Does not have to be unique.\r\n   * @param {Scene} [scene] - The scene to render. The default scene contains a single mesh that fills the screen.\r\n   * @param {Camera} [camera] - The camera. The default camera perfectly captures the screen mesh.\r\n   */\n  function Pass() {\n    var name = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : \"Pass\";\n    var scene = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Scene();\n    var camera = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : new OrthographicCamera(-1, 1, 1, -1, 0, 1);\n\n    _classCallCheck(this, Pass);\n\n    /**\r\n     * The name of this pass.\r\n     *\r\n     * @type {String}\r\n     */\n    this.name = name;\n    /**\r\n     * The scene to render.\r\n     *\r\n     * @type {Scene}\r\n     * @protected\r\n     */\n\n    this.scene = scene;\n    /**\r\n     * The camera.\r\n     *\r\n     * @type {Camera}\r\n     * @protected\r\n     */\n\n    this.camera = camera;\n    /**\r\n     * A mesh that fills the screen.\r\n     *\r\n     * @type {Mesh}\r\n     * @private\r\n     */\n\n    this.screen = null;\n    /**\r\n     * Only relevant for subclassing.\r\n     *\r\n     * Indicates whether the {@link EffectComposer} should swap the frame\r\n     * buffers after this pass has finished rendering.\r\n     *\r\n     * Set this to `false` if this pass doesn't render to the output buffer or\r\n     * the screen. Otherwise, the contents of the input buffer will be lost.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    this.needsSwap = true;\n    /**\r\n     * Indicates whether the {@link EffectComposer} should prepare a depth\r\n     * texture for this pass.\r\n     *\r\n     * Set this to `true` if this pass relies on depth information from a\r\n     * preceding {@link RenderPass}.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    this.needsDepthTexture = false;\n    /**\r\n     * Indicates whether this pass should render to screen.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    this.renderToScreen = false;\n    /**\r\n     * Indicates whether this pass should be executed.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    this.enabled = true;\n  }\n  /**\r\n   * Returns the current fullscreen material.\r\n   *\r\n   * @return {Material} The current fullscreen material, or null if there is none.\r\n   */\n\n\n  _createClass(Pass, [{\n    key: \"getFullscreenMaterial\",\n    value: function getFullscreenMaterial() {\n      return this.screen !== null ? this.screen.material : null;\n    }\n    /**\r\n     * Sets the fullscreen material.\r\n     *\r\n     * The material will be assigned to a mesh that fills the screen. The mesh\r\n     * will be created once a material is assigned via this method.\r\n     *\r\n     * @protected\r\n     * @param {Material} material - A fullscreen material.\r\n     */\n\n  }, {\n    key: \"setFullscreenMaterial\",\n    value: function setFullscreenMaterial(material) {\n      var screen = this.screen;\n\n      if (screen !== null) {\n        screen.material = material;\n      } else {\n        screen = new Mesh(getFullscreenTriangle(), material);\n        screen.frustumCulled = false;\n\n        if (this.scene === null) {\n          this.scene = new Scene();\n        }\n\n        this.scene.add(screen);\n        this.screen = screen;\n      }\n    }\n    /**\r\n     * Returns the current depth texture.\r\n     *\r\n     * @return {Texture} The current depth texture, or null if there is none.\r\n     */\n\n  }, {\n    key: \"getDepthTexture\",\n    value: function getDepthTexture() {\n      return null;\n    }\n    /**\r\n     * Sets the depth texture.\r\n     *\r\n     * You may override this method if your pass relies on the depth information\r\n     * of a preceding {@link RenderPass}.\r\n     *\r\n     * @param {Texture} depthTexture - A depth texture.\r\n     * @param {Number} [depthPacking=0] - The depth packing.\r\n     */\n\n  }, {\n    key: \"setDepthTexture\",\n    value: function setDepthTexture(depthTexture) {\n      var depthPacking = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n    }\n    /**\r\n     * Renders the effect.\r\n     *\r\n     * This is an abstract method that must be overridden.\r\n     *\r\n     * @abstract\r\n     * @throws {Error} An error is thrown if the method is not overridden.\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n     */\n\n  }, {\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      throw new Error(\"Render method not implemented!\");\n    }\n    /**\r\n     * Updates this pass with the renderer's size.\r\n     *\r\n     * You may override this method in case you want to be informed about the size\r\n     * of the main frame buffer.\r\n     *\r\n     * The {@link EffectComposer} calls this method before this pass is\r\n     * initialized and every time its own size is updated.\r\n     *\r\n     * @param {Number} width - The renderer's width.\r\n     * @param {Number} height - The renderer's height.\r\n     * @example this.myRenderTarget.setSize(width, height);\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {}\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * By overriding this method you gain access to the renderer. You'll also be\r\n     * able to configure your custom render targets to use the appropriate format\r\n     * (RGB or RGBA).\r\n     *\r\n     * The provided renderer can be used to warm up special off-screen render\r\n     * targets by performing a preliminary render operation.\r\n     *\r\n     * The {@link EffectComposer} calls this method when this pass is added to its\r\n     * queue, but not before its size has been set.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     * @example if(!alpha) { this.myRenderTarget.texture.format = RGBFormat; }\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {}\n    /**\r\n     * Performs a shallow search for disposable properties and deletes them. The\r\n     * pass will be inoperative after this method was called!\r\n     *\r\n     * Disposable objects:\r\n     *  - WebGLRenderTarget\r\n     *  - Material\r\n     *  - Texture\r\n     *\r\n     * The {@link EffectComposer} calls this method when it is being destroyed.\r\n     * You may, however, use it independently to free memory when you are certain\r\n     * that you don't need this pass anymore.\r\n     */\n\n  }, {\n    key: \"dispose\",\n    value: function dispose() {\n      var material = this.getFullscreenMaterial();\n\n      if (material !== null) {\n        material.dispose();\n      }\n\n      for (var _i = 0, _Object$keys = Object.keys(this); _i < _Object$keys.length; _i++) {\n        var key = _Object$keys[_i];\n\n        if (this[key] !== null && typeof this[key].dispose === \"function\") {\n          /** @ignore */\n          this[key].dispose();\n        }\n      }\n    }\n  }]);\n\n  return Pass;\n}();\n/**\r\n * An efficient, incremental blur pass.\r\n */\n\n\nvar BlurPass = /*#__PURE__*/function (_Pass) {\n  _inherits(BlurPass, _Pass);\n\n  var _super12 = _createSuper(BlurPass);\n\n  /**\r\n   * Constructs a new blur pass.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {Number} [options.resolutionScale=0.5] - Deprecated. Adjust the height or width instead for consistent results.\r\n   * @param {Number} [options.width=Resizer.AUTO_SIZE] - The blur render width.\r\n   * @param {Number} [options.height=Resizer.AUTO_SIZE] - The blur render height.\r\n   * @param {KernelSize} [options.kernelSize=KernelSize.LARGE] - The blur kernel size.\r\n   */\n  function BlurPass() {\n    var _this6;\n\n    var _ref = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref$resolutionScale = _ref.resolutionScale,\n        resolutionScale = _ref$resolutionScale === void 0 ? 0.5 : _ref$resolutionScale,\n        _ref$width = _ref.width,\n        width = _ref$width === void 0 ? Resizer.AUTO_SIZE : _ref$width,\n        _ref$height = _ref.height,\n        height = _ref$height === void 0 ? Resizer.AUTO_SIZE : _ref$height,\n        _ref$kernelSize = _ref.kernelSize,\n        kernelSize = _ref$kernelSize === void 0 ? KernelSize.LARGE : _ref$kernelSize;\n\n    _classCallCheck(this, BlurPass);\n\n    _this6 = _super12.call(this, \"BlurPass\");\n    /**\r\n     * A render target.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this6.renderTargetA = new WebGLRenderTarget(1, 1, {\n      minFilter: LinearFilter,\n      magFilter: LinearFilter,\n      stencilBuffer: false,\n      depthBuffer: false\n    });\n    _this6.renderTargetA.texture.name = \"Blur.TargetA\";\n    /**\r\n     * A second render target.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this6.renderTargetB = _this6.renderTargetA.clone();\n    _this6.renderTargetB.texture.name = \"Blur.TargetB\";\n    /**\r\n     * The desired render resolution.\r\n     *\r\n     * It's recommended to set the height or the width to an absolute value for\r\n     * consistent results across different devices and resolutions.\r\n     *\r\n     * Use {@link Resizer.AUTO_SIZE} for the width or height to automatically\r\n     * calculate it based on its counterpart and the original aspect ratio.\r\n     *\r\n     * @type {Resizer}\r\n     */\n\n    _this6.resolution = new Resizer(_assertThisInitialized(_this6), width, height);\n    _this6.resolution.scale = resolutionScale;\n    /**\r\n     * A convolution shader material.\r\n     *\r\n     * @type {ConvolutionMaterial}\r\n     * @private\r\n     */\n\n    _this6.convolutionMaterial = new ConvolutionMaterial();\n    /**\r\n     * A convolution shader material that uses dithering.\r\n     *\r\n     * @type {ConvolutionMaterial}\r\n     * @private\r\n     */\n\n    _this6.ditheredConvolutionMaterial = new ConvolutionMaterial();\n    _this6.ditheredConvolutionMaterial.dithering = true;\n    /**\r\n     * Whether the blurred result should also be dithered using noise.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    _this6.dithering = false;\n    _this6.kernelSize = kernelSize;\n    return _this6;\n  }\n  /**\r\n   * The current width of the internal render targets.\r\n   *\r\n   * @type {Number}\r\n   * @deprecated Use resolution.width instead.\r\n   */\n\n\n  _createClass(BlurPass, [{\n    key: \"getResolutionScale\",\n\n    /**\r\n     * Returns the current resolution scale.\r\n     *\r\n     * @return {Number} The resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n    value: function getResolutionScale() {\n      return this.resolution.scale;\n    }\n    /**\r\n     * Sets the resolution scale.\r\n     *\r\n     * @param {Number} scale - The new resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n\n  }, {\n    key: \"setResolutionScale\",\n    value: function setResolutionScale(scale) {\n      this.resolution.scale = scale;\n      this.setSize(this.resolution.base.x, this.resolution.base.y);\n    }\n    /**\r\n     * Blurs the input buffer and writes the result to the output buffer. The\r\n     * input buffer remains intact, unless it's also the output buffer.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n     */\n\n  }, {\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      var scene = this.scene;\n      var camera = this.camera;\n      var renderTargetA = this.renderTargetA;\n      var renderTargetB = this.renderTargetB;\n      var material = this.convolutionMaterial;\n      var uniforms = material.uniforms;\n      var kernel = material.getKernel();\n      var lastRT = inputBuffer;\n      var destRT;\n      var i, l;\n      this.setFullscreenMaterial(material); // Apply the multi-pass blur.\n\n      for (i = 0, l = kernel.length - 1; i < l; ++i) {\n        // Alternate between targets.\n        destRT = (i & 1) === 0 ? renderTargetA : renderTargetB;\n        uniforms.kernel.value = kernel[i];\n        uniforms.inputBuffer.value = lastRT.texture;\n        renderer.setRenderTarget(destRT);\n        renderer.render(scene, camera);\n        lastRT = destRT;\n      }\n\n      if (this.dithering) {\n        material = this.ditheredConvolutionMaterial;\n        uniforms = material.uniforms;\n        this.setFullscreenMaterial(material);\n      }\n\n      uniforms.kernel.value = kernel[i];\n      uniforms.inputBuffer.value = lastRT.texture;\n      renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);\n      renderer.render(scene, camera);\n    }\n    /**\r\n     * Updates the size of this pass.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      var resolution = this.resolution;\n      resolution.base.set(width, height);\n      width = resolution.width;\n      height = resolution.height;\n      this.renderTargetA.setSize(width, height);\n      this.renderTargetB.setSize(width, height);\n      this.convolutionMaterial.setTexelSize(1.0 / width, 1.0 / height);\n      this.ditheredConvolutionMaterial.setTexelSize(1.0 / width, 1.0 / height);\n    }\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {\n      if (!alpha) {\n        this.renderTargetA.texture.format = RGBFormat;\n        this.renderTargetB.texture.format = RGBFormat;\n      }\n    }\n    /**\r\n     * An auto sizing flag.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use {@link Resizer.AUTO_SIZE} instead.\r\n     */\n\n  }, {\n    key: \"width\",\n    get: function get() {\n      return this.resolution.width;\n    }\n    /**\r\n     * Sets the render width.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.width instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.resolution.width = value;\n    }\n    /**\r\n     * The current height of the internal render targets.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.height instead.\r\n     */\n\n  }, {\n    key: \"height\",\n    get: function get() {\n      return this.resolution.height;\n    }\n    /**\r\n     * Sets the render height.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.height instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.resolution.height = value;\n    }\n    /**\r\n     * The current blur scale.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"scale\",\n    get: function get() {\n      return this.convolutionMaterial.uniforms.scale.value;\n    }\n    /**\r\n     * Sets the blur scale.\r\n     *\r\n     * This value influences the overall blur strength and should not be greater\r\n     * than 1. For larger blurs please increase the {@link kernelSize}!\r\n     *\r\n     * Note that the blur strength is closely tied to the resolution. For a smooth\r\n     * transition from no blur to full blur, set the width or the height to a high\r\n     * enough value.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.convolutionMaterial.uniforms.scale.value = value;\n      this.ditheredConvolutionMaterial.uniforms.scale.value = value;\n    }\n    /**\r\n     * The kernel size.\r\n     *\r\n     * @type {KernelSize}\r\n     */\n\n  }, {\n    key: \"kernelSize\",\n    get: function get() {\n      return this.convolutionMaterial.kernelSize;\n    }\n    /**\r\n     * Sets the kernel size.\r\n     *\r\n     * Larger kernels require more processing power but scale well with larger\r\n     * render resolutions.\r\n     *\r\n     * @type {KernelSize}\r\n     */\n    ,\n    set: function set(value) {\n      this.convolutionMaterial.kernelSize = value;\n      this.ditheredConvolutionMaterial.kernelSize = value;\n    }\n  }], [{\n    key: \"AUTO_SIZE\",\n    get: function get() {\n      return Resizer.AUTO_SIZE;\n    }\n  }]);\n\n  return BlurPass;\n}(Pass);\n/**\r\n * A pass that disables the stencil test.\r\n */\n\n\nvar ClearMaskPass = /*#__PURE__*/function (_Pass2) {\n  _inherits(ClearMaskPass, _Pass2);\n\n  var _super13 = _createSuper(ClearMaskPass);\n\n  /**\r\n   * Constructs a new clear mask pass.\r\n   */\n  function ClearMaskPass() {\n    var _this7;\n\n    _classCallCheck(this, ClearMaskPass);\n\n    _this7 = _super13.call(this, \"ClearMaskPass\", null, null);\n    _this7.needsSwap = false;\n    return _this7;\n  }\n  /**\r\n   * Disables the global stencil test.\r\n   *\r\n   * @param {WebGLRenderer} renderer - The renderer.\r\n   * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n   * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n   * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n   * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n   */\n\n\n  _createClass(ClearMaskPass, [{\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      var stencil = renderer.state.buffers.stencil;\n      stencil.setLocked(false);\n      stencil.setTest(false);\n    }\n  }]);\n\n  return ClearMaskPass;\n}(Pass);\n/**\r\n * Stores the original clear color of the renderer.\r\n *\r\n * @type {Color}\r\n * @private\r\n */\n\n\nvar color = new Color();\n/**\r\n * A pass that clears the input buffer or the screen.\r\n */\n\nvar ClearPass = /*#__PURE__*/function (_Pass3) {\n  _inherits(ClearPass, _Pass3);\n\n  var _super14 = _createSuper(ClearPass);\n\n  /**\r\n   * Constructs a new clear pass.\r\n   *\r\n   * @param {Boolean} [color=true] - Determines whether the color buffer should be cleared.\r\n   * @param {Boolean} [depth=true] - Determines whether the depth buffer should be cleared.\r\n   * @param {Boolean} [stencil=false] - Determines whether the stencil buffer should be cleared.\r\n   */\n  function ClearPass() {\n    var _this8;\n\n    var color = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : true;\n    var depth = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n    var stencil = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : false;\n\n    _classCallCheck(this, ClearPass);\n\n    _this8 = _super14.call(this, \"ClearPass\", null, null);\n    _this8.needsSwap = false;\n    /**\r\n     * Indicates whether the color buffer should be cleared.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    _this8.color = color;\n    /**\r\n     * Indicates whether the depth buffer should be cleared.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    _this8.depth = depth;\n    /**\r\n     * Indicates whether the stencil buffer should be cleared.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    _this8.stencil = stencil;\n    /**\r\n     * An override clear color.\r\n     *\r\n     * The default value is null.\r\n     *\r\n     * @type {Color}\r\n     */\n\n    _this8.overrideClearColor = null;\n    /**\r\n     * An override clear alpha.\r\n     *\r\n     * The default value is -1.\r\n     *\r\n     * @type {Number}\r\n     */\n\n    _this8.overrideClearAlpha = -1.0;\n    return _this8;\n  }\n  /**\r\n   * Clears the input buffer or the screen.\r\n   *\r\n   * @param {WebGLRenderer} renderer - The renderer.\r\n   * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n   * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n   * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n   * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n   */\n\n\n  _createClass(ClearPass, [{\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      var overrideClearColor = this.overrideClearColor;\n      var overrideClearAlpha = this.overrideClearAlpha;\n      var clearAlpha = renderer.getClearAlpha();\n      var hasOverrideClearColor = overrideClearColor !== null;\n      var hasOverrideClearAlpha = overrideClearAlpha >= 0.0;\n\n      if (hasOverrideClearColor) {\n        color.copy(renderer.getClearColor());\n        renderer.setClearColor(overrideClearColor, hasOverrideClearAlpha ? overrideClearAlpha : clearAlpha);\n      } else if (hasOverrideClearAlpha) {\n        renderer.setClearAlpha(overrideClearAlpha);\n      }\n\n      renderer.setRenderTarget(this.renderToScreen ? null : inputBuffer);\n      renderer.clear(this.color, this.depth, this.stencil);\n\n      if (hasOverrideClearColor) {\n        renderer.setClearColor(color, clearAlpha);\n      } else if (hasOverrideClearAlpha) {\n        renderer.setClearAlpha(clearAlpha);\n      }\n    }\n  }]);\n\n  return ClearPass;\n}(Pass);\n/**\r\n * A pass that renders a given scene into the input buffer or to screen.\r\n *\r\n * This pass uses a {@link ClearPass} to clear the target buffer.\r\n */\n\n\nvar RenderPass = /*#__PURE__*/function (_Pass4) {\n  _inherits(RenderPass, _Pass4);\n\n  var _super15 = _createSuper(RenderPass);\n\n  /**\r\n   * Constructs a new render pass.\r\n   *\r\n   * @param {Scene} scene - The scene to render.\r\n   * @param {Camera} camera - The camera to use to render the scene.\r\n   * @param {Material} [overrideMaterial=null] - An override material for the scene.\r\n   */\n  function RenderPass(scene, camera) {\n    var _this9;\n\n    var overrideMaterial = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n    _classCallCheck(this, RenderPass);\n\n    _this9 = _super15.call(this, \"RenderPass\", scene, camera);\n    _this9.needsSwap = false;\n    /**\r\n     * An override material.\r\n     *\r\n     * @type {Material}\r\n     */\n\n    _this9.overrideMaterial = overrideMaterial;\n    /**\r\n     * A clear pass.\r\n     *\r\n     * @type {ClearPass}\r\n     * @private\r\n     */\n\n    _this9.clearPass = new ClearPass();\n    /**\r\n     * A depth texture.\r\n     *\r\n     * @type {DepthTexture}\r\n     * @private\r\n     */\n\n    _this9.depthTexture = null;\n    return _this9;\n  }\n  /**\r\n   * Indicates whether the target buffer should be cleared before rendering.\r\n   *\r\n   * @type {Boolean}\r\n   */\n\n\n  _createClass(RenderPass, [{\n    key: \"getClearPass\",\n\n    /**\r\n     * Returns the clear pass.\r\n     *\r\n     * @return {ClearPass} The clear pass.\r\n     */\n    value: function getClearPass() {\n      return this.clearPass;\n    }\n    /**\r\n     * Returns the current depth texture.\r\n     *\r\n     * @return {Texture} The current depth texture, or null if there is none.\r\n     */\n\n  }, {\n    key: \"getDepthTexture\",\n    value: function getDepthTexture() {\n      return this.depthTexture;\n    }\n    /**\r\n     * Sets the depth texture.\r\n     *\r\n     * The provided texture will be attached to the input buffer unless this pass\r\n     * renders to screen.\r\n     *\r\n     * @param {Texture} depthTexture - A depth texture.\r\n     * @param {Number} [depthPacking=0] - The depth packing.\r\n     */\n\n  }, {\n    key: \"setDepthTexture\",\n    value: function setDepthTexture(depthTexture) {\n      var depthPacking = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      this.depthTexture = depthTexture;\n    }\n    /**\r\n     * Renders the scene.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n     */\n\n  }, {\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      var scene = this.scene;\n      var renderTarget = this.renderToScreen ? null : inputBuffer;\n      var overrideMaterial = scene.overrideMaterial;\n\n      if (this.depthTexture !== null && !this.renderToScreen) {\n        inputBuffer.depthTexture = this.depthTexture;\n        outputBuffer.depthTexture = null;\n      }\n\n      if (this.clear) {\n        this.clearPass.renderToScreen = this.renderToScreen;\n        this.clearPass.render(renderer, inputBuffer);\n      }\n\n      scene.overrideMaterial = this.overrideMaterial;\n      renderer.setRenderTarget(renderTarget);\n      renderer.render(scene, this.camera);\n      scene.overrideMaterial = overrideMaterial;\n    }\n  }, {\n    key: \"clear\",\n    get: function get() {\n      return this.clearPass.enabled;\n    }\n    /**\r\n     * Enables or disables auto clear.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      this.clearPass.enabled = value;\n    }\n  }]);\n\n  return RenderPass;\n}(Pass);\n/**\r\n * A pass that renders the depth of a given scene into a color buffer.\r\n */\n\n\nvar DepthPass = /*#__PURE__*/function (_Pass5) {\n  _inherits(DepthPass, _Pass5);\n\n  var _super16 = _createSuper(DepthPass);\n\n  /**\r\n   * Constructs a new depth pass.\r\n   *\r\n   * @param {Scene} scene - The scene to render.\r\n   * @param {Camera} camera - The camera to use to render the scene.\r\n   * @param {Object} [options] - The options.\r\n   * @param {Number} [options.resolutionScale=1.0] - Deprecated. Adjust the height or width instead for consistent results.\r\n   * @param {Number} [options.width=Resizer.AUTO_SIZE] - The render width.\r\n   * @param {Number} [options.height=Resizer.AUTO_SIZE] - The render height.\r\n   * @param {WebGLRenderTarget} [options.renderTarget] - A custom render target.\r\n   */\n  function DepthPass(scene, camera) {\n    var _this10;\n\n    var _ref2 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n        _ref2$resolutionScale = _ref2.resolutionScale,\n        resolutionScale = _ref2$resolutionScale === void 0 ? 1.0 : _ref2$resolutionScale,\n        _ref2$width = _ref2.width,\n        width = _ref2$width === void 0 ? Resizer.AUTO_SIZE : _ref2$width,\n        _ref2$height = _ref2.height,\n        height = _ref2$height === void 0 ? Resizer.AUTO_SIZE : _ref2$height,\n        renderTarget = _ref2.renderTarget;\n\n    _classCallCheck(this, DepthPass);\n\n    _this10 = _super16.call(this, \"DepthPass\");\n    _this10.needsSwap = false;\n    /**\r\n     * A render pass.\r\n     *\r\n     * @type {RenderPass}\r\n     * @private\r\n     */\n\n    _this10.renderPass = new RenderPass(scene, camera, new MeshDepthMaterial({\n      depthPacking: RGBADepthPacking,\n      morphTargets: true,\n      skinning: true\n    }));\n\n    var clearPass = _this10.renderPass.getClearPass();\n\n    clearPass.overrideClearColor = new Color(0xffffff);\n    clearPass.overrideClearAlpha = 1.0;\n    /**\r\n     * A render target that contains the scene depth.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     */\n\n    _this10.renderTarget = renderTarget;\n\n    if (_this10.renderTarget === undefined) {\n      _this10.renderTarget = new WebGLRenderTarget(1, 1, {\n        minFilter: LinearFilter,\n        magFilter: LinearFilter,\n        stencilBuffer: false\n      });\n      _this10.renderTarget.texture.name = \"DepthPass.Target\";\n    }\n    /**\r\n     * The desired render resolution.\r\n     *\r\n     * Use {@link Resizer.AUTO_SIZE} for the width or height to automatically\r\n     * calculate it based on its counterpart and the original aspect ratio.\r\n     *\r\n     * @type {Resizer}\r\n     */\n\n\n    _this10.resolution = new Resizer(_assertThisInitialized(_this10), width, height);\n    _this10.resolution.scale = resolutionScale;\n    return _this10;\n  }\n  /**\r\n   * Returns the current resolution scale.\r\n   *\r\n   * @return {Number} The resolution scale.\r\n   * @deprecated Adjust the fixed resolution width or height instead.\r\n   */\n\n\n  _createClass(DepthPass, [{\n    key: \"getResolutionScale\",\n    value: function getResolutionScale() {\n      return this.resolutionScale;\n    }\n    /**\r\n     * Sets the resolution scale.\r\n     *\r\n     * @param {Number} scale - The new resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n\n  }, {\n    key: \"setResolutionScale\",\n    value: function setResolutionScale(scale) {\n      this.resolutionScale = scale;\n      this.setSize(this.originalSize.x, this.originalSize.y);\n    }\n    /**\r\n     * Renders the scene depth.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n     */\n\n  }, {\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      var renderTarget = this.renderToScreen ? null : this.renderTarget;\n      this.renderPass.render(renderer, renderTarget);\n    }\n    /**\r\n     * Updates the size of this pass.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      var resolution = this.resolution;\n      resolution.base.set(width, height);\n      width = resolution.width;\n      height = resolution.height;\n      this.renderTarget.setSize(width, height);\n    }\n  }]);\n\n  return DepthPass;\n}(Pass);\n/**\r\n * A blend function enumeration.\r\n *\r\n * @type {Object}\r\n * @property {Number} SKIP - No blending. The effect will not be included in the final shader.\r\n * @property {Number} ADD - Additive blending. Fast, but may produce washed out results.\r\n * @property {Number} ALPHA - Alpha blending. Blends based on the alpha value of the new color.\r\n * @property {Number} AVERAGE - Average blending.\r\n * @property {Number} COLOR_BURN - Color burn.\r\n * @property {Number} COLOR_DODGE - Color dodge.\r\n * @property {Number} DARKEN - Prioritize darker colors.\r\n * @property {Number} DIFFERENCE - Color difference.\r\n * @property {Number} EXCLUSION - Color exclusion.\r\n * @property {Number} LIGHTEN - Prioritize lighter colors.\r\n * @property {Number} MULTIPLY - Color multiplication.\r\n * @property {Number} DIVIDE - Color division.\r\n * @property {Number} NEGATION - Color negation.\r\n * @property {Number} NORMAL - Normal blending. The new color overwrites the old one.\r\n * @property {Number} OVERLAY - Color overlay.\r\n * @property {Number} REFLECT - Color reflection.\r\n * @property {Number} SCREEN - Screen blending. The two colors are effectively projected on a white screen simultaneously.\r\n * @property {Number} SOFT_LIGHT - Soft light blending.\r\n * @property {Number} SUBTRACT - Color subtraction.\r\n */\n\n\nvar BlendFunction = {\n  SKIP: 0,\n  ADD: 1,\n  ALPHA: 2,\n  AVERAGE: 3,\n  COLOR_BURN: 4,\n  COLOR_DODGE: 5,\n  DARKEN: 6,\n  DIFFERENCE: 7,\n  EXCLUSION: 8,\n  LIGHTEN: 9,\n  MULTIPLY: 10,\n  DIVIDE: 11,\n  NEGATION: 12,\n  NORMAL: 13,\n  OVERLAY: 14,\n  REFLECT: 15,\n  SCREEN: 16,\n  SOFT_LIGHT: 17,\n  SUBTRACT: 18\n};\nvar addBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return min(x+y,1.0)*opacity+x*(1.0-opacity);}\";\nvar alphaBlendFunction = \"vec3 blend(const in vec3 x,const in vec3 y,const in float opacity){return y*opacity+x*(1.0-opacity);}vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){float a=min(y.a,opacity);return vec4(blend(x.rgb,y.rgb,a),max(x.a,a));}\";\nvar averageBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return(x+y)*0.5*opacity+x*(1.0-opacity);}\";\nvar colorBurnBlendFunction = \"float blend(const in float x,const in float y){return(y==0.0)? y : max(1.0-(1.0-x)/y,0.0);}vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){vec4 z=vec4(blend(x.r,y.r),blend(x.g,y.g),blend(x.b,y.b),blend(x.a,y.a));return z*opacity+x*(1.0-opacity);}\";\nvar colorDodgeBlendFunction = \"float blend(const in float x,const in float y){return(y==1.0)? y : min(x/(1.0-y),1.0);}vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){vec4 z=vec4(blend(x.r,y.r),blend(x.g,y.g),blend(x.b,y.b),blend(x.a,y.a));return z*opacity+x*(1.0-opacity);}\";\nvar darkenBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return min(x,y)*opacity+x*(1.0-opacity);}\";\nvar differenceBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return abs(x-y)*opacity+x*(1.0-opacity);}\";\nvar exclusionBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return(x+y-2.0*x*y)*opacity+x*(1.0-opacity);}\";\nvar lightenBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return max(x,y)*opacity+x*(1.0-opacity);}\";\nvar multiplyBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return x*y*opacity+x*(1.0-opacity);}\";\nvar divideBlendFunction = \"float blend(const in float x,const in float y){return(y>0.0)? min(x/y,1.0): 1.0;}vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){vec4 z=vec4(blend(x.r,y.r),blend(x.g,y.g),blend(x.b,y.b),blend(x.a,y.a));return z*opacity+x*(1.0-opacity);}\";\nvar negationBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return(1.0-abs(1.0-x-y))*opacity+x*(1.0-opacity);}\";\nvar normalBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return y*opacity+x*(1.0-opacity);}\";\nvar overlayBlendFunction = \"float blend(const in float x,const in float y){return(x<0.5)?(2.0*x*y):(1.0-2.0*(1.0-x)*(1.0-y));}vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){vec4 z=vec4(blend(x.r,y.r),blend(x.g,y.g),blend(x.b,y.b),blend(x.a,y.a));return z*opacity+x*(1.0-opacity);}\";\nvar reflectBlendFunction = \"float blend(const in float x,const in float y){return(y==1.0)? y : min(x*x/(1.0-y),1.0);}vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){vec4 z=vec4(blend(x.r,y.r),blend(x.g,y.g),blend(x.b,y.b),blend(x.a,y.a));return z*opacity+x*(1.0-opacity);}\";\nvar screenBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return(1.0-(1.0-x)*(1.0-y))*opacity+x*(1.0-opacity);}\";\nvar softLightBlendFunction = \"float blend(const in float x,const in float y){return(y<0.5)?(2.0*x*y+x*x*(1.0-2.0*y)):(sqrt(x)*(2.0*y-1.0)+2.0*x*(1.0-y));}vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){vec4 z=vec4(blend(x.r,y.r),blend(x.g,y.g),blend(x.b,y.b),blend(x.a,y.a));return z*opacity+x*(1.0-opacity);}\";\nvar subtractBlendFunction = \"vec4 blend(const in vec4 x,const in vec4 y,const in float opacity){return max(x+y-1.0,0.0)*opacity+x*(1.0-opacity);}\";\n/**\r\n * A blend function shader code catalogue.\r\n *\r\n * @type {Map<BlendFunction, String>}\r\n * @private\r\n */\n\nvar blendFunctions = new Map([[BlendFunction.SKIP, null], [BlendFunction.ADD, addBlendFunction], [BlendFunction.ALPHA, alphaBlendFunction], [BlendFunction.AVERAGE, averageBlendFunction], [BlendFunction.COLOR_BURN, colorBurnBlendFunction], [BlendFunction.COLOR_DODGE, colorDodgeBlendFunction], [BlendFunction.DARKEN, darkenBlendFunction], [BlendFunction.DIFFERENCE, differenceBlendFunction], [BlendFunction.EXCLUSION, exclusionBlendFunction], [BlendFunction.LIGHTEN, lightenBlendFunction], [BlendFunction.MULTIPLY, multiplyBlendFunction], [BlendFunction.DIVIDE, divideBlendFunction], [BlendFunction.NEGATION, negationBlendFunction], [BlendFunction.NORMAL, normalBlendFunction], [BlendFunction.OVERLAY, overlayBlendFunction], [BlendFunction.REFLECT, reflectBlendFunction], [BlendFunction.SCREEN, screenBlendFunction], [BlendFunction.SOFT_LIGHT, softLightBlendFunction], [BlendFunction.SUBTRACT, subtractBlendFunction]]);\n/**\r\n * A blend mode.\r\n */\n\nvar BlendMode = /*#__PURE__*/function () {\n  /**\r\n   * Constructs a new blend mode.\r\n   *\r\n   * @param {BlendFunction} blendFunction - The blend function to use.\r\n   * @param {Number} opacity - The opacity of the color that will be blended with the base color.\r\n   */\n  function BlendMode(blendFunction) {\n    var opacity = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 1.0;\n\n    _classCallCheck(this, BlendMode);\n\n    /**\r\n     * The blend function.\r\n     *\r\n     * @type {BlendFunction}\r\n     */\n    this.blendFunction = blendFunction;\n    /**\r\n     * The opacity of the color that will be blended with the base color.\r\n     *\r\n     * @type {Uniform}\r\n     */\n\n    this.opacity = new Uniform(opacity);\n  }\n  /**\r\n   * Returns the blend function shader code.\r\n   *\r\n   * @return {String} The blend function shader code.\r\n   */\n\n\n  _createClass(BlendMode, [{\n    key: \"getShaderCode\",\n    value: function getShaderCode() {\n      return blendFunctions.get(this.blendFunction);\n    }\n  }]);\n\n  return BlendMode;\n}();\n/**\r\n * An abstract effect.\r\n *\r\n * Effects can be combined using the {@link EffectPass}.\r\n *\r\n * @implements {Initializable}\r\n * @implements {Resizable}\r\n * @implements {Disposable}\r\n */\n\n\nvar Effect = /*#__PURE__*/function () {\n  /**\r\n   * Constructs a new effect.\r\n   *\r\n   * @param {String} name - The name of this effect. Doesn't have to be unique.\r\n   * @param {String} fragmentShader - The fragment shader. This shader is required.\r\n   * @param {Object} [options] - Additional options.\r\n   * @param {EffectAttribute} [options.attributes=EffectAttribute.NONE] - The effect attributes that determine the execution priority and resource requirements.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function of this effect.\r\n   * @param {Map<String, String>} [options.defines] - Custom preprocessor macro definitions. Keys are names and values are code.\r\n   * @param {Map<String, Uniform>} [options.uniforms] - Custom shader uniforms. Keys are names and values are uniforms.\r\n   * @param {Set<WebGLExtension>} [options.extensions] - WebGL extensions.\r\n   * @param {String} [options.vertexShader=null] - The vertex shader. Most effects don't need one.\r\n   */\n  function Effect(name, fragmentShader) {\n    var _ref3 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n        _ref3$attributes = _ref3.attributes,\n        attributes = _ref3$attributes === void 0 ? EffectAttribute.NONE : _ref3$attributes,\n        _ref3$blendFunction = _ref3.blendFunction,\n        blendFunction = _ref3$blendFunction === void 0 ? BlendFunction.SCREEN : _ref3$blendFunction,\n        _ref3$defines = _ref3.defines,\n        defines = _ref3$defines === void 0 ? new Map() : _ref3$defines,\n        _ref3$uniforms = _ref3.uniforms,\n        uniforms = _ref3$uniforms === void 0 ? new Map() : _ref3$uniforms,\n        _ref3$extensions = _ref3.extensions,\n        extensions = _ref3$extensions === void 0 ? null : _ref3$extensions,\n        _ref3$vertexShader = _ref3.vertexShader,\n        vertexShader = _ref3$vertexShader === void 0 ? null : _ref3$vertexShader;\n\n    _classCallCheck(this, Effect);\n\n    /**\r\n     * The name of this effect.\r\n     *\r\n     * @type {String}\r\n     */\n    this.name = name;\n    /**\r\n     * The effect attributes.\r\n     *\r\n     * Effects that have the same attributes will be executed in the order in\r\n     * which they were registered. Some attributes imply a higher priority.\r\n     *\r\n     * @type {EffectAttribute}\r\n     */\n\n    this.attributes = attributes;\n    /**\r\n     * The fragment shader.\r\n     *\r\n     * @type {String}\r\n     */\n\n    this.fragmentShader = fragmentShader;\n    /**\r\n     * The vertex shader.\r\n     *\r\n     * @type {String}\r\n     */\n\n    this.vertexShader = vertexShader;\n    /**\r\n     * Preprocessor macro definitions.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing a macro.\r\n     *\r\n     * @type {Map<String, String>}\r\n     */\n\n    this.defines = defines;\n    /**\r\n     * Shader uniforms.\r\n     *\r\n     * You may freely modify the values of these uniforms at runtime. However,\r\n     * uniforms must not be removed or added after the effect was created.\r\n     *\r\n     * @type {Map<String, Uniform>}\r\n     */\n\n    this.uniforms = uniforms;\n    /**\r\n     * WebGL extensions that are required by this effect.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after adding or removing\r\n     * an extension.\r\n     *\r\n     * @type {Set<WebGLExtension>}\r\n     */\n\n    this.extensions = extensions;\n    /**\r\n     * The blend mode of this effect.\r\n     *\r\n     * The result of this effect will be blended with the result of the previous\r\n     * effect using this blend mode.\r\n     *\r\n     * Feel free to adjust the opacity of the blend mode at runtime. However,\r\n     * you'll need to call {@link EffectPass#recompile} if you change the blend\r\n     * function.\r\n     *\r\n     * @type {BlendMode}\r\n     */\n\n    this.blendMode = new BlendMode(blendFunction);\n  }\n  /**\r\n   * Sets the depth texture.\r\n   *\r\n   * You may override this method if your effect requires direct access to the\r\n   * depth texture that is bound to the associated {@link EffectPass}.\r\n   *\r\n   * @param {Texture} depthTexture - A depth texture.\r\n   * @param {Number} [depthPacking=0] - The depth packing.\r\n   */\n\n\n  _createClass(Effect, [{\n    key: \"setDepthTexture\",\n    value: function setDepthTexture(depthTexture) {\n      var depthPacking = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n    }\n    /**\r\n     * Updates the effect by performing supporting operations.\r\n     *\r\n     * This method is called by the {@link EffectPass} right before the main\r\n     * fullscreen render operation, even if the blend function is set to `SKIP`.\r\n     *\r\n     * You may override this method if you need to render additional off-screen\r\n     * textures or update custom uniforms.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     */\n\n  }, {\n    key: \"update\",\n    value: function update(renderer, inputBuffer, deltaTime) {}\n    /**\r\n     * Updates the size of this effect.\r\n     *\r\n     * You may override this method in case you want to be informed about the main\r\n     * render size.\r\n     *\r\n     * The {@link EffectPass} calls this method before this effect is initialized\r\n     * and every time its own size is updated.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     * @example this.myRenderTarget.setSize(width, height);\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {}\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * By overriding this method you gain access to the renderer. You'll also be\r\n     * able to configure your custom render targets to use the appropriate format\r\n     * (RGB or RGBA).\r\n     *\r\n     * The provided renderer can be used to warm up special off-screen render\r\n     * targets by performing a preliminary render operation.\r\n     *\r\n     * The {@link EffectPass} calls this method during its own initialization\r\n     * which happens after the size has been set.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     * @example if(!alpha) { this.myRenderTarget.texture.format = RGBFormat; }\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {}\n    /**\r\n     * Performs a shallow search for properties that define a dispose method and\r\n     * deletes them. The effect will be inoperative after this method was called!\r\n     *\r\n     * Disposable objects:\r\n     *  - render targets\r\n     *  - materials\r\n     *  - textures\r\n     *\r\n     * The {@link EffectPass} calls this method when it is being destroyed. Do not\r\n     * call this method directly.\r\n     */\n\n  }, {\n    key: \"dispose\",\n    value: function dispose() {\n      for (var _i2 = 0, _Object$keys2 = Object.keys(this); _i2 < _Object$keys2.length; _i2++) {\n        var key = _Object$keys2[_i2];\n\n        if (this[key] !== null && typeof this[key].dispose === \"function\") {\n          /** @ignore */\n          this[key].dispose();\n        }\n      }\n    }\n  }]);\n\n  return Effect;\n}();\n/**\r\n * An enumeration of effect attributes.\r\n *\r\n * Attributes can be concatenated using the bitwise OR operator.\r\n *\r\n * @type {Object}\r\n * @property {Number} CONVOLUTION - Describes effects that fetch additional samples from the input buffer. There cannot be more than one effect with this attribute per {@link EffectPass}.\r\n * @property {Number} DEPTH - Describes effects that require a depth texture.\r\n * @property {Number} NONE - No attributes. Most effects don't need to specify any attributes.\r\n * @example\r\n * const attributes = EffectAttribute.CONVOLUTION | EffectAttribute.DEPTH;\r\n */\n\n\nvar EffectAttribute = {\n  CONVOLUTION: 2,\n  DEPTH: 1,\n  NONE: 0\n};\n/**\r\n * An enumeration of WebGL extensions.\r\n *\r\n * @type {Object}\r\n * @property {String} DERIVATIVES - Enables derivatives by adding the functions dFdx, dFdy and fwidth.\r\n * @property {String} FRAG_DEPTH - Enables gl_FragDepthEXT to set a depth value of a fragment from within the fragment shader.\r\n * @property {String} DRAW_BUFFERS - Enables multiple render targets (MRT) support.\r\n * @property {String} SHADER_TEXTURE_LOD - Enables explicit control of texture LOD.\r\n */\n\nvar WebGLExtension = {\n  DERIVATIVES: \"derivatives\",\n  FRAG_DEPTH: \"fragDepth\",\n  DRAW_BUFFERS: \"drawBuffers\",\n  SHADER_TEXTURE_LOD: \"shaderTextureLOD\"\n};\n/**\r\n * Finds and collects substrings that match the given regular expression.\r\n *\r\n * @private\r\n * @param {RegExp} regExp - A regular expression.\r\n * @param {String} string - A string.\r\n * @return {String[]} The matching substrings.\r\n */\n\nfunction findSubstrings(regExp, string) {\n  var substrings = [];\n  var result;\n\n  while ((result = regExp.exec(string)) !== null) {\n    substrings.push(result[1]);\n  }\n\n  return substrings;\n}\n/**\r\n * Prefixes substrings within the given strings.\r\n *\r\n * @private\r\n * @param {String} prefix - A prefix.\r\n * @param {String[]} substrings - The substrings.\r\n * @param {Map<String, String>} strings - A collection of named strings.\r\n */\n\n\nfunction prefixSubstrings(prefix, substrings, strings) {\n  var prefixed, regExp;\n\n  var _iterator3 = _createForOfIteratorHelper(substrings),\n      _step3;\n\n  try {\n    for (_iterator3.s(); !(_step3 = _iterator3.n()).done;) {\n      var substring = _step3.value;\n      prefixed = \"$1\" + prefix + substring.charAt(0).toUpperCase() + substring.slice(1);\n      regExp = new RegExp(\"([^\\\\.])(\\\\b\" + substring + \"\\\\b)\", \"g\");\n\n      var _iterator4 = _createForOfIteratorHelper(strings.entries()),\n          _step4;\n\n      try {\n        for (_iterator4.s(); !(_step4 = _iterator4.n()).done;) {\n          var entry = _step4.value;\n\n          if (entry[1] !== null) {\n            strings.set(entry[0], entry[1].replace(regExp, prefixed));\n          }\n        }\n      } catch (err) {\n        _iterator4.e(err);\n      } finally {\n        _iterator4.f();\n      }\n    }\n  } catch (err) {\n    _iterator3.e(err);\n  } finally {\n    _iterator3.f();\n  }\n}\n/**\r\n * Integrates the given effect.\r\n *\r\n * @private\r\n * @param {String} prefix - A prefix.\r\n * @param {Effect} effect - An effect.\r\n * @param {Map<String, String>} shaderParts - The shader parts.\r\n * @param {Map<BlendFunction, BlendMode>} blendModes - The blend modes.\r\n * @param {Map<String, String>} defines - The macro definitions.\r\n * @param {Map<String, Uniform>} uniforms - The uniforms.\r\n * @param {EffectAttribute} attributes - The global, collective attributes.\r\n * @return {Object} The results.\r\n * @property {String[]} varyings - The varyings used by the given effect.\r\n * @property {Boolean} transformedUv - Indicates whether the effect transforms UV coordinates in the fragment shader.\r\n * @property {Boolean} readDepth - Indicates whether the effect actually uses depth in the fragment shader.\r\n */\n\n\nfunction integrateEffect(prefix, effect, shaderParts, blendModes, defines, uniforms, attributes) {\n  var functionRegExp = /(?:\\w+\\s+(\\w+)\\([\\w\\s,]*\\)\\s*{[^}]+})/g;\n  var varyingRegExp = /(?:varying\\s+\\w+\\s+(\\w*))/g;\n  var blendMode = effect.blendMode;\n  var shaders = new Map([[\"fragment\", effect.fragmentShader], [\"vertex\", effect.vertexShader]]);\n  var mainImageExists = shaders.get(\"fragment\") !== undefined && shaders.get(\"fragment\").indexOf(\"mainImage\") >= 0;\n  var mainUvExists = shaders.get(\"fragment\") !== undefined && shaders.get(\"fragment\").indexOf(\"mainUv\") >= 0;\n  var varyings = [],\n      names = [];\n  var transformedUv = false;\n  var readDepth = false;\n\n  if (shaders.get(\"fragment\") === undefined) {\n    console.error(\"Missing fragment shader\", effect);\n  } else if (mainUvExists && (attributes & EffectAttribute.CONVOLUTION) !== 0) {\n    console.error(\"Effects that transform UV coordinates are incompatible with convolution effects\", effect);\n  } else if (!mainImageExists && !mainUvExists) {\n    console.error(\"The fragment shader contains neither a mainImage nor a mainUv function\", effect);\n  } else {\n    if (mainUvExists) {\n      shaderParts.set(Section.FRAGMENT_MAIN_UV, shaderParts.get(Section.FRAGMENT_MAIN_UV) + \"\\t\" + prefix + \"MainUv(UV);\\n\");\n      transformedUv = true;\n    }\n\n    if (shaders.get(\"vertex\") !== null && shaders.get(\"vertex\").indexOf(\"mainSupport\") >= 0) {\n      var string = \"\\t\" + prefix + \"MainSupport(\"; // Check if the vertex shader expects uv coordinates.\n\n      if (shaders.get(\"vertex\").indexOf(\"uv\") >= 0) {\n        string += \"vUv\";\n      }\n\n      string += \");\\n\";\n      shaderParts.set(Section.VERTEX_MAIN_SUPPORT, shaderParts.get(Section.VERTEX_MAIN_SUPPORT) + string);\n      varyings = varyings.concat(findSubstrings(varyingRegExp, shaders.get(\"vertex\")));\n      names = names.concat(varyings).concat(findSubstrings(functionRegExp, shaders.get(\"vertex\")));\n    }\n\n    names = names.concat(findSubstrings(functionRegExp, shaders.get(\"fragment\"))).concat(Array.from(effect.uniforms.keys())).concat(Array.from(effect.defines.keys())); // Store prefixed uniforms and macros.\n\n    effect.uniforms.forEach(function (value, key) {\n      return uniforms.set(prefix + key.charAt(0).toUpperCase() + key.slice(1), value);\n    });\n    effect.defines.forEach(function (value, key) {\n      return defines.set(prefix + key.charAt(0).toUpperCase() + key.slice(1), value);\n    }); // Prefix varyings, functions, uniforms and macros.\n\n    prefixSubstrings(prefix, names, defines);\n    prefixSubstrings(prefix, names, shaders); // Collect unique blend modes.\n\n    blendModes.set(blendMode.blendFunction, blendMode);\n\n    if (mainImageExists) {\n      var _string = prefix + \"MainImage(color0, UV, \"; // The effect may sample depth in a different shader.\n\n\n      if ((attributes & EffectAttribute.DEPTH) !== 0 && shaders.get(\"fragment\").indexOf(\"depth\") >= 0) {\n        _string += \"depth, \";\n        readDepth = true;\n      }\n\n      _string += \"color1);\\n\\t\"; // Include the blend opacity uniform of this effect.\n\n      var blendOpacity = prefix + \"BlendOpacity\";\n      uniforms.set(blendOpacity, blendMode.opacity); // Blend the result of this effect with the input color.\n\n      _string += \"color0 = blend\" + blendMode.blendFunction + \"(color0, color1, \" + blendOpacity + \");\\n\\n\\t\";\n      shaderParts.set(Section.FRAGMENT_MAIN_IMAGE, shaderParts.get(Section.FRAGMENT_MAIN_IMAGE) + _string);\n      shaderParts.set(Section.FRAGMENT_HEAD, shaderParts.get(Section.FRAGMENT_HEAD) + \"uniform float \" + blendOpacity + \";\\n\\n\");\n    } // Include the modified code in the final shader.\n\n\n    shaderParts.set(Section.FRAGMENT_HEAD, shaderParts.get(Section.FRAGMENT_HEAD) + shaders.get(\"fragment\") + \"\\n\");\n\n    if (shaders.get(\"vertex\") !== null) {\n      shaderParts.set(Section.VERTEX_HEAD, shaderParts.get(Section.VERTEX_HEAD) + shaders.get(\"vertex\") + \"\\n\");\n    }\n  }\n\n  return {\n    varyings: varyings,\n    transformedUv: transformedUv,\n    readDepth: readDepth\n  };\n}\n/**\r\n * An effect pass.\r\n *\r\n * Use this pass to combine {@link Effect} instances.\r\n */\n\n\nvar EffectPass = /*#__PURE__*/function (_Pass6) {\n  _inherits(EffectPass, _Pass6);\n\n  var _super17 = _createSuper(EffectPass);\n\n  /**\r\n   * Constructs a new effect pass.\r\n   *\r\n   * The provided effects will be organized and merged for optimal performance.\r\n   *\r\n   * @param {Camera} camera - The main camera. The camera's type and settings will be available to all effects.\r\n   * @param {...Effect} effects - The effects that will be rendered by this pass.\r\n   */\n  function EffectPass(camera) {\n    var _this11;\n\n    _classCallCheck(this, EffectPass);\n\n    _this11 = _super17.call(this, \"EffectPass\");\n\n    _this11.setFullscreenMaterial(new EffectMaterial(null, null, null, camera));\n    /**\r\n     * The effects, sorted by attribute priority, DESC.\r\n     *\r\n     * @type {Effect[]}\r\n     * @private\r\n     */\n\n\n    for (var _len = arguments.length, effects = new Array(_len > 1 ? _len - 1 : 0), _key = 1; _key < _len; _key++) {\n      effects[_key - 1] = arguments[_key];\n    }\n\n    _this11.effects = effects.sort(function (a, b) {\n      return b.attributes - a.attributes;\n    });\n    /**\r\n     * Indicates whether this pass should skip rendering.\r\n     *\r\n     * Effects will still be updated, even if this flag is true.\r\n     *\r\n     * @type {Boolean}\r\n     * @private\r\n     */\n\n    _this11.skipRendering = false;\n    /**\r\n     * The amount of shader uniforms that this pass uses.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this11.uniforms = 0;\n    /**\r\n     * The amount of shader varyings that this pass uses.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this11.varyings = 0;\n    /**\r\n     * A time offset.\r\n     *\r\n     * Elapsed time will start at this value.\r\n     *\r\n     * @type {Number}\r\n     */\n\n    _this11.minTime = 1.0;\n    /**\r\n     * The maximum time.\r\n     *\r\n     * If the elapsed time exceeds this value, it will be reset.\r\n     *\r\n     * @type {Number}\r\n     */\n\n    _this11.maxTime = 1e3;\n    return _this11;\n  }\n  /**\r\n   * The current render size.\r\n   *\r\n   * @type {Vector2}\r\n   * @private\r\n   */\n\n\n  _createClass(EffectPass, [{\n    key: \"updateMaterial\",\n\n    /**\r\n     * Updates the compound shader material.\r\n     *\r\n     * @private\r\n     */\n    value: function updateMaterial() {\n      var blendRegExp = /\\bblend\\b/g;\n      var shaderParts = new Map([[Section.FRAGMENT_HEAD, \"\"], [Section.FRAGMENT_MAIN_UV, \"\"], [Section.FRAGMENT_MAIN_IMAGE, \"\"], [Section.VERTEX_HEAD, \"\"], [Section.VERTEX_MAIN_SUPPORT, \"\"]]);\n      var blendModes = new Map();\n      var defines = new Map();\n      var uniforms = new Map();\n      var extensions = new Set();\n      var id = 0,\n          varyings = 0,\n          attributes = 0;\n      var transformedUv = false;\n      var readDepth = false;\n      var result;\n\n      var _iterator5 = _createForOfIteratorHelper(this.effects),\n          _step5;\n\n      try {\n        for (_iterator5.s(); !(_step5 = _iterator5.n()).done;) {\n          var effect = _step5.value;\n\n          if (effect.blendMode.blendFunction === BlendFunction.SKIP) {\n            // Check if this effect relies on depth and then continue.\n            attributes |= effect.attributes & EffectAttribute.DEPTH;\n          } else if ((attributes & EffectAttribute.CONVOLUTION) !== 0 && (effect.attributes & EffectAttribute.CONVOLUTION) !== 0) {\n            console.error(\"Convolution effects cannot be merged\", effect);\n          } else {\n            attributes |= effect.attributes;\n            result = integrateEffect(\"e\" + id++, effect, shaderParts, blendModes, defines, uniforms, attributes);\n            varyings += result.varyings.length;\n            transformedUv = transformedUv || result.transformedUv;\n            readDepth = readDepth || result.readDepth;\n\n            if (effect.extensions !== null) {\n              // Collect the WebGL extensions that are required by this effect.\n              var _iterator8 = _createForOfIteratorHelper(effect.extensions),\n                  _step8;\n\n              try {\n                for (_iterator8.s(); !(_step8 = _iterator8.n()).done;) {\n                  var _extension = _step8.value;\n                  extensions.add(_extension);\n                }\n              } catch (err) {\n                _iterator8.e(err);\n              } finally {\n                _iterator8.f();\n              }\n            }\n          }\n        } // Integrate the relevant blend functions.\n\n      } catch (err) {\n        _iterator5.e(err);\n      } finally {\n        _iterator5.f();\n      }\n\n      var _iterator6 = _createForOfIteratorHelper(blendModes.values()),\n          _step6;\n\n      try {\n        for (_iterator6.s(); !(_step6 = _iterator6.n()).done;) {\n          var blendMode = _step6.value;\n          shaderParts.set(Section.FRAGMENT_HEAD, shaderParts.get(Section.FRAGMENT_HEAD) + blendMode.getShaderCode().replace(blendRegExp, \"blend\" + blendMode.blendFunction) + \"\\n\");\n        } // Check if any effect relies on depth.\n\n      } catch (err) {\n        _iterator6.e(err);\n      } finally {\n        _iterator6.f();\n      }\n\n      if ((attributes & EffectAttribute.DEPTH) !== 0) {\n        // Only read depth if any effect actually uses this information.\n        if (readDepth) {\n          shaderParts.set(Section.FRAGMENT_MAIN_IMAGE, \"float depth = readDepth(UV);\\n\\n\\t\" + shaderParts.get(Section.FRAGMENT_MAIN_IMAGE));\n        } // Only request a depth texture if none has been provided yet.\n\n\n        this.needsDepthTexture = this.getDepthTexture() === null;\n      } // Check if any effect transforms UVs in the fragment shader.\n\n\n      if (transformedUv) {\n        shaderParts.set(Section.FRAGMENT_MAIN_UV, \"vec2 transformedUv = vUv;\\n\" + shaderParts.get(Section.FRAGMENT_MAIN_UV));\n        defines.set(\"UV\", \"transformedUv\");\n      } else {\n        defines.set(\"UV\", \"vUv\");\n      }\n\n      shaderParts.forEach(function (value, key, map) {\n        return map.set(key, value.trim());\n      });\n      this.uniforms = uniforms.size;\n      this.varyings = varyings;\n      this.skipRendering = id === 0;\n      this.needsSwap = !this.skipRendering;\n      var material = this.getFullscreenMaterial();\n      material.setShaderParts(shaderParts).setDefines(defines).setUniforms(uniforms);\n      material.extensions = {};\n\n      if (extensions.size > 0) {\n        // Enable required WebGL extensions.\n        var _iterator7 = _createForOfIteratorHelper(extensions),\n            _step7;\n\n        try {\n          for (_iterator7.s(); !(_step7 = _iterator7.n()).done;) {\n            var extension = _step7.value;\n            material.extensions[extension] = true;\n          }\n        } catch (err) {\n          _iterator7.e(err);\n        } finally {\n          _iterator7.f();\n        }\n      }\n    }\n    /**\r\n     * Updates the shader material.\r\n     *\r\n     * Warning: This method triggers a relatively expensive shader recompilation.\r\n     */\n\n  }, {\n    key: \"recompile\",\n    value: function recompile() {\n      this.updateMaterial();\n    }\n    /**\r\n     * Returns the current depth texture.\r\n     *\r\n     * @return {Texture} The current depth texture, or null if there is none.\r\n     */\n\n  }, {\n    key: \"getDepthTexture\",\n    value: function getDepthTexture() {\n      return this.getFullscreenMaterial().uniforms.depthBuffer.value;\n    }\n    /**\r\n     * Sets the depth texture.\r\n     *\r\n     * @param {Texture} depthTexture - A depth texture.\r\n     * @param {Number} [depthPacking=0] - The depth packing.\r\n     */\n\n  }, {\n    key: \"setDepthTexture\",\n    value: function setDepthTexture(depthTexture) {\n      var depthPacking = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      var material = this.getFullscreenMaterial();\n      material.uniforms.depthBuffer.value = depthTexture;\n      material.depthPacking = depthPacking;\n      material.needsUpdate = true;\n\n      var _iterator9 = _createForOfIteratorHelper(this.effects),\n          _step9;\n\n      try {\n        for (_iterator9.s(); !(_step9 = _iterator9.n()).done;) {\n          var effect = _step9.value;\n          effect.setDepthTexture(depthTexture, depthPacking);\n        }\n      } catch (err) {\n        _iterator9.e(err);\n      } finally {\n        _iterator9.f();\n      }\n    }\n    /**\r\n     * Renders the effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n     */\n\n  }, {\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      var material = this.getFullscreenMaterial();\n      var time = material.uniforms.time.value + deltaTime;\n\n      var _iterator10 = _createForOfIteratorHelper(this.effects),\n          _step10;\n\n      try {\n        for (_iterator10.s(); !(_step10 = _iterator10.n()).done;) {\n          var effect = _step10.value;\n          effect.update(renderer, inputBuffer, deltaTime);\n        }\n      } catch (err) {\n        _iterator10.e(err);\n      } finally {\n        _iterator10.f();\n      }\n\n      if (!this.skipRendering || this.renderToScreen) {\n        material.uniforms.inputBuffer.value = inputBuffer.texture;\n        material.uniforms.time.value = time <= this.maxTime ? time : this.minTime;\n        renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);\n        renderer.render(this.scene, this.camera);\n      }\n    }\n    /**\r\n     * Updates the size of this pass.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.getFullscreenMaterial().setSize(width, height);\n\n      var _iterator11 = _createForOfIteratorHelper(this.effects),\n          _step11;\n\n      try {\n        for (_iterator11.s(); !(_step11 = _iterator11.n()).done;) {\n          var effect = _step11.value;\n          effect.setSize(width, height);\n        }\n      } catch (err) {\n        _iterator11.e(err);\n      } finally {\n        _iterator11.f();\n      }\n    }\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {\n      // Initialize effects before building the final shader.\n      var _iterator12 = _createForOfIteratorHelper(this.effects),\n          _step12;\n\n      try {\n        for (_iterator12.s(); !(_step12 = _iterator12.n()).done;) {\n          var effect = _step12.value;\n          effect.initialize(renderer, alpha);\n        } // Initialize the fullscreen material.\n\n      } catch (err) {\n        _iterator12.e(err);\n      } finally {\n        _iterator12.f();\n      }\n\n      this.updateMaterial(); // Compare required resources with capabilities.\n\n      var capabilities = renderer.capabilities;\n      var max = Math.min(capabilities.maxFragmentUniforms, capabilities.maxVertexUniforms);\n\n      if (this.uniforms > max) {\n        console.warn(\"The current rendering context doesn't support more than \" + max + \" uniforms, but \" + this.uniforms + \" were defined\");\n      }\n\n      max = capabilities.maxVaryings;\n\n      if (this.varyings > max) {\n        console.warn(\"The current rendering context doesn't support more than \" + max + \" varyings, but \" + this.varyings + \" were defined\");\n      }\n    }\n    /**\r\n     * Deletes disposable objects.\r\n     *\r\n     * This pass will be inoperative after this method was called!\r\n     */\n\n  }, {\n    key: \"dispose\",\n    value: function dispose() {\n      _get(_getPrototypeOf(EffectPass.prototype), \"dispose\", this).call(this);\n\n      var _iterator13 = _createForOfIteratorHelper(this.effects),\n          _step13;\n\n      try {\n        for (_iterator13.s(); !(_step13 = _iterator13.n()).done;) {\n          var effect = _step13.value;\n          effect.dispose();\n        }\n      } catch (err) {\n        _iterator13.e(err);\n      } finally {\n        _iterator13.f();\n      }\n    }\n  }, {\n    key: \"size\",\n    get: function get() {\n      return this.getFullscreenMaterial().uniforms.resolution.value;\n    }\n    /**\r\n     * Indicates whether dithering is enabled.\r\n     *\r\n     * Color quantization reduces banding artifacts but degrades performance.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"dithering\",\n    get: function get() {\n      return this.getFullscreenMaterial().dithering;\n    }\n    /**\r\n     * Enables or disables dithering.\r\n     *\r\n     * Note that some effects have their own dithering setting.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      var material = this.getFullscreenMaterial();\n\n      if (material.dithering !== value) {\n        material.dithering = value;\n        material.needsUpdate = true;\n      }\n    }\n  }]);\n\n  return EffectPass;\n}(Pass);\n/**\r\n * A mask pass.\r\n *\r\n * This pass requires that the input and output buffers have a stencil buffer.\r\n * You can enable the stencil buffer via the {@link EffectComposer} constructor.\r\n */\n\n\nvar MaskPass = /*#__PURE__*/function (_Pass7) {\n  _inherits(MaskPass, _Pass7);\n\n  var _super18 = _createSuper(MaskPass);\n\n  /**\r\n   * Constructs a new mask pass.\r\n   *\r\n   * @param {Scene} scene - The scene to render.\r\n   * @param {Camera} camera - The camera to use.\r\n   */\n  function MaskPass(scene, camera) {\n    var _this12;\n\n    _classCallCheck(this, MaskPass);\n\n    _this12 = _super18.call(this, \"MaskPass\", scene, camera);\n    _this12.needsSwap = false;\n    /**\r\n     * A clear pass.\r\n     *\r\n     * @type {ClearPass}\r\n     * @private\r\n     */\n\n    _this12.clearPass = new ClearPass(false, false, true);\n    /**\r\n     * Inverse flag.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    _this12.inverse = false;\n    return _this12;\n  }\n  /**\r\n   * Indicates whether this pass should clear the stencil buffer.\r\n   *\r\n   * @type {Boolean}\r\n   */\n\n\n  _createClass(MaskPass, [{\n    key: \"render\",\n\n    /**\r\n     * Renders the effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n     */\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      var context = renderer.getContext();\n      var buffers = renderer.state.buffers;\n      var scene = this.scene;\n      var camera = this.camera;\n      var clearPass = this.clearPass;\n      var writeValue = this.inverse ? 0 : 1;\n      var clearValue = 1 - writeValue; // Don't update color or depth.\n\n      buffers.color.setMask(false);\n      buffers.depth.setMask(false); // Lock the buffers.\n\n      buffers.color.setLocked(true);\n      buffers.depth.setLocked(true); // Configure the stencil.\n\n      buffers.stencil.setTest(true);\n      buffers.stencil.setOp(context.REPLACE, context.REPLACE, context.REPLACE);\n      buffers.stencil.setFunc(context.ALWAYS, writeValue, 0xffffffff);\n      buffers.stencil.setClear(clearValue);\n      buffers.stencil.setLocked(true); // Clear the stencil.\n\n      if (this.clear) {\n        if (this.renderToScreen) {\n          clearPass.render(renderer, null);\n        } else {\n          clearPass.render(renderer, inputBuffer);\n          clearPass.render(renderer, outputBuffer);\n        }\n      } // Draw the mask.\n\n\n      if (this.renderToScreen) {\n        renderer.setRenderTarget(null);\n        renderer.render(scene, camera);\n      } else {\n        renderer.setRenderTarget(inputBuffer);\n        renderer.render(scene, camera);\n        renderer.setRenderTarget(outputBuffer);\n        renderer.render(scene, camera);\n      } // Unlock the buffers.\n\n\n      buffers.color.setLocked(false);\n      buffers.depth.setLocked(false); // Only render where the stencil is set to 1.\n\n      buffers.stencil.setLocked(false);\n      buffers.stencil.setFunc(context.EQUAL, 1, 0xffffffff);\n      buffers.stencil.setOp(context.KEEP, context.KEEP, context.KEEP);\n      buffers.stencil.setLocked(true);\n    }\n  }, {\n    key: \"clear\",\n    get: function get() {\n      return this.clearPass.enabled;\n    }\n    /**\r\n     * Enables or disables auto clear.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      this.clearPass.enabled = value;\n    }\n  }]);\n\n  return MaskPass;\n}(Pass);\n/**\r\n * A pass that renders the normals of a given scene.\r\n */\n\n\nvar NormalPass = /*#__PURE__*/function (_Pass8) {\n  _inherits(NormalPass, _Pass8);\n\n  var _super19 = _createSuper(NormalPass);\n\n  /**\r\n   * Constructs a new normal pass.\r\n   *\r\n   * @param {Scene} scene - The scene to render.\r\n   * @param {Camera} camera - The camera to use to render the scene.\r\n   * @param {Object} [options] - The options.\r\n   * @param {Number} [options.resolutionScale=1.0] - Deprecated. Adjust the height or width instead for consistent results.\r\n   * @param {Number} [options.width=Resizer.AUTO_SIZE] - The render width.\r\n   * @param {Number} [options.height=Resizer.AUTO_SIZE] - The render height.\r\n   * @param {WebGLRenderTarget} [options.renderTarget] - A custom render target.\r\n   */\n  function NormalPass(scene, camera) {\n    var _this13;\n\n    var _ref4 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n        _ref4$resolutionScale = _ref4.resolutionScale,\n        resolutionScale = _ref4$resolutionScale === void 0 ? 1.0 : _ref4$resolutionScale,\n        _ref4$width = _ref4.width,\n        width = _ref4$width === void 0 ? Resizer.AUTO_SIZE : _ref4$width,\n        _ref4$height = _ref4.height,\n        height = _ref4$height === void 0 ? Resizer.AUTO_SIZE : _ref4$height,\n        renderTarget = _ref4.renderTarget;\n\n    _classCallCheck(this, NormalPass);\n\n    _this13 = _super19.call(this, \"NormalPass\");\n    _this13.needsSwap = false;\n    /**\r\n     * A render pass.\r\n     *\r\n     * @type {RenderPass}\r\n     * @private\r\n     */\n\n    _this13.renderPass = new RenderPass(scene, camera, new MeshNormalMaterial({\n      morphTargets: true,\n      morphNormals: true,\n      skinning: true\n    }));\n\n    var clearPass = _this13.renderPass.getClearPass();\n\n    clearPass.overrideClearColor = new Color(0x7777ff);\n    clearPass.overrideClearAlpha = 1.0;\n    /**\r\n     * A render target that contains the scene normals.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     */\n\n    _this13.renderTarget = renderTarget;\n\n    if (_this13.renderTarget === undefined) {\n      _this13.renderTarget = new WebGLRenderTarget(1, 1, {\n        minFilter: LinearFilter,\n        magFilter: LinearFilter,\n        format: RGBFormat,\n        stencilBuffer: false\n      });\n      _this13.renderTarget.texture.name = \"NormalPass.Target\";\n    }\n    /**\r\n     * The desired render resolution.\r\n     *\r\n     * Use {@link Resizer.AUTO_SIZE} for the width or height to automatically\r\n     * calculate it based on its counterpart and the original aspect ratio.\r\n     *\r\n     * @type {Resizer}\r\n     */\n\n\n    _this13.resolution = new Resizer(_assertThisInitialized(_this13), width, height);\n    _this13.resolution.scale = resolutionScale;\n    return _this13;\n  }\n  /**\r\n   * Returns the current resolution scale.\r\n   *\r\n   * @return {Number} The resolution scale.\r\n   * @deprecated Adjust the fixed resolution width or height instead.\r\n   */\n\n\n  _createClass(NormalPass, [{\n    key: \"getResolutionScale\",\n    value: function getResolutionScale() {\n      return this.resolutionScale;\n    }\n    /**\r\n     * Sets the resolution scale.\r\n     *\r\n     * @param {Number} scale - The new resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n\n  }, {\n    key: \"setResolutionScale\",\n    value: function setResolutionScale(scale) {\n      this.resolutionScale = scale;\n      this.setSize(this.originalSize.x, this.originalSize.y);\n    }\n    /**\r\n     * Renders the scene normals.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n     */\n\n  }, {\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      var renderTarget = this.renderToScreen ? null : this.renderTarget;\n      this.renderPass.render(renderer, renderTarget, renderTarget);\n    }\n    /**\r\n     * Updates the size of this pass.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      var resolution = this.resolution;\n      resolution.base.set(width, height);\n      width = resolution.width;\n      height = resolution.height;\n      this.renderTarget.setSize(width, height);\n    }\n  }]);\n\n  return NormalPass;\n}(Pass);\n/**\r\n * A pass that renders the result from a previous pass to another render target.\r\n */\n\n\nvar SavePass = /*#__PURE__*/function (_Pass9) {\n  _inherits(SavePass, _Pass9);\n\n  var _super20 = _createSuper(SavePass);\n\n  /**\r\n   * Constructs a new save pass.\r\n   *\r\n   * @param {WebGLRenderTarget} [renderTarget] - A render target.\r\n   * @param {Boolean} [resize=true] - Whether the render target should adjust to the size of the input buffer.\r\n   */\n  function SavePass(renderTarget) {\n    var _this14;\n\n    var resize = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n\n    _classCallCheck(this, SavePass);\n\n    _this14 = _super20.call(this, \"SavePass\");\n\n    _this14.setFullscreenMaterial(new CopyMaterial());\n\n    _this14.needsSwap = false;\n    /**\r\n     * The render target.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     */\n\n    _this14.renderTarget = renderTarget;\n\n    if (renderTarget === undefined) {\n      _this14.renderTarget = new WebGLRenderTarget(1, 1, {\n        minFilter: LinearFilter,\n        magFilter: LinearFilter,\n        stencilBuffer: false,\n        depthBuffer: false\n      });\n      _this14.renderTarget.texture.name = \"SavePass.Target\";\n    }\n    /**\r\n     * Indicates whether the render target should be resized automatically.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n\n    _this14.resize = resize;\n    return _this14;\n  }\n  /**\r\n   * Saves the input buffer.\r\n   *\r\n   * @param {WebGLRenderer} renderer - The renderer.\r\n   * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n   * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n   * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n   * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n   */\n\n\n  _createClass(SavePass, [{\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      this.getFullscreenMaterial().uniforms.inputBuffer.value = inputBuffer.texture;\n      renderer.setRenderTarget(this.renderToScreen ? null : this.renderTarget);\n      renderer.render(this.scene, this.camera);\n    }\n    /**\r\n     * Updates the size of this pass.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      if (this.resize) {\n        width = Math.max(1, width);\n        height = Math.max(1, height);\n        this.renderTarget.setSize(width, height);\n      }\n    }\n  }]);\n\n  return SavePass;\n}(Pass);\n/**\r\n * A shader pass.\r\n *\r\n * Renders any shader material as a fullscreen effect.\r\n *\r\n * This pass should not be used to create multiple chained effects. For a more\r\n * efficient solution, please refer to the {@link EffectPass}.\r\n */\n\n\nvar ShaderPass = /*#__PURE__*/function (_Pass10) {\n  _inherits(ShaderPass, _Pass10);\n\n  var _super21 = _createSuper(ShaderPass);\n\n  /**\r\n   * Constructs a new shader pass.\r\n   *\r\n   * @param {ShaderMaterial} material - A shader material.\r\n   * @param {String} [input=\"inputBuffer\"] - The name of the input buffer uniform.\r\n   */\n  function ShaderPass(material) {\n    var _this15;\n\n    var input = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : \"inputBuffer\";\n\n    _classCallCheck(this, ShaderPass);\n\n    _this15 = _super21.call(this, \"ShaderPass\");\n\n    _this15.setFullscreenMaterial(material);\n    /**\r\n     * The input buffer uniform.\r\n     *\r\n     * @type {String}\r\n     * @private\r\n     */\n\n\n    _this15.uniform = null;\n\n    _this15.setInput(input);\n\n    return _this15;\n  }\n  /**\r\n   * Sets the name of the input buffer uniform.\r\n   *\r\n   * Most fullscreen materials modify texels from an input texture. This pass\r\n   * automatically assigns the main input buffer to the uniform identified by\r\n   * the given name.\r\n   *\r\n   * @param {String} input - The name of the input buffer uniform.\r\n   */\n\n\n  _createClass(ShaderPass, [{\n    key: \"setInput\",\n    value: function setInput(input) {\n      var material = this.getFullscreenMaterial();\n      this.uniform = null;\n\n      if (material !== null) {\n        var uniforms = material.uniforms;\n\n        if (uniforms !== undefined && uniforms[input] !== undefined) {\n          this.uniform = uniforms[input];\n        }\n      }\n    }\n    /**\r\n     * Renders the effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {WebGLRenderTarget} outputBuffer - A frame buffer that serves as the output render target unless this pass renders to screen.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     * @param {Boolean} [stencilTest] - Indicates whether a stencil mask is active.\r\n     */\n\n  }, {\n    key: \"render\",\n    value: function render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest) {\n      if (this.uniform !== null) {\n        this.uniform.value = inputBuffer.texture;\n      }\n\n      renderer.setRenderTarget(this.renderToScreen ? null : outputBuffer);\n      renderer.render(this.scene, this.camera);\n    }\n  }]);\n\n  return ShaderPass;\n}(Pass);\n/**\r\n * The EffectComposer may be used in place of a normal WebGLRenderer.\r\n *\r\n * The auto clear behaviour of the provided renderer will be disabled to prevent\r\n * unnecessary clear operations.\r\n *\r\n * It is common practice to use a {@link RenderPass} as the first pass to\r\n * automatically clear the buffers and render a scene for further processing.\r\n *\r\n * @implements {Resizable}\r\n * @implements {Disposable}\r\n */\n\n\nvar EffectComposer = /*#__PURE__*/function () {\n  /**\r\n   * Constructs a new effect composer.\r\n   *\r\n   * @param {WebGLRenderer} renderer - The renderer that should be used.\r\n   * @param {Object} [options] - The options.\r\n   * @param {Boolean} [options.depthBuffer=true] - Whether the main render targets should have a depth buffer.\r\n   * @param {Boolean} [options.stencilBuffer=false] - Whether the main render targets should have a stencil buffer.\r\n   */\n  function EffectComposer() {\n    var renderer = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : null;\n\n    var _ref5 = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {},\n        _ref5$depthBuffer = _ref5.depthBuffer,\n        depthBuffer = _ref5$depthBuffer === void 0 ? true : _ref5$depthBuffer,\n        _ref5$stencilBuffer = _ref5.stencilBuffer,\n        stencilBuffer = _ref5$stencilBuffer === void 0 ? false : _ref5$stencilBuffer;\n\n    _classCallCheck(this, EffectComposer);\n\n    /**\r\n     * The renderer.\r\n     *\r\n     * @type {WebGLRenderer}\r\n     * @private\r\n     */\n    this.renderer = renderer;\n    /**\r\n     * The input buffer.\r\n     *\r\n     * Reading from and writing to the same render target should be avoided.\r\n     * Therefore, two seperate yet identical buffers are used.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    this.inputBuffer = null;\n    /**\r\n     * The output buffer.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    this.outputBuffer = null;\n\n    if (this.renderer !== null) {\n      this.renderer.autoClear = false;\n      this.inputBuffer = this.createBuffer(depthBuffer, stencilBuffer);\n      this.outputBuffer = this.inputBuffer.clone();\n    }\n    /**\r\n     * A copy pass used for copying masked scenes.\r\n     *\r\n     * @type {ShaderPass}\r\n     * @private\r\n     */\n\n\n    this.copyPass = new ShaderPass(new CopyMaterial());\n    /**\r\n     * A depth texture.\r\n     *\r\n     * @type {DepthTexture}\r\n     * @private\r\n     */\n\n    this.depthTexture = null;\n    /**\r\n     * The passes.\r\n     *\r\n     * @type {Pass[]}\r\n     * @private\r\n     */\n\n    this.passes = [];\n  }\n  /**\r\n   * Returns the WebGL renderer.\r\n   *\r\n   * You may replace the renderer at any time by using\r\n   * {@link EffectComposer#replaceRenderer}.\r\n   *\r\n   * @return {WebGLRenderer} The renderer.\r\n   */\n\n\n  _createClass(EffectComposer, [{\n    key: \"getRenderer\",\n    value: function getRenderer() {\n      return this.renderer;\n    }\n    /**\r\n     * Replaces the current renderer with the given one.\r\n     *\r\n     * The auto clear mechanism of the provided renderer will be disabled. If the\r\n     * new render size differs from the previous one, all passes will be updated.\r\n     *\r\n     * By default, the DOM element of the current renderer will automatically be\r\n     * removed from its parent node and the DOM element of the new renderer will\r\n     * take its place.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The new renderer.\r\n     * @param {Boolean} updateDOM - Indicates whether the old canvas should be replaced by the new one in the DOM.\r\n     * @return {WebGLRenderer} The old renderer.\r\n     */\n\n  }, {\n    key: \"replaceRenderer\",\n    value: function replaceRenderer(renderer) {\n      var updateDOM = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : true;\n      var oldRenderer = this.renderer;\n\n      if (oldRenderer !== null && oldRenderer !== renderer) {\n        var oldSize = oldRenderer.getSize(new Vector2$1());\n        var newSize = renderer.getSize(new Vector2$1());\n        var parent = oldRenderer.domElement.parentNode;\n        this.renderer = renderer;\n        this.renderer.autoClear = false;\n\n        if (!oldSize.equals(newSize)) {\n          this.setSize();\n        }\n\n        if (updateDOM && parent !== null) {\n          parent.removeChild(oldRenderer.domElement);\n          parent.appendChild(renderer.domElement);\n        }\n      }\n\n      return oldRenderer;\n    }\n    /**\r\n     * Creates a depth texture attachment that will be provided to all passes.\r\n     *\r\n     * Note: When a shader reads from a depth texture and writes to a render\r\n     * target that uses the same depth texture attachment, the depth information\r\n     * will be lost. This happens even if `depthWrite` is disabled.\r\n     *\r\n     * @private\r\n     * @return {DepthTexture} The depth texture.\r\n     */\n\n  }, {\n    key: \"createDepthTexture\",\n    value: function createDepthTexture() {\n      var depthTexture = this.depthTexture = new DepthTexture();\n\n      if (this.inputBuffer.stencilBuffer) {\n        depthTexture.format = DepthStencilFormat;\n        depthTexture.type = UnsignedInt248Type;\n      }\n\n      return depthTexture;\n    }\n    /**\r\n     * Creates a new render target by replicating the renderer's canvas.\r\n     *\r\n     * The created render target uses a linear filter for texel minification and\r\n     * magnification. Its render texture format depends on whether the renderer\r\n     * uses the alpha channel. Mipmaps are disabled.\r\n     *\r\n     * @param {Boolean} depthBuffer - Whether the render target should have a depth buffer.\r\n     * @param {Boolean} stencilBuffer - Whether the render target should have a stencil buffer.\r\n     * @return {WebGLRenderTarget} A new render target that equals the renderer's canvas.\r\n     */\n\n  }, {\n    key: \"createBuffer\",\n    value: function createBuffer(depthBuffer, stencilBuffer) {\n      var drawingBufferSize = this.renderer.getDrawingBufferSize(new Vector2$1());\n      var alpha = this.renderer.getContext().getContextAttributes().alpha;\n      var renderTarget = new WebGLRenderTarget(drawingBufferSize.width, drawingBufferSize.height, {\n        minFilter: LinearFilter,\n        magFilter: LinearFilter,\n        format: alpha ? RGBAFormat : RGBFormat,\n        depthBuffer: depthBuffer,\n        stencilBuffer: stencilBuffer\n      });\n      renderTarget.texture.name = \"EffectComposer.Buffer\";\n      renderTarget.texture.generateMipmaps = false;\n      return renderTarget;\n    }\n    /**\r\n     * Adds a pass, optionally at a specific index.\r\n     *\r\n     * @param {Pass} pass - A new pass.\r\n     * @param {Number} [index] - An index at which the pass should be inserted.\r\n     */\n\n  }, {\n    key: \"addPass\",\n    value: function addPass(pass, index) {\n      var passes = this.passes;\n      var renderer = this.renderer;\n      var drawingBufferSize = renderer.getDrawingBufferSize(new Vector2$1());\n      pass.setSize(drawingBufferSize.width, drawingBufferSize.height);\n      pass.initialize(renderer, renderer.getContext().getContextAttributes().alpha);\n\n      if (index !== undefined) {\n        passes.splice(index, 0, pass);\n      } else {\n        passes.push(pass);\n      }\n\n      if (pass.needsDepthTexture || this.depthTexture !== null) {\n        if (this.depthTexture === null) {\n          var depthTexture = this.createDepthTexture();\n\n          var _iterator14 = _createForOfIteratorHelper(passes),\n              _step14;\n\n          try {\n            for (_iterator14.s(); !(_step14 = _iterator14.n()).done;) {\n              pass = _step14.value;\n              pass.setDepthTexture(depthTexture);\n            }\n          } catch (err) {\n            _iterator14.e(err);\n          } finally {\n            _iterator14.f();\n          }\n        } else {\n          pass.setDepthTexture(this.depthTexture);\n        }\n      }\n    }\n    /**\r\n     * Removes a pass.\r\n     *\r\n     * @param {Pass} pass - The pass.\r\n     */\n\n  }, {\n    key: \"removePass\",\n    value: function removePass(pass) {\n      var passes = this.passes;\n      var removed = passes.splice(passes.indexOf(pass), 1).length > 0;\n\n      if (removed && this.depthTexture !== null) {\n        var reducer = function reducer(a, b) {\n          return a || b.needsDepthTexture;\n        };\n\n        var depthTextureRequired = passes.reduce(reducer, false);\n\n        if (!depthTextureRequired) {\n          this.depthTexture.dispose();\n          this.depthTexture = null;\n          this.inputBuffer.depthTexture = null;\n          this.outputBuffer.depthTexture = null;\n\n          var _iterator15 = _createForOfIteratorHelper(passes),\n              _step15;\n\n          try {\n            for (_iterator15.s(); !(_step15 = _iterator15.n()).done;) {\n              pass = _step15.value;\n              pass.setDepthTexture(null);\n            }\n          } catch (err) {\n            _iterator15.e(err);\n          } finally {\n            _iterator15.f();\n          }\n        }\n      }\n    }\n    /**\r\n     * Renders all enabled passes in the order in which they were added.\r\n     *\r\n     * @param {Number} deltaTime - The time between the last frame and the current one in seconds.\r\n     */\n\n  }, {\n    key: \"render\",\n    value: function render(deltaTime) {\n      var renderer = this.renderer;\n      var copyPass = this.copyPass;\n      var inputBuffer = this.inputBuffer;\n      var outputBuffer = this.outputBuffer;\n      var stencilTest = false;\n      var context, stencil, buffer;\n\n      var _iterator16 = _createForOfIteratorHelper(this.passes),\n          _step16;\n\n      try {\n        for (_iterator16.s(); !(_step16 = _iterator16.n()).done;) {\n          var pass = _step16.value;\n\n          if (pass.enabled) {\n            pass.render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest);\n\n            if (pass.needsSwap) {\n              if (stencilTest) {\n                copyPass.renderToScreen = pass.renderToScreen;\n                context = renderer.getContext();\n                stencil = renderer.state.buffers.stencil; // Preserve the unaffected pixels.\n\n                stencil.setFunc(context.NOTEQUAL, 1, 0xffffffff);\n                copyPass.render(renderer, inputBuffer, outputBuffer, deltaTime, stencilTest);\n                stencil.setFunc(context.EQUAL, 1, 0xffffffff);\n              }\n\n              buffer = inputBuffer;\n              inputBuffer = outputBuffer;\n              outputBuffer = buffer;\n            }\n\n            if (pass instanceof MaskPass) {\n              stencilTest = true;\n            } else if (pass instanceof ClearMaskPass) {\n              stencilTest = false;\n            }\n          }\n        }\n      } catch (err) {\n        _iterator16.e(err);\n      } finally {\n        _iterator16.f();\n      }\n    }\n    /**\r\n     * Sets the size of the buffers and the renderer's output canvas.\r\n     *\r\n     * Every pass will be informed of the new size. It's up to each pass how that\r\n     * information is used.\r\n     *\r\n     * If no width or height is specified, the render targets and passes will be\r\n     * updated with the current size of the renderer.\r\n     *\r\n     * @param {Number} [width] - The width.\r\n     * @param {Number} [height] - The height.\r\n     * @param {Boolean} [updateStyle] - Determines whether the style of the canvas should be updated.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height, updateStyle) {\n      var renderer = this.renderer;\n\n      if (width === undefined || height === undefined) {\n        var size = renderer.getSize(new Vector2$1());\n        width = size.width;\n        height = size.height;\n      } // Update the logical render size.\n\n\n      renderer.setSize(width, height, updateStyle); // The drawing buffer size takes the device pixel ratio into account.\n\n      var drawingBufferSize = renderer.getDrawingBufferSize(new Vector2$1());\n      this.inputBuffer.setSize(drawingBufferSize.width, drawingBufferSize.height);\n      this.outputBuffer.setSize(drawingBufferSize.width, drawingBufferSize.height);\n\n      var _iterator17 = _createForOfIteratorHelper(this.passes),\n          _step17;\n\n      try {\n        for (_iterator17.s(); !(_step17 = _iterator17.n()).done;) {\n          var pass = _step17.value;\n          pass.setSize(drawingBufferSize.width, drawingBufferSize.height);\n        }\n      } catch (err) {\n        _iterator17.e(err);\n      } finally {\n        _iterator17.f();\n      }\n    }\n    /**\r\n     * Resets this composer by deleting all passes and creating new buffers.\r\n     */\n\n  }, {\n    key: \"reset\",\n    value: function reset() {\n      var renderTarget = this.createBuffer(this.inputBuffer.depthBuffer, this.inputBuffer.stencilBuffer);\n      this.dispose(); // Reanimate.\n\n      this.inputBuffer = renderTarget;\n      this.outputBuffer = renderTarget.clone();\n      this.depthTexture = null;\n      this.copyPass = new ShaderPass(new CopyMaterial());\n    }\n    /**\r\n     * Destroys this composer and all passes.\r\n     *\r\n     * This method deallocates all disposable objects created by the passes. It\r\n     * also deletes the main frame buffers of this composer.\r\n     */\n\n  }, {\n    key: \"dispose\",\n    value: function dispose() {\n      var _iterator18 = _createForOfIteratorHelper(this.passes),\n          _step18;\n\n      try {\n        for (_iterator18.s(); !(_step18 = _iterator18.n()).done;) {\n          var pass = _step18.value;\n          pass.dispose();\n        }\n      } catch (err) {\n        _iterator18.e(err);\n      } finally {\n        _iterator18.f();\n      }\n\n      this.passes = [];\n\n      if (this.inputBuffer !== null) {\n        this.inputBuffer.dispose();\n        this.inputBuffer = null;\n      }\n\n      if (this.outputBuffer !== null) {\n        this.outputBuffer.dispose();\n        this.outputBuffer = null;\n      }\n\n      if (this.depthTexture !== null) {\n        this.depthTexture.dispose();\n      }\n\n      this.copyPass.dispose();\n    }\n  }]);\n\n  return EffectComposer;\n}();\n/**\r\n * The Resizable contract.\r\n *\r\n * Implemented by objects that can be resized.\r\n *\r\n * @interface\r\n */\n\n\nvar Resizable = /*#__PURE__*/function () {\n  function Resizable() {\n    _classCallCheck(this, Resizable);\n  }\n\n  _createClass(Resizable, [{\n    key: \"setSize\",\n\n    /**\r\n     * Sets the size of this object.\r\n     *\r\n     * @param {Number} width - The new width.\r\n     * @param {Number} height - The new height.\r\n     */\n    value: function setSize(width, height) {}\n  }]);\n\n  return Resizable;\n}();\n/**\r\n * An object selection.\r\n */\n\n\nvar Selection = /*#__PURE__*/function (_Set) {\n  _inherits(Selection, _Set);\n\n  var _super22 = _createSuper(Selection);\n\n  /**\r\n   * Constructs a new selection.\r\n   *\r\n   * @param {Iterable<Object3D>} [iterable] - A collection of objects that should be added to this selection.\r\n   * @param {Number} [layer=10] - A dedicated render layer for selected objects.\r\n   */\n  function Selection(iterable) {\n    var _this16;\n\n    var layer = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 10;\n\n    _classCallCheck(this, Selection);\n\n    _this16 = _super22.call(this);\n    /**\r\n     * The current render layer for selected objects.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this16.currentLayer = layer;\n\n    if (iterable !== undefined) {\n      _this16.set(iterable);\n    }\n\n    return _this16;\n  }\n  /**\r\n   * A dedicated render layer for selected objects.\r\n   *\r\n   * This layer is set to 10 by default. If this collides with your own custom\r\n   * layers, please change it to a free layer before rendering!\r\n   *\r\n   * @type {Number}\r\n   */\n\n\n  _createClass(Selection, [{\n    key: \"clear\",\n\n    /**\r\n     * Clears this selection.\r\n     *\r\n     * @return {Selection} This selection.\r\n     */\n    value: function clear() {\n      var layer = this.layer;\n\n      var _iterator19 = _createForOfIteratorHelper(this),\n          _step19;\n\n      try {\n        for (_iterator19.s(); !(_step19 = _iterator19.n()).done;) {\n          var object = _step19.value;\n          object.layers.disable(layer);\n        }\n      } catch (err) {\n        _iterator19.e(err);\n      } finally {\n        _iterator19.f();\n      }\n\n      return _get(_getPrototypeOf(Selection.prototype), \"clear\", this).call(this);\n    }\n    /**\r\n     * Clears this selection and adds the given objects.\r\n     *\r\n     * @param {Iterable<Object3D>} objects - The objects that should be selected. This array will be copied.\r\n     * @return {Selection} This selection.\r\n     */\n\n  }, {\n    key: \"set\",\n    value: function set(objects) {\n      this.clear();\n\n      var _iterator20 = _createForOfIteratorHelper(objects),\n          _step20;\n\n      try {\n        for (_iterator20.s(); !(_step20 = _iterator20.n()).done;) {\n          var object = _step20.value;\n          this.add(object);\n        }\n      } catch (err) {\n        _iterator20.e(err);\n      } finally {\n        _iterator20.f();\n      }\n\n      return this;\n    }\n    /**\r\n     * An alias for {@link has}.\r\n     *\r\n     * @param {Object3D} object - An object.\r\n     * @return {Number} Returns 0 if the given object is currently selected, or -1 otherwise.\r\n     * @deprecated Added for backward compatibility. Use has instead.\r\n     */\n\n  }, {\n    key: \"indexOf\",\n    value: function indexOf(object) {\n      return this.has(object) ? 0 : -1;\n    }\n    /**\r\n     * Adds an object to this selection.\r\n     *\r\n     * @param {Object3D} object - The object that should be selected.\r\n     * @return {Selection} This selection.\r\n     */\n\n  }, {\n    key: \"add\",\n    value: function add(object) {\n      object.layers.enable(this.layer);\n\n      _get(_getPrototypeOf(Selection.prototype), \"add\", this).call(this, object);\n\n      return this;\n    }\n    /**\r\n     * Removes an object from this selection.\r\n     *\r\n     * @param {Object3D} object - The object that should be deselected.\r\n     * @return {Boolean} Returns true if an object has successfully been removed from this selection; otherwise false.\r\n     */\n\n  }, {\n    key: \"delete\",\n    value: function _delete(object) {\n      if (this.has(object)) {\n        object.layers.disable(this.layer);\n      }\n\n      return _get(_getPrototypeOf(Selection.prototype), \"delete\", this).call(this, object);\n    }\n    /**\r\n     * Sets the visibility of all selected objects.\r\n     *\r\n     * This method enables or disables render layer 0 of all selected objects.\r\n     *\r\n     * @param {Boolean} visible - Whether the selected objects should be visible.\r\n     * @return {Selection} This selection.\r\n     */\n\n  }, {\n    key: \"setVisible\",\n    value: function setVisible(visible) {\n      var _iterator21 = _createForOfIteratorHelper(this),\n          _step21;\n\n      try {\n        for (_iterator21.s(); !(_step21 = _iterator21.n()).done;) {\n          var object = _step21.value;\n\n          if (visible) {\n            object.layers.enable(0);\n          } else {\n            object.layers.disable(0);\n          }\n        }\n      } catch (err) {\n        _iterator21.e(err);\n      } finally {\n        _iterator21.f();\n      }\n\n      return this;\n    }\n  }, {\n    key: \"layer\",\n    get: function get() {\n      return this.currentLayer;\n    }\n    /**\r\n     * Sets the render layer of selected objects.\r\n     *\r\n     * The current selection will be updated accordingly.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      var currentLayer = this.currentLayer;\n\n      var _iterator22 = _createForOfIteratorHelper(this),\n          _step22;\n\n      try {\n        for (_iterator22.s(); !(_step22 = _iterator22.n()).done;) {\n          var object = _step22.value;\n          object.layers.disable(currentLayer);\n          object.layers.enable(value);\n        }\n      } catch (err) {\n        _iterator22.e(err);\n      } finally {\n        _iterator22.f();\n      }\n\n      this.currentLayer = value;\n    }\n  }]);\n\n  return Selection;\n}( /*#__PURE__*/_wrapNativeSuper(Set));\n\nvar fragmentShader$a = \"uniform sampler2D texture;\\n#ifdef ASPECT_CORRECTION\\nvarying vec2 vUv2;\\n#endif\\nvoid mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){\\n#ifdef ASPECT_CORRECTION\\noutputColor=texture2D(texture,vUv2);\\n#else\\noutputColor=texture2D(texture,uv);\\n#endif\\n}\";\n/**\r\n * A bloom effect.\r\n *\r\n * This effect uses the fast Kawase convolution technique and a luminance filter\r\n * to blur bright highlights.\r\n */\n\nvar BloomEffect = /*#__PURE__*/function (_Effect) {\n  _inherits(BloomEffect, _Effect);\n\n  var _super23 = _createSuper(BloomEffect);\n\n  /**\r\n   * Constructs a new bloom effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function of this effect.\r\n   * @param {Number} [options.luminanceThreshold=0.9] - The luminance threshold. Raise this value to mask out darker elements in the scene. Range is [0, 1].\r\n   * @param {Number} [options.luminanceSmoothing=0.025] - Controls the smoothness of the luminance threshold. Range is [0, 1].\r\n   * @param {Number} [options.resolutionScale=0.5] - Deprecated. Use height or width instead.\r\n   * @param {Number} [options.width=Resizer.AUTO_SIZE] - The render width.\r\n   * @param {Number} [options.height=Resizer.AUTO_SIZE] - The render height.\r\n   * @param {KernelSize} [options.kernelSize=KernelSize.LARGE] - The blur kernel size.\r\n   */\n  function BloomEffect() {\n    var _this17;\n\n    var _ref6 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref6$blendFunction = _ref6.blendFunction,\n        blendFunction = _ref6$blendFunction === void 0 ? BlendFunction.SCREEN : _ref6$blendFunction,\n        _ref6$luminanceThresh = _ref6.luminanceThreshold,\n        luminanceThreshold = _ref6$luminanceThresh === void 0 ? 0.9 : _ref6$luminanceThresh,\n        _ref6$luminanceSmooth = _ref6.luminanceSmoothing,\n        luminanceSmoothing = _ref6$luminanceSmooth === void 0 ? 0.025 : _ref6$luminanceSmooth,\n        _ref6$resolutionScale = _ref6.resolutionScale,\n        resolutionScale = _ref6$resolutionScale === void 0 ? 0.5 : _ref6$resolutionScale,\n        _ref6$width = _ref6.width,\n        width = _ref6$width === void 0 ? Resizer.AUTO_SIZE : _ref6$width,\n        _ref6$height = _ref6.height,\n        height = _ref6$height === void 0 ? Resizer.AUTO_SIZE : _ref6$height,\n        _ref6$kernelSize = _ref6.kernelSize,\n        kernelSize = _ref6$kernelSize === void 0 ? KernelSize.LARGE : _ref6$kernelSize;\n\n    _classCallCheck(this, BloomEffect);\n\n    _this17 = _super23.call(this, \"BloomEffect\", fragmentShader$a, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"texture\", new Uniform(null)]])\n    });\n    /**\r\n     * A render target.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this17.renderTarget = new WebGLRenderTarget(1, 1, {\n      minFilter: LinearFilter,\n      magFilter: LinearFilter,\n      stencilBuffer: false,\n      depthBuffer: false\n    });\n    _this17.renderTarget.texture.name = \"Bloom.Target\";\n    _this17.renderTarget.texture.generateMipmaps = false;\n    _this17.uniforms.get(\"texture\").value = _this17.renderTarget.texture;\n    /**\r\n     * A blur pass.\r\n     *\r\n     * @type {BlurPass}\r\n     */\n\n    _this17.blurPass = new BlurPass({\n      resolutionScale: resolutionScale,\n      width: width,\n      height: height,\n      kernelSize: kernelSize\n    });\n    _this17.blurPass.resolution.resizable = _assertThisInitialized(_this17);\n    /**\r\n     * A luminance shader pass.\r\n     *\r\n     * You may disable this pass to deactivate luminance filtering.\r\n     *\r\n     * @type {ShaderPass}\r\n     */\n\n    _this17.luminancePass = new ShaderPass(new LuminanceMaterial(true));\n    _this17.luminanceMaterial.threshold = luminanceThreshold;\n    _this17.luminanceMaterial.smoothing = luminanceSmoothing;\n    return _this17;\n  }\n  /**\r\n   * A texture that contains the intermediate result of this effect.\r\n   *\r\n   * This texture will be applied to the scene colors unless the blend function\r\n   * is set to `SKIP`.\r\n   *\r\n   * @type {Texture}\r\n   */\n\n\n  _createClass(BloomEffect, [{\n    key: \"getResolutionScale\",\n\n    /**\r\n     * Returns the current resolution scale.\r\n     *\r\n     * @return {Number} The resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n    value: function getResolutionScale() {\n      return this.resolution.scale;\n    }\n    /**\r\n     * Sets the resolution scale.\r\n     *\r\n     * @param {Number} scale - The new resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n\n  }, {\n    key: \"setResolutionScale\",\n    value: function setResolutionScale(scale) {\n      this.resolution.scale = scale;\n      this.setSize(this.resolution.base.x, this.resolution.base.y);\n    }\n    /**\r\n     * Updates this effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     */\n\n  }, {\n    key: \"update\",\n    value: function update(renderer, inputBuffer, deltaTime) {\n      var renderTarget = this.renderTarget;\n\n      if (this.luminancePass.enabled) {\n        this.luminancePass.render(renderer, inputBuffer, renderTarget);\n        this.blurPass.render(renderer, renderTarget, renderTarget);\n      } else {\n        this.blurPass.render(renderer, inputBuffer, renderTarget);\n      }\n    }\n    /**\r\n     * Updates the size of internal render targets.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.blurPass.setSize(width, height);\n      this.renderTarget.setSize(this.resolution.width, this.resolution.height);\n    }\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {\n      this.blurPass.initialize(renderer, alpha);\n\n      if (!alpha) {\n        this.renderTarget.texture.format = RGBFormat;\n      }\n    }\n  }, {\n    key: \"texture\",\n    get: function get() {\n      return this.renderTarget.texture;\n    }\n    /**\r\n     * The luminance material.\r\n     *\r\n     * @type {LuminanceMaterial}\r\n     */\n\n  }, {\n    key: \"luminanceMaterial\",\n    get: function get() {\n      return this.luminancePass.getFullscreenMaterial();\n    }\n    /**\r\n     * The resolution of this effect.\r\n     *\r\n     * @type {Resizer}\r\n     */\n\n  }, {\n    key: \"resolution\",\n    get: function get() {\n      return this.blurPass.resolution;\n    }\n    /**\r\n     * The current width of the internal render targets.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.width instead.\r\n     */\n\n  }, {\n    key: \"width\",\n    get: function get() {\n      return this.resolution.width;\n    }\n    /**\r\n     * Sets the render width.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.width instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.resolution.width = value;\n    }\n    /**\r\n     * The current height of the internal render targets.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.height instead.\r\n     */\n\n  }, {\n    key: \"height\",\n    get: function get() {\n      return this.resolution.height;\n    }\n    /**\r\n     * Sets the render height.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.height instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.resolution.height = value;\n    }\n    /**\r\n     * Indicates whether dithering is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     * @deprecated Use blurPass.dithering instead.\r\n     */\n\n  }, {\n    key: \"dithering\",\n    get: function get() {\n      return this.blurPass.dithering;\n    }\n    /**\r\n     * Enables or disables dithering.\r\n     *\r\n     * @type {Boolean}\r\n     * @deprecated Use blurPass.dithering instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.blurPass.dithering = value;\n    }\n    /**\r\n     * The blur kernel size.\r\n     *\r\n     * @type {KernelSize}\r\n     * @deprecated Use blurPass.kernelSize instead.\r\n     */\n\n  }, {\n    key: \"kernelSize\",\n    get: function get() {\n      return this.blurPass.kernelSize;\n    }\n    /**\r\n     * @type {KernelSize}\r\n     * @deprecated Use blurPass.kernelSize instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.blurPass.kernelSize = value;\n    }\n    /**\r\n     * @type {Number}\r\n     * @deprecated Use luminanceMaterial.threshold and luminanceMaterial.smoothing instead.\r\n     */\n\n  }, {\n    key: \"distinction\",\n    get: function get() {\n      console.warn(this.name, \"The distinction field has been removed, use luminanceMaterial.threshold and luminanceMaterial.smoothing instead.\");\n      return 1.0;\n    }\n    /**\r\n     * @type {Number}\r\n     * @deprecated Use luminanceMaterial.threshold and luminanceMaterial.smoothing instead.\r\n     */\n    ,\n    set: function set(value) {\n      console.warn(this.name, \"The distinction field has been removed, use luminanceMaterial.threshold and luminanceMaterial.smoothing instead.\");\n    }\n  }]);\n\n  return BloomEffect;\n}(Effect);\n\nvar fragmentShader$b = \"uniform float focus;uniform float dof;uniform float aperture;uniform float maxBlur;void mainImage(const in vec4 inputColor,const in vec2 uv,const in float depth,out vec4 outputColor){vec2 aspectCorrection=vec2(1.0,aspect);float focusNear=clamp(focus-dof,0.0,1.0);float focusFar=clamp(focus+dof,0.0,1.0);float low=step(depth,focusNear);float high=step(focusFar,depth);float factor=(depth-focusNear)*low+(depth-focusFar)*high;vec2 dofBlur=vec2(clamp(factor*aperture,-maxBlur,maxBlur));vec2 dofblur9=dofBlur*0.9;vec2 dofblur7=dofBlur*0.7;vec2 dofblur4=dofBlur*0.4;vec4 color=inputColor;color+=texture2D(inputBuffer,uv+(vec2(0.0,0.4)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.15,0.37)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.29,0.29)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(-0.37,0.15)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.40,0.0)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.37,-0.15)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.29,-0.29)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(-0.15,-0.37)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.0,-0.4)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(-0.15,0.37)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(-0.29,0.29)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.37,0.15)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(-0.4,0.0)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(-0.37,-0.15)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(-0.29,-0.29)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.15,-0.37)*aspectCorrection)*dofBlur);color+=texture2D(inputBuffer,uv+(vec2(0.15,0.37)*aspectCorrection)*dofblur9);color+=texture2D(inputBuffer,uv+(vec2(-0.37,0.15)*aspectCorrection)*dofblur9);color+=texture2D(inputBuffer,uv+(vec2(0.37,-0.15)*aspectCorrection)*dofblur9);color+=texture2D(inputBuffer,uv+(vec2(-0.15,-0.37)*aspectCorrection)*dofblur9);color+=texture2D(inputBuffer,uv+(vec2(-0.15,0.37)*aspectCorrection)*dofblur9);color+=texture2D(inputBuffer,uv+(vec2(0.37,0.15)*aspectCorrection)*dofblur9);color+=texture2D(inputBuffer,uv+(vec2(-0.37,-0.15)*aspectCorrection)*dofblur9);color+=texture2D(inputBuffer,uv+(vec2(0.15,-0.37)*aspectCorrection)*dofblur9);color+=texture2D(inputBuffer,uv+(vec2(0.29,0.29)*aspectCorrection)*dofblur7);color+=texture2D(inputBuffer,uv+(vec2(0.40,0.0)*aspectCorrection)*dofblur7);color+=texture2D(inputBuffer,uv+(vec2(0.29,-0.29)*aspectCorrection)*dofblur7);color+=texture2D(inputBuffer,uv+(vec2(0.0,-0.4)*aspectCorrection)*dofblur7);color+=texture2D(inputBuffer,uv+(vec2(-0.29,0.29)*aspectCorrection)*dofblur7);color+=texture2D(inputBuffer,uv+(vec2(-0.4,0.0)*aspectCorrection)*dofblur7);color+=texture2D(inputBuffer,uv+(vec2(-0.29,-0.29)*aspectCorrection)*dofblur7);color+=texture2D(inputBuffer,uv+(vec2(0.0,0.4)*aspectCorrection)*dofblur7);color+=texture2D(inputBuffer,uv+(vec2(0.29,0.29)*aspectCorrection)*dofblur4);color+=texture2D(inputBuffer,uv+(vec2(0.4,0.0)*aspectCorrection)*dofblur4);color+=texture2D(inputBuffer,uv+(vec2(0.29,-0.29)*aspectCorrection)*dofblur4);color+=texture2D(inputBuffer,uv+(vec2(0.0,-0.4)*aspectCorrection)*dofblur4);color+=texture2D(inputBuffer,uv+(vec2(-0.29,0.29)*aspectCorrection)*dofblur4);color+=texture2D(inputBuffer,uv+(vec2(-0.4,0.0)*aspectCorrection)*dofblur4);color+=texture2D(inputBuffer,uv+(vec2(-0.29,-0.29)*aspectCorrection)*dofblur4);color+=texture2D(inputBuffer,uv+(vec2(0.0,0.4)*aspectCorrection)*dofblur4);outputColor=color/41.0;}\";\n/**\r\n * A depth of field (bokeh) effect.\r\n *\r\n * Original shader code by Martins Upitis:\r\n *  http://artmartinsh.blogspot.com/2010/02/glsl-lens-blur-filter-with-bokeh.html\r\n */\n\nvar BokehEffect = /*#__PURE__*/function (_Effect2) {\n  _inherits(BokehEffect, _Effect2);\n\n  var _super24 = _createSuper(BokehEffect);\n\n  /**\r\n   * Constructs a new bokeh effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Number} [options.focus=0.5] - The focus distance ratio, ranging from 0.0 to 1.0.\r\n   * @param {Number} [options.dof=0.02] - Depth of field. An area in front of and behind the focal point that still appears sharp.\r\n   * @param {Number} [options.aperture=0.015] - Camera aperture scale. Bigger values for stronger blur and shallower depth of field.\r\n   * @param {Number} [options.maxBlur=1.0] - The maximum blur strength.\r\n   */\n  function BokehEffect() {\n    var _ref7 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref7$blendFunction = _ref7.blendFunction,\n        blendFunction = _ref7$blendFunction === void 0 ? BlendFunction.NORMAL : _ref7$blendFunction,\n        _ref7$focus = _ref7.focus,\n        focus = _ref7$focus === void 0 ? 0.5 : _ref7$focus,\n        _ref7$dof = _ref7.dof,\n        dof = _ref7$dof === void 0 ? 0.02 : _ref7$dof,\n        _ref7$aperture = _ref7.aperture,\n        aperture = _ref7$aperture === void 0 ? 0.015 : _ref7$aperture,\n        _ref7$maxBlur = _ref7.maxBlur,\n        maxBlur = _ref7$maxBlur === void 0 ? 1.0 : _ref7$maxBlur;\n\n    _classCallCheck(this, BokehEffect);\n\n    return _super24.call(this, \"BokehEffect\", fragmentShader$b, {\n      blendFunction: blendFunction,\n      attributes: EffectAttribute.CONVOLUTION | EffectAttribute.DEPTH,\n      uniforms: new Map([[\"focus\", new Uniform(focus)], [\"dof\", new Uniform(dof)], [\"aperture\", new Uniform(aperture)], [\"maxBlur\", new Uniform(maxBlur)]])\n    });\n  }\n\n  return BokehEffect;\n}(Effect);\n\nvar fragmentShader$c = \"uniform float brightness;uniform float contrast;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec3 color=inputColor.rgb+vec3(brightness-0.5);if(contrast>0.0){color/=vec3(1.0-contrast);}else{color*=vec3(1.0+contrast);}outputColor=vec4(min(color+vec3(0.5),1.0),inputColor.a);}\";\n/**\r\n * A brightness/contrast effect.\r\n *\r\n * Reference: https://github.com/evanw/glfx.js\r\n */\n\nvar BrightnessContrastEffect = /*#__PURE__*/function (_Effect3) {\n  _inherits(BrightnessContrastEffect, _Effect3);\n\n  var _super25 = _createSuper(BrightnessContrastEffect);\n\n  /**\r\n   * Constructs a new brightness/contrast effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Number} [options.brightness=0.0] - The brightness factor, ranging from -1 to 1, where 0 means no change.\r\n   * @param {Number} [options.contrast=0.0] - The contrast factor, ranging from -1 to 1, where 0 means no change.\r\n   */\n  function BrightnessContrastEffect() {\n    var _ref8 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref8$blendFunction = _ref8.blendFunction,\n        blendFunction = _ref8$blendFunction === void 0 ? BlendFunction.NORMAL : _ref8$blendFunction,\n        _ref8$brightness = _ref8.brightness,\n        brightness = _ref8$brightness === void 0 ? 0.0 : _ref8$brightness,\n        _ref8$contrast = _ref8.contrast,\n        contrast = _ref8$contrast === void 0 ? 0.0 : _ref8$contrast;\n\n    _classCallCheck(this, BrightnessContrastEffect);\n\n    return _super25.call(this, \"BrightnessContrastEffect\", fragmentShader$c, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"brightness\", new Uniform(brightness)], [\"contrast\", new Uniform(contrast)]])\n    });\n  }\n\n  return BrightnessContrastEffect;\n}(Effect);\n\nvar fragmentShader$d = \"void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){float sum=inputColor.r+inputColor.g+inputColor.b;outputColor=vec4(vec3(sum/3.0),inputColor.a);}\";\n/**\r\n * A color average effect.\r\n */\n\nvar ColorAverageEffect = /*#__PURE__*/function (_Effect4) {\n  _inherits(ColorAverageEffect, _Effect4);\n\n  var _super26 = _createSuper(ColorAverageEffect);\n\n  /**\r\n   * Constructs a new color average effect.\r\n   *\r\n   * @param {BlendFunction} [blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   */\n  function ColorAverageEffect() {\n    var blendFunction = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : BlendFunction.NORMAL;\n\n    _classCallCheck(this, ColorAverageEffect);\n\n    return _super26.call(this, \"ColorAverageEffect\", fragmentShader$d, {\n      blendFunction: blendFunction\n    });\n  }\n\n  return ColorAverageEffect;\n}(Effect);\n\nvar fragmentShader$e = \"uniform float factor;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){outputColor=vec4(floor(inputColor.rgb*factor+0.5)/factor,inputColor.a);}\";\n/**\r\n * A color depth effect.\r\n *\r\n * Simulates a hardware limitation to achieve a retro feel.\r\n */\n\nvar ColorDepthEffect = /*#__PURE__*/function (_Effect5) {\n  _inherits(ColorDepthEffect, _Effect5);\n\n  var _super27 = _createSuper(ColorDepthEffect);\n\n  /**\r\n   * Constructs a new color depth effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Number} [options.bits=16] - The color bit depth.\r\n   */\n  function ColorDepthEffect() {\n    var _this18;\n\n    var _ref9 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref9$blendFunction = _ref9.blendFunction,\n        blendFunction = _ref9$blendFunction === void 0 ? BlendFunction.NORMAL : _ref9$blendFunction,\n        _ref9$bits = _ref9.bits,\n        bits = _ref9$bits === void 0 ? 16 : _ref9$bits;\n\n    _classCallCheck(this, ColorDepthEffect);\n\n    _this18 = _super27.call(this, \"ColorDepthEffect\", fragmentShader$e, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"factor\", new Uniform(1.0)]])\n    });\n    /**\r\n     * The current amount of bits.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this18.bits = 0;\n\n    _this18.setBitDepth(bits);\n\n    return _this18;\n  }\n  /**\r\n   * Returns the current color bit depth.\r\n   *\r\n   * @return {Number} The color bit depth.\r\n   */\n\n\n  _createClass(ColorDepthEffect, [{\n    key: \"getBitDepth\",\n    value: function getBitDepth() {\n      return this.bits;\n    }\n    /**\r\n     * Sets the virtual amount of color bits.\r\n     *\r\n     * Each color channel will use a third of the available bits. The alpha\r\n     * channel remains unaffected.\r\n     *\r\n     * Note that the real color depth will not be altered by this effect.\r\n     *\r\n     * @param {Number} bits - The new color bit depth.\r\n     */\n\n  }, {\n    key: \"setBitDepth\",\n    value: function setBitDepth(bits) {\n      this.bits = bits;\n      this.uniforms.get(\"factor\").value = Math.pow(2.0, bits / 3.0);\n    }\n  }]);\n\n  return ColorDepthEffect;\n}(Effect);\n\nvar fragmentShader$f = \"varying vec2 vUvR;varying vec2 vUvB;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec4 color=inputColor;\\n#ifdef ALPHA\\nvec2 ra=texture2D(inputBuffer,vUvR).ra;vec2 ba=texture2D(inputBuffer,vUvB).ba;color.r=ra.x;color.b=ba.x;color.a=max(max(ra.y,ba.y),inputColor.a);\\n#else\\ncolor.r=texture2D(inputBuffer,vUvR).r;color.b=texture2D(inputBuffer,vUvB).b;\\n#endif\\noutputColor=color;}\";\nvar vertexShader$6 = \"uniform vec2 offset;varying vec2 vUvR;varying vec2 vUvB;void mainSupport(const in vec2 uv){vUvR=uv+offset;vUvB=uv-offset;}\";\n/**\r\n * A chromatic aberration effect.\r\n */\n\nvar ChromaticAberrationEffect = /*#__PURE__*/function (_Effect6) {\n  _inherits(ChromaticAberrationEffect, _Effect6);\n\n  var _super28 = _createSuper(ChromaticAberrationEffect);\n\n  /**\r\n   * Constructs a new chromatic aberration effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Vector2} [options.offset] - The color offset.\r\n   */\n  function ChromaticAberrationEffect() {\n    var _ref10 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref10$blendFunction = _ref10.blendFunction,\n        blendFunction = _ref10$blendFunction === void 0 ? BlendFunction.NORMAL : _ref10$blendFunction,\n        _ref10$offset = _ref10.offset,\n        offset = _ref10$offset === void 0 ? new Vector2$1(0.001, 0.0005) : _ref10$offset;\n\n    _classCallCheck(this, ChromaticAberrationEffect);\n\n    return _super28.call(this, \"ChromaticAberrationEffect\", fragmentShader$f, {\n      vertexShader: vertexShader$6,\n      blendFunction: blendFunction,\n      attributes: EffectAttribute.CONVOLUTION,\n      uniforms: new Map([[\"offset\", new Uniform(offset)]])\n    });\n  }\n  /**\r\n   * The color offset.\r\n   *\r\n   * @type {Vector2}\r\n   */\n\n\n  _createClass(ChromaticAberrationEffect, [{\n    key: \"initialize\",\n\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     */\n    value: function initialize(renderer, alpha) {\n      if (alpha) {\n        this.defines.set(\"ALPHA\", \"1\");\n      } else {\n        this.defines[\"delete\"](\"ALPHA\");\n      }\n    }\n  }, {\n    key: \"offset\",\n    get: function get() {\n      return this.uniforms.get(\"offset\").value;\n    }\n    /**\r\n     * @type {Vector2}\r\n     */\n    ,\n    set: function set(value) {\n      this.uniforms.get(\"offset\").value = value;\n    }\n  }]);\n\n  return ChromaticAberrationEffect;\n}(Effect);\n\nvar fragmentShader$g = \"void mainImage(const in vec4 inputColor,const in vec2 uv,const in float depth,out vec4 outputColor){\\n#ifdef INVERTED\\nvec3 color=vec3(1.0-depth);\\n#else\\nvec3 color=vec3(depth);\\n#endif\\noutputColor=vec4(color,inputColor.a);}\";\n/**\r\n * A depth visualization effect.\r\n *\r\n * Useful for debugging.\r\n */\n\nvar DepthEffect = /*#__PURE__*/function (_Effect7) {\n  _inherits(DepthEffect, _Effect7);\n\n  var _super29 = _createSuper(DepthEffect);\n\n  /**\r\n   * Constructs a new depth effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Boolean} [options.inverted=false] - Whether the depth values should be inverted.\r\n   */\n  function DepthEffect() {\n    var _this19;\n\n    var _ref11 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref11$blendFunction = _ref11.blendFunction,\n        blendFunction = _ref11$blendFunction === void 0 ? BlendFunction.NORMAL : _ref11$blendFunction,\n        _ref11$inverted = _ref11.inverted,\n        inverted = _ref11$inverted === void 0 ? false : _ref11$inverted;\n\n    _classCallCheck(this, DepthEffect);\n\n    _this19 = _super29.call(this, \"DepthEffect\", fragmentShader$g, {\n      blendFunction: blendFunction,\n      attributes: EffectAttribute.DEPTH\n    });\n    _this19.inverted = inverted;\n    return _this19;\n  }\n  /**\r\n   * Indicates whether depth will be inverted.\r\n   *\r\n   * @type {Boolean}\r\n   */\n\n\n  _createClass(DepthEffect, [{\n    key: \"inverted\",\n    get: function get() {\n      return this.defines.has(\"INVERTED\");\n    }\n    /**\r\n     * Enables or disables depth inversion.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.set(\"INVERTED\", \"1\") : this.defines[\"delete\"](\"INVERTED\");\n    }\n  }]);\n\n  return DepthEffect;\n}(Effect);\n\nvar fragmentShader$h = \"uniform vec2 angle;uniform float scale;float pattern(const in vec2 uv){vec2 point=scale*vec2(dot(angle.yx,vec2(uv.x,-uv.y)),dot(angle,uv));return(sin(point.x)*sin(point.y))*4.0;}void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec3 color=vec3(inputColor.rgb*10.0-5.0+pattern(uv*resolution));outputColor=vec4(color,inputColor.a);}\";\n/**\r\n * A dot screen effect.\r\n */\n\nvar DotScreenEffect = /*#__PURE__*/function (_Effect8) {\n  _inherits(DotScreenEffect, _Effect8);\n\n  var _super30 = _createSuper(DotScreenEffect);\n\n  /**\r\n   * Constructs a new dot screen effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Number} [options.angle=1.57] - The angle of the dot pattern.\r\n   * @param {Number} [options.scale=1.0] - The scale of the dot pattern.\r\n   */\n  function DotScreenEffect() {\n    var _this20;\n\n    var _ref12 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref12$blendFunction = _ref12.blendFunction,\n        blendFunction = _ref12$blendFunction === void 0 ? BlendFunction.NORMAL : _ref12$blendFunction,\n        _ref12$angle = _ref12.angle,\n        angle = _ref12$angle === void 0 ? Math.PI * 0.5 : _ref12$angle,\n        _ref12$scale = _ref12.scale,\n        scale = _ref12$scale === void 0 ? 1.0 : _ref12$scale;\n\n    _classCallCheck(this, DotScreenEffect);\n\n    _this20 = _super30.call(this, \"DotScreenEffect\", fragmentShader$h, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"angle\", new Uniform(new Vector2$1())], [\"scale\", new Uniform(scale)]])\n    });\n\n    _this20.setAngle(angle);\n\n    return _this20;\n  }\n  /**\r\n   * Sets the pattern angle.\r\n   *\r\n   * @param {Number} [angle] - The angle of the dot pattern.\r\n   */\n\n\n  _createClass(DotScreenEffect, [{\n    key: \"setAngle\",\n    value: function setAngle(angle) {\n      this.uniforms.get(\"angle\").value.set(Math.sin(angle), Math.cos(angle));\n    }\n  }]);\n\n  return DotScreenEffect;\n}(Effect);\n\nvar fragmentShader$i = \"uniform float gamma;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){outputColor=LinearToGamma(max(inputColor,0.0),gamma);}\";\n/**\r\n * A gamma correction effect.\r\n */\n\nvar GammaCorrectionEffect = /*#__PURE__*/function (_Effect9) {\n  _inherits(GammaCorrectionEffect, _Effect9);\n\n  var _super31 = _createSuper(GammaCorrectionEffect);\n\n  /**\r\n   * Constructs a new gamma correction effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Number} [options.gamma=2.0] - The gamma factor.\r\n   */\n  function GammaCorrectionEffect() {\n    var _ref13 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref13$blendFunction = _ref13.blendFunction,\n        blendFunction = _ref13$blendFunction === void 0 ? BlendFunction.NORMAL : _ref13$blendFunction,\n        _ref13$gamma = _ref13.gamma,\n        gamma = _ref13$gamma === void 0 ? 2.0 : _ref13$gamma;\n\n    _classCallCheck(this, GammaCorrectionEffect);\n\n    return _super31.call(this, \"GammaCorrectionEffect\", fragmentShader$i, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"gamma\", new Uniform(gamma)]])\n    });\n  }\n\n  return GammaCorrectionEffect;\n}(Effect);\n\nvar fragmentShader$j = \"uniform sampler2D perturbationMap;uniform bool active;uniform float columns;uniform float random;uniform vec2 seed;uniform vec2 distortion;void mainUv(inout vec2 uv){if(active){if(uv.y<distortion.x+columns&&uv.y>distortion.x-columns*random){float sx=clamp(ceil(seed.x),0.0,1.0);uv.y=sx*(1.0-(uv.y+distortion.y))+(1.0-sx)*distortion.y;}if(uv.x<distortion.y+columns&&uv.x>distortion.y-columns*random){float sy=clamp(ceil(seed.y),0.0,1.0);uv.x=sy*distortion.x+(1.0-sy)*(1.0-(uv.x+distortion.x));}vec2 normal=texture2D(perturbationMap,uv*random*random).rg;uv+=normal*seed*(random*0.2);}}\";\n/**\r\n * A label for generated data textures.\r\n *\r\n * @type {String}\r\n * @private\r\n */\n\nvar tag = \"Glitch.Generated\";\n/**\r\n * Returns a random float in the specified range.\r\n *\r\n * @private\r\n * @param {Number} low - The lowest possible value.\r\n * @param {Number} high - The highest possible value.\r\n * @return {Number} The random value.\r\n */\n\nfunction randomFloat(low, high) {\n  return low + Math.random() * (high - low);\n}\n/**\r\n * A glitch effect.\r\n *\r\n * This effect can influence the {@link ChromaticAberrationEffect}.\r\n *\r\n * Reference: https://github.com/staffantan/unityglitch\r\n *\r\n * Warning: This effect cannot be merged with convolution effects.\r\n */\n\n\nvar GlitchEffect = /*#__PURE__*/function (_Effect10) {\n  _inherits(GlitchEffect, _Effect10);\n\n  var _super32 = _createSuper(GlitchEffect);\n\n  /**\r\n   * Constructs a new glitch effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Vector2} [options.chromaticAberrationOffset] - A chromatic aberration offset. If provided, the glitch effect will influence this offset.\r\n   * @param {Vector2} [options.delay] - The minimum and maximum delay between glitch activations in seconds.\r\n   * @param {Vector2} [options.duration] - The minimum and maximum duration of a glitch in seconds.\r\n   * @param {Vector2} [options.strength] - The strength of weak and strong glitches.\r\n   * @param {Texture} [options.perturbationMap] - A perturbation map. If none is provided, a noise texture will be created.\r\n   * @param {Number} [options.dtSize=64] - The size of the generated noise map. Will be ignored if a perturbation map is provided.\r\n   * @param {Number} [options.columns=0.05] - The scale of the blocky glitch columns.\r\n   * @param {Number} [options.ratio=0.85] - The threshold for strong glitches.\r\n   */\n  function GlitchEffect() {\n    var _this21;\n\n    var _ref14 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref14$blendFunction = _ref14.blendFunction,\n        blendFunction = _ref14$blendFunction === void 0 ? BlendFunction.NORMAL : _ref14$blendFunction,\n        _ref14$chromaticAberr = _ref14.chromaticAberrationOffset,\n        chromaticAberrationOffset = _ref14$chromaticAberr === void 0 ? null : _ref14$chromaticAberr,\n        _ref14$delay = _ref14.delay,\n        delay = _ref14$delay === void 0 ? new Vector2$1(1.5, 3.5) : _ref14$delay,\n        _ref14$duration = _ref14.duration,\n        duration = _ref14$duration === void 0 ? new Vector2$1(0.6, 1.0) : _ref14$duration,\n        _ref14$strength = _ref14.strength,\n        strength = _ref14$strength === void 0 ? new Vector2$1(0.3, 1.0) : _ref14$strength,\n        _ref14$columns = _ref14.columns,\n        columns = _ref14$columns === void 0 ? 0.05 : _ref14$columns,\n        _ref14$ratio = _ref14.ratio,\n        ratio = _ref14$ratio === void 0 ? 0.85 : _ref14$ratio,\n        _ref14$perturbationMa = _ref14.perturbationMap,\n        perturbationMap = _ref14$perturbationMa === void 0 ? null : _ref14$perturbationMa,\n        _ref14$dtSize = _ref14.dtSize,\n        dtSize = _ref14$dtSize === void 0 ? 64 : _ref14$dtSize;\n\n    _classCallCheck(this, GlitchEffect);\n\n    _this21 = _super32.call(this, \"GlitchEffect\", fragmentShader$j, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"perturbationMap\", new Uniform(null)], [\"columns\", new Uniform(columns)], [\"active\", new Uniform(false)], [\"random\", new Uniform(0.02)], [\"seed\", new Uniform(new Vector2$1())], [\"distortion\", new Uniform(new Vector2$1())]])\n    });\n    /**\r\n     * The current perturbation map.\r\n     *\r\n     * @type {Texture}\r\n     * @private\r\n     */\n\n    _this21.perturbationMap = null;\n\n    _this21.setPerturbationMap(perturbationMap === null ? _this21.generatePerturbationMap(dtSize) : perturbationMap);\n\n    _this21.perturbationMap.generateMipmaps = false;\n    /**\r\n     * The minimum and maximum delay between glitch activations in seconds.\r\n     *\r\n     * @type {Vector2}\r\n     */\n\n    _this21.delay = delay;\n    /**\r\n     * The minimum and maximum duration of a glitch in seconds.\r\n     *\r\n     * @type {Vector2}\r\n     */\n\n    _this21.duration = duration;\n    /**\r\n     * A random glitch break point.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this21.breakPoint = new Vector2$1(randomFloat(_this21.delay.x, _this21.delay.y), randomFloat(_this21.duration.x, _this21.duration.y));\n    /**\r\n     * A time accumulator.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this21.time = 0;\n    /**\r\n     * Random seeds.\r\n     *\r\n     * @type {Vector2}\r\n     * @private\r\n     */\n\n    _this21.seed = _this21.uniforms.get(\"seed\").value;\n    /**\r\n     * A distortion vector.\r\n     *\r\n     * @type {Vector2}\r\n     * @private\r\n     */\n\n    _this21.distortion = _this21.uniforms.get(\"distortion\").value;\n    /**\r\n     * The effect mode.\r\n     *\r\n     * @type {GlitchMode}\r\n     */\n\n    _this21.mode = GlitchMode.SPORADIC;\n    /**\r\n     * The strength of weak and strong glitches.\r\n     *\r\n     * @type {Vector2}\r\n     */\n\n    _this21.strength = strength;\n    /**\r\n     * The threshold for strong glitches, ranging from 0 to 1 where 0 means no\r\n     * weak glitches and 1 means no strong ones. The default ratio of 0.85\r\n     * offers a decent balance.\r\n     *\r\n     * @type {Number}\r\n     */\n\n    _this21.ratio = ratio;\n    /**\r\n     * The chromatic aberration offset.\r\n     *\r\n     * @type {Vector2}\r\n     */\n\n    _this21.chromaticAberrationOffset = chromaticAberrationOffset;\n    return _this21;\n  }\n  /**\r\n   * Indicates whether the glitch effect is currently active.\r\n   *\r\n   * @type {Boolean}\r\n   */\n\n\n  _createClass(GlitchEffect, [{\n    key: \"getPerturbationMap\",\n\n    /**\r\n     * Returns the current perturbation map.\r\n     *\r\n     * @return {Texture} The current perturbation map.\r\n     */\n    value: function getPerturbationMap() {\n      return this.perturbationMap;\n    }\n    /**\r\n     * Replaces the current perturbation map with the given one.\r\n     *\r\n     * The current map will be disposed if it was generated by this effect.\r\n     *\r\n     * @param {Texture} perturbationMap - The new perturbation map.\r\n     */\n\n  }, {\n    key: \"setPerturbationMap\",\n    value: function setPerturbationMap(perturbationMap) {\n      if (this.perturbationMap !== null && this.perturbationMap.name === tag) {\n        this.perturbationMap.dispose();\n      }\n\n      perturbationMap.wrapS = perturbationMap.wrapT = RepeatWrapping;\n      perturbationMap.magFilter = perturbationMap.minFilter = NearestFilter;\n      this.perturbationMap = perturbationMap;\n      this.uniforms.get(\"perturbationMap\").value = perturbationMap;\n    }\n    /**\r\n     * Generates a perturbation map.\r\n     *\r\n     * @param {Number} [size=64] - The texture size.\r\n     * @return {DataTexture} The perturbation map.\r\n     */\n\n  }, {\n    key: \"generatePerturbationMap\",\n    value: function generatePerturbationMap() {\n      var size = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 64;\n      var pixels = size * size;\n      var data = new Uint8Array(pixels * 3);\n      var i, l, x;\n\n      for (i = 0, l = data.length; i < l; i += 3) {\n        x = Math.random() * 255;\n        data[i] = x;\n        data[i + 1] = x;\n        data[i + 2] = x;\n      }\n\n      var map = new DataTexture(data, size, size, RGBFormat);\n      map.name = tag;\n      map.needsUpdate = true;\n      return map;\n    }\n    /**\r\n     * Updates this effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     */\n\n  }, {\n    key: \"update\",\n    value: function update(renderer, inputBuffer, deltaTime) {\n      var mode = this.mode;\n      var breakPoint = this.breakPoint;\n      var offset = this.chromaticAberrationOffset;\n      var s = this.strength;\n      var time = this.time;\n      var active = false;\n      var r = 0.0,\n          a = 0.0;\n      var trigger;\n\n      if (mode !== GlitchMode.DISABLED) {\n        if (mode === GlitchMode.SPORADIC) {\n          time += deltaTime;\n          trigger = time > breakPoint.x;\n\n          if (time >= breakPoint.x + breakPoint.y) {\n            breakPoint.set(randomFloat(this.delay.x, this.delay.y), randomFloat(this.duration.x, this.duration.y));\n            time = 0;\n          }\n        }\n\n        r = Math.random();\n        this.uniforms.get(\"random\").value = r;\n\n        if (trigger && r > this.ratio || mode === GlitchMode.CONSTANT_WILD) {\n          active = true;\n          r *= s.y * 0.03;\n          a = randomFloat(-Math.PI, Math.PI);\n          this.seed.set(randomFloat(-s.y, s.y), randomFloat(-s.y, s.y));\n          this.distortion.set(randomFloat(0.0, 1.0), randomFloat(0.0, 1.0));\n        } else if (trigger || mode === GlitchMode.CONSTANT_MILD) {\n          active = true;\n          r *= s.x * 0.03;\n          a = randomFloat(-Math.PI, Math.PI);\n          this.seed.set(randomFloat(-s.x, s.x), randomFloat(-s.x, s.x));\n          this.distortion.set(randomFloat(0.0, 1.0), randomFloat(0.0, 1.0));\n        }\n\n        this.time = time;\n      }\n\n      if (offset !== null) {\n        if (active) {\n          offset.set(Math.cos(a), Math.sin(a)).multiplyScalar(r);\n        } else {\n          offset.set(0.0, 0.0);\n        }\n      }\n\n      this.uniforms.get(\"active\").value = active;\n    }\n  }, {\n    key: \"active\",\n    get: function get() {\n      return this.uniforms.get(\"active\").value;\n    }\n  }]);\n\n  return GlitchEffect;\n}(Effect);\n/**\r\n * A glitch mode enumeration.\r\n *\r\n * @type {Object}\r\n * @property {Number} DISABLED - No glitches.\r\n * @property {Number} SPORADIC - Sporadic glitches.\r\n * @property {Number} CONSTANT_MILD - Constant mild glitches.\r\n * @property {Number} CONSTANT_WILD - Constant wild glitches.\r\n */\n\n\nvar GlitchMode = {\n  DISABLED: 0,\n  SPORADIC: 1,\n  CONSTANT_MILD: 2,\n  CONSTANT_WILD: 3\n};\n/**\r\n * A vector.\r\n *\r\n * @type {Vector3}\r\n * @private\r\n */\n\nvar v = new Vector3();\n/**\r\n * A matrix.\r\n *\r\n * @type {Matrix4}\r\n * @private\r\n */\n\nvar m = new Matrix4();\n/**\r\n * A god rays effect.\r\n */\n\nvar GodRaysEffect = /*#__PURE__*/function (_Effect11) {\n  _inherits(GodRaysEffect, _Effect11);\n\n  var _super33 = _createSuper(GodRaysEffect);\n\n  /**\r\n   * Constructs a new god rays effect.\r\n   *\r\n   * @param {Camera} camera - The main camera.\r\n   * @param {Mesh|Points} lightSource - The light source. Must not write depth and has to be flagged as transparent.\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function of this effect.\r\n   * @param {Number} [options.samples=60.0] - The number of samples per pixel.\r\n   * @param {Number} [options.density=0.96] - The density of the light rays.\r\n   * @param {Number} [options.decay=0.9] - An illumination decay factor.\r\n   * @param {Number} [options.weight=0.4] - A light ray weight factor.\r\n   * @param {Number} [options.exposure=0.6] - A constant attenuation coefficient.\r\n   * @param {Number} [options.clampMax=1.0] - An upper bound for the saturation of the overall effect.\r\n   * @param {Number} [options.resolutionScale=0.5] - Deprecated. Use height or width instead.\r\n   * @param {Number} [options.width=Resizer.AUTO_SIZE] - The render width.\r\n   * @param {Number} [options.height=Resizer.AUTO_SIZE] - The render height.\r\n   * @param {KernelSize} [options.kernelSize=KernelSize.SMALL] - The blur kernel size. Has no effect if blur is disabled.\r\n   * @param {Number} [options.blur=true] - Whether the god rays should be blurred to reduce artifacts.\r\n   */\n  function GodRaysEffect(camera, lightSource) {\n    var _this22;\n\n    var _ref15 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n        _ref15$blendFunction = _ref15.blendFunction,\n        blendFunction = _ref15$blendFunction === void 0 ? BlendFunction.SCREEN : _ref15$blendFunction,\n        _ref15$samples = _ref15.samples,\n        samples = _ref15$samples === void 0 ? 60.0 : _ref15$samples,\n        _ref15$density = _ref15.density,\n        density = _ref15$density === void 0 ? 0.96 : _ref15$density,\n        _ref15$decay = _ref15.decay,\n        decay = _ref15$decay === void 0 ? 0.9 : _ref15$decay,\n        _ref15$weight = _ref15.weight,\n        weight = _ref15$weight === void 0 ? 0.4 : _ref15$weight,\n        _ref15$exposure = _ref15.exposure,\n        exposure = _ref15$exposure === void 0 ? 0.6 : _ref15$exposure,\n        _ref15$clampMax = _ref15.clampMax,\n        clampMax = _ref15$clampMax === void 0 ? 1.0 : _ref15$clampMax,\n        _ref15$resolutionScal = _ref15.resolutionScale,\n        resolutionScale = _ref15$resolutionScal === void 0 ? 0.5 : _ref15$resolutionScal,\n        _ref15$width = _ref15.width,\n        width = _ref15$width === void 0 ? Resizer.AUTO_SIZE : _ref15$width,\n        _ref15$height = _ref15.height,\n        height = _ref15$height === void 0 ? Resizer.AUTO_SIZE : _ref15$height,\n        _ref15$kernelSize = _ref15.kernelSize,\n        kernelSize = _ref15$kernelSize === void 0 ? KernelSize.SMALL : _ref15$kernelSize,\n        _ref15$blur = _ref15.blur,\n        blur = _ref15$blur === void 0 ? true : _ref15$blur;\n\n    _classCallCheck(this, GodRaysEffect);\n\n    _this22 = _super33.call(this, \"GodRaysEffect\", fragmentShader$a, {\n      blendFunction: blendFunction,\n      attributes: EffectAttribute.DEPTH,\n      uniforms: new Map([[\"texture\", new Uniform(null)]])\n    });\n    /**\r\n     * The main camera.\r\n     *\r\n     * @type {Camera}\r\n     * @private\r\n     */\n\n    _this22.camera = camera;\n    /**\r\n     * The light source.\r\n     *\r\n     * @type {Mesh|Points}\r\n     * @private\r\n     */\n\n    _this22.lightSource = lightSource;\n    _this22.lightSource.material.depthWrite = false;\n    _this22.lightSource.material.transparent = true;\n    /**\r\n     * A scene that only contains the light source.\r\n     *\r\n     * @type {Scene}\r\n     * @private\r\n     */\n\n    _this22.lightScene = new Scene();\n    /**\r\n     * The light position in screen space.\r\n     *\r\n     * @type {Vector3}\r\n     * @private\r\n     */\n\n    _this22.screenPosition = new Vector2$1();\n    /**\r\n     * A render target.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this22.renderTargetA = new WebGLRenderTarget(1, 1, {\n      minFilter: LinearFilter,\n      magFilter: LinearFilter,\n      stencilBuffer: false,\n      depthBuffer: false\n    });\n    _this22.renderTargetA.texture.name = \"GodRays.TargetX\";\n    /**\r\n     * A render target.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this22.renderTargetB = _this22.renderTargetA.clone();\n    _this22.renderTargetB.texture.name = \"GodRays.TargetY\";\n    _this22.uniforms.get(\"texture\").value = _this22.renderTargetB.texture;\n    /**\r\n     * A render target for the light scene.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this22.renderTargetLight = _this22.renderTargetA.clone();\n    _this22.renderTargetLight.texture.name = \"GodRays.Light\";\n    _this22.renderTargetLight.depthBuffer = true;\n    _this22.renderTargetLight.depthTexture = new DepthTexture();\n    /**\r\n     * A pass that only renders the light source.\r\n     *\r\n     * @type {RenderPass}\r\n     * @private\r\n     */\n\n    _this22.renderPassLight = new RenderPass(_this22.lightScene, camera);\n    _this22.renderPassLight.getClearPass().overrideClearColor = new Color(0x000000);\n    /**\r\n     * A clear pass.\r\n     *\r\n     * @type {ClearPass}\r\n     * @private\r\n     */\n\n    _this22.clearPass = new ClearPass(true, false, false);\n    /**\r\n     * A blur pass that reduces aliasing artifacts and makes the light softer.\r\n     *\r\n     * Disable this pass to improve performance.\r\n     *\r\n     * @type {BlurPass}\r\n     */\n\n    _this22.blurPass = new BlurPass({\n      resolutionScale: resolutionScale,\n      width: width,\n      height: height,\n      kernelSize: kernelSize\n    });\n    _this22.blurPass.resolution.resizable = _assertThisInitialized(_this22);\n    /**\r\n     * A depth mask pass.\r\n     *\r\n     * @type {ShaderPass}\r\n     * @private\r\n     */\n\n    _this22.depthMaskPass = new ShaderPass(function (depthTexture) {\n      var material = new DepthMaskMaterial();\n      material.uniforms.depthBuffer1.value = depthTexture;\n      return material;\n    }(_this22.renderTargetLight.depthTexture));\n    /**\r\n     * A god rays blur pass.\r\n     *\r\n     * @type {ShaderPass}\r\n     * @private\r\n     */\n\n    _this22.godRaysPass = new ShaderPass(function () {\n      var material = new GodRaysMaterial(_this22.screenPosition);\n      material.uniforms.density.value = density;\n      material.uniforms.decay.value = decay;\n      material.uniforms.weight.value = weight;\n      material.uniforms.exposure.value = exposure;\n      material.uniforms.clampMax.value = clampMax;\n      return material;\n    }());\n    _this22.samples = samples;\n    _this22.blur = blur;\n    return _this22;\n  }\n  /**\r\n   * A texture that contains the intermediate result of this effect.\r\n   *\r\n   * This texture will be applied to the scene colors unless the blend function\r\n   * is set to `SKIP`.\r\n   *\r\n   * @type {Texture}\r\n   */\n\n\n  _createClass(GodRaysEffect, [{\n    key: \"getResolutionScale\",\n\n    /**\r\n     * Returns the current resolution scale.\r\n     *\r\n     * @return {Number} The resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n    value: function getResolutionScale() {\n      return this.resolution.scale;\n    }\n    /**\r\n     * Sets the resolution scale.\r\n     *\r\n     * @param {Number} scale - The new resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n\n  }, {\n    key: \"setResolutionScale\",\n    value: function setResolutionScale(scale) {\n      this.resolution.scale = scale;\n      this.setSize(this.resolution.base.x, this.resolution.base.y);\n    }\n    /**\r\n     * The number of samples per pixel.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"setDepthTexture\",\n\n    /**\r\n     * Sets the depth texture.\r\n     *\r\n     * @param {Texture} depthTexture - A depth texture.\r\n     * @param {Number} [depthPacking=0] - The depth packing.\r\n     */\n    value: function setDepthTexture(depthTexture) {\n      var depthPacking = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n      var material = this.depthMaskPass.getFullscreenMaterial();\n      material.uniforms.depthBuffer0.value = depthTexture;\n      material.defines.DEPTH_PACKING_0 = depthPacking.toFixed(0);\n    }\n    /**\r\n     * Updates this effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     */\n\n  }, {\n    key: \"update\",\n    value: function update(renderer, inputBuffer, deltaTime) {\n      var lightSource = this.lightSource;\n      var parent = lightSource.parent;\n      var matrixAutoUpdate = lightSource.matrixAutoUpdate;\n      var renderTargetA = this.renderTargetA;\n      var renderTargetLight = this.renderTargetLight;\n\n      if (!matrixAutoUpdate) {\n        // Remember the local transformation to restore it later.\n        m.copy(lightSource.matrix);\n      } // Enable depth write for the light scene render pass.\n\n\n      lightSource.material.depthWrite = true; // The light source may be inside a group; apply all transformations.\n\n      lightSource.matrixAutoUpdate = false;\n      lightSource.updateWorldMatrix(true, false);\n      lightSource.matrix.copy(lightSource.matrixWorld); // Render the light source and mask it based on depth.\n\n      this.lightScene.add(lightSource);\n      this.renderPassLight.render(renderer, renderTargetLight);\n      this.clearPass.render(renderer, renderTargetA);\n      this.depthMaskPass.render(renderer, renderTargetLight, renderTargetA); // Restore the original values.\n\n      lightSource.material.depthWrite = false;\n      lightSource.matrixAutoUpdate = matrixAutoUpdate;\n\n      if (!matrixAutoUpdate) {\n        lightSource.matrix.copy(m);\n      }\n\n      if (parent !== null) {\n        parent.add(lightSource);\n      } // Calculate the screen light position and translate it to [0.0, 1.0].\n\n\n      v.setFromMatrixPosition(lightSource.matrixWorld).project(this.camera);\n      this.screenPosition.set(Math.max(0.0, Math.min(1.0, (v.x + 1.0) * 0.5)), Math.max(0.0, Math.min(1.0, (v.y + 1.0) * 0.5)));\n\n      if (this.blur) {\n        // Blur the masked scene to reduce artifacts.\n        this.blurPass.render(renderer, renderTargetA, renderTargetA);\n      } // Blur the masked scene along radial lines towards the light source.\n\n\n      this.godRaysPass.render(renderer, renderTargetA, this.renderTargetB);\n    }\n    /**\r\n     * Updates the size of internal render targets.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.blurPass.setSize(width, height);\n      this.renderPassLight.setSize(width, height);\n      this.depthMaskPass.setSize(width, height);\n      this.godRaysPass.setSize(width, height);\n      width = this.resolution.width;\n      height = this.resolution.height;\n      this.renderTargetA.setSize(width, height);\n      this.renderTargetB.setSize(width, height);\n      this.renderTargetLight.setSize(width, height);\n    }\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {\n      this.blurPass.initialize(renderer, alpha);\n      this.renderPassLight.initialize(renderer, alpha);\n      this.depthMaskPass.initialize(renderer, alpha);\n      this.godRaysPass.initialize(renderer, alpha);\n\n      if (!alpha) {\n        this.renderTargetA.texture.format = RGBFormat;\n        this.renderTargetB.texture.format = RGBFormat;\n        this.renderTargetLight.texture.format = RGBFormat;\n      }\n    }\n  }, {\n    key: \"texture\",\n    get: function get() {\n      return this.renderTargetB.texture;\n    }\n    /**\r\n     * The internal god rays material.\r\n     *\r\n     * @type {GodRaysMaterial}\r\n     */\n\n  }, {\n    key: \"godRaysMaterial\",\n    get: function get() {\n      return this.godRaysPass.getFullscreenMaterial();\n    }\n    /**\r\n     * The resolution of this effect.\r\n     *\r\n     * @type {Resizer}\r\n     */\n\n  }, {\n    key: \"resolution\",\n    get: function get() {\n      return this.blurPass.resolution;\n    }\n    /**\r\n     * The current width of the internal render targets.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.width instead.\r\n     */\n\n  }, {\n    key: \"width\",\n    get: function get() {\n      return this.resolution.width;\n    }\n    /**\r\n     * Sets the render width.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.width instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.resolution.width = value;\n    }\n    /**\r\n     * The current height of the internal render targets.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.height instead.\r\n     */\n\n  }, {\n    key: \"height\",\n    get: function get() {\n      return this.resolution.height;\n    }\n    /**\r\n     * Sets the render height.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.height instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.resolution.height = value;\n    }\n    /**\r\n     * Indicates whether dithering is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"dithering\",\n    get: function get() {\n      return this.godRaysMaterial.dithering;\n    }\n    /**\r\n     * Enables or disables dithering.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      var material = this.godRaysMaterial;\n      material.dithering = value;\n      material.needsUpdate = true;\n    }\n    /**\r\n     * Indicates whether the god rays should be blurred to reduce artifacts.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"blur\",\n    get: function get() {\n      return this.blurPass.enabled;\n    }\n    /**\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      this.blurPass.enabled = value;\n    }\n    /**\r\n     * The blur kernel size.\r\n     *\r\n     * @type {KernelSize}\r\n     * @deprecated Use blurPass.kernelSize instead.\r\n     */\n\n  }, {\n    key: \"kernelSize\",\n    get: function get() {\n      return this.blurPass.kernelSize;\n    }\n    /**\r\n     * Sets the blur kernel size.\r\n     *\r\n     * @type {KernelSize}\r\n     * @deprecated Use blurPass.kernelSize instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.blurPass.kernelSize = value;\n    }\n  }, {\n    key: \"samples\",\n    get: function get() {\n      return this.godRaysMaterial.samples;\n    }\n    /**\r\n     * A higher sample count improves quality at the cost of performance.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.godRaysMaterial.samples = value;\n    }\n  }]);\n\n  return GodRaysEffect;\n}(Effect);\n\nvar fragmentShader$k = \"uniform vec2 scale;uniform float lineWidth;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){float grid=0.5-max(abs(mod(uv.x*scale.x,1.0)-0.5),abs(mod(uv.y*scale.y,1.0)-0.5));outputColor=vec4(vec3(smoothstep(0.0,lineWidth,grid)),inputColor.a);}\";\n/**\r\n * A grid effect.\r\n */\n\nvar GridEffect = /*#__PURE__*/function (_Effect12) {\n  _inherits(GridEffect, _Effect12);\n\n  var _super34 = _createSuper(GridEffect);\n\n  /**\r\n   * Constructs a new grid effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.OVERLAY] - The blend function of this effect.\r\n   * @param {Number} [options.scale=1.0] - The scale of the grid pattern.\r\n   * @param {Number} [options.lineWidth=0.0] - The line width of the grid pattern.\r\n   */\n  function GridEffect() {\n    var _this23;\n\n    var _ref16 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref16$blendFunction = _ref16.blendFunction,\n        blendFunction = _ref16$blendFunction === void 0 ? BlendFunction.OVERLAY : _ref16$blendFunction,\n        _ref16$scale = _ref16.scale,\n        scale = _ref16$scale === void 0 ? 1.0 : _ref16$scale,\n        _ref16$lineWidth = _ref16.lineWidth,\n        lineWidth = _ref16$lineWidth === void 0 ? 0.0 : _ref16$lineWidth;\n\n    _classCallCheck(this, GridEffect);\n\n    _this23 = _super34.call(this, \"GridEffect\", fragmentShader$k, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"scale\", new Uniform(new Vector2$1())], [\"lineWidth\", new Uniform(lineWidth)]])\n    });\n    /**\r\n     * The original resolution.\r\n     *\r\n     * @type {Vector2}\r\n     * @private\r\n     */\n\n    _this23.resolution = new Vector2$1();\n    /**\r\n     * The grid scale, relative to the screen height.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this23.scale = Math.max(scale, 1e-6);\n    /**\r\n     * The grid line width.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this23.lineWidth = Math.max(lineWidth, 0.0);\n    return _this23;\n  }\n  /**\r\n   * Returns the current grid scale.\r\n   *\r\n   * @return {Number} The grid scale.\r\n   */\n\n\n  _createClass(GridEffect, [{\n    key: \"getScale\",\n    value: function getScale() {\n      return this.scale;\n    }\n    /**\r\n     * Sets the grid scale.\r\n     *\r\n     * @param {Number} scale - The new grid scale.\r\n     */\n\n  }, {\n    key: \"setScale\",\n    value: function setScale(scale) {\n      this.scale = scale;\n      this.setSize(this.resolution.x, this.resolution.y);\n    }\n    /**\r\n     * Returns the current grid line width.\r\n     *\r\n     * @return {Number} The grid line width.\r\n     */\n\n  }, {\n    key: \"getLineWidth\",\n    value: function getLineWidth() {\n      return this.lineWidth;\n    }\n    /**\r\n     * Sets the grid line width.\r\n     *\r\n     * @param {Number} lineWidth - The new grid line width.\r\n     */\n\n  }, {\n    key: \"setLineWidth\",\n    value: function setLineWidth(lineWidth) {\n      this.lineWidth = lineWidth;\n      this.setSize(this.resolution.x, this.resolution.y);\n    }\n    /**\r\n     * Updates the size of this pass.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.resolution.set(width, height);\n      var aspect = width / height;\n      var scale = this.scale * (height * 0.125);\n      this.uniforms.get(\"scale\").value.set(aspect * scale, scale);\n      this.uniforms.get(\"lineWidth\").value = scale / height + this.lineWidth;\n    }\n  }]);\n\n  return GridEffect;\n}(Effect);\n\nvar fragmentShader$l = \"uniform vec3 hue;uniform float saturation;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec3 color=vec3(dot(inputColor.rgb,hue.xyz),dot(inputColor.rgb,hue.zxy),dot(inputColor.rgb,hue.yzx));float average=(color.r+color.g+color.b)/3.0;vec3 diff=average-color;if(saturation>0.0){color+=diff*(1.0-1.0/(1.001-saturation));}else{color+=diff*-saturation;}outputColor=vec4(min(color,1.0),inputColor.a);}\";\n/**\r\n * A hue/saturation effect.\r\n *\r\n * Reference: https://github.com/evanw/glfx.js\r\n */\n\nvar HueSaturationEffect = /*#__PURE__*/function (_Effect13) {\n  _inherits(HueSaturationEffect, _Effect13);\n\n  var _super35 = _createSuper(HueSaturationEffect);\n\n  /**\r\n   * Constructs a new hue/saturation effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Number} [options.hue=0.0] - The hue in radians.\r\n   * @param {Number} [options.saturation=0.0] - The saturation factor, ranging from -1 to 1, where 0 means no change.\r\n   */\n  function HueSaturationEffect() {\n    var _this24;\n\n    var _ref17 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref17$blendFunction = _ref17.blendFunction,\n        blendFunction = _ref17$blendFunction === void 0 ? BlendFunction.NORMAL : _ref17$blendFunction,\n        _ref17$hue = _ref17.hue,\n        hue = _ref17$hue === void 0 ? 0.0 : _ref17$hue,\n        _ref17$saturation = _ref17.saturation,\n        saturation = _ref17$saturation === void 0 ? 0.0 : _ref17$saturation;\n\n    _classCallCheck(this, HueSaturationEffect);\n\n    _this24 = _super35.call(this, \"HueSaturationEffect\", fragmentShader$l, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"hue\", new Uniform(new Vector3())], [\"saturation\", new Uniform(saturation)]])\n    });\n\n    _this24.setHue(hue);\n\n    return _this24;\n  }\n  /**\r\n   * Sets the hue.\r\n   *\r\n   * @param {Number} hue - The hue in radians.\r\n   */\n\n\n  _createClass(HueSaturationEffect, [{\n    key: \"setHue\",\n    value: function setHue(hue) {\n      var s = Math.sin(hue),\n          c = Math.cos(hue);\n      this.uniforms.get(\"hue\").value.set(2.0 * c, -Math.sqrt(3.0) * s - c, Math.sqrt(3.0) * s - c).addScalar(1.0).divideScalar(3.0);\n    }\n  }]);\n\n  return HueSaturationEffect;\n}(Effect);\n\nvar fragmentShader$m = \"void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec3 noise=vec3(rand(uv*time));\\n#ifdef PREMULTIPLY\\noutputColor=vec4(inputColor.rgb*noise,inputColor.a);\\n#else\\noutputColor=vec4(noise,inputColor.a);\\n#endif\\n}\";\n/**\r\n * A noise effect.\r\n */\n\nvar NoiseEffect = /*#__PURE__*/function (_Effect14) {\n  _inherits(NoiseEffect, _Effect14);\n\n  var _super36 = _createSuper(NoiseEffect);\n\n  /**\r\n   * Constructs a new noise effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function of this effect.\r\n   * @param {Boolean} [options.premultiply=false] - Whether the noise should be multiplied with the input color.\r\n   */\n  function NoiseEffect() {\n    var _this25;\n\n    var _ref18 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref18$blendFunction = _ref18.blendFunction,\n        blendFunction = _ref18$blendFunction === void 0 ? BlendFunction.SCREEN : _ref18$blendFunction,\n        _ref18$premultiply = _ref18.premultiply,\n        premultiply = _ref18$premultiply === void 0 ? false : _ref18$premultiply;\n\n    _classCallCheck(this, NoiseEffect);\n\n    _this25 = _super36.call(this, \"NoiseEffect\", fragmentShader$m, {\n      blendFunction: blendFunction\n    });\n    _this25.premultiply = premultiply;\n    return _this25;\n  }\n  /**\r\n   * Indicates whether the noise should be multiplied with the input color.\r\n   *\r\n   * @type {Boolean}\r\n   */\n\n\n  _createClass(NoiseEffect, [{\n    key: \"premultiply\",\n    get: function get() {\n      return this.defines.has(\"PREMULTIPLY\");\n    }\n    /**\r\n     * Enables or disables noise premultiplication.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.set(\"PREMULTIPLY\", \"1\") : this.defines[\"delete\"](\"PREMULTIPLY\");\n    }\n  }]);\n\n  return NoiseEffect;\n}(Effect);\n\nvar fragmentShader$n = \"uniform sampler2D edgeTexture;uniform sampler2D maskTexture;uniform vec3 visibleEdgeColor;uniform vec3 hiddenEdgeColor;uniform float pulse;uniform float edgeStrength;\\n#ifdef USE_PATTERN\\nuniform sampler2D patternTexture;varying vec2 vUvPattern;\\n#endif\\nvoid mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec2 edge=texture2D(edgeTexture,uv).rg;vec2 mask=texture2D(maskTexture,uv).rg;\\n#ifndef X_RAY\\nedge.y=0.0;\\n#endif\\nedge*=(edgeStrength*mask.x*pulse);vec3 color=edge.x*visibleEdgeColor+edge.y*hiddenEdgeColor;float visibilityFactor=0.0;\\n#ifdef USE_PATTERN\\nvec4 patternColor=texture2D(patternTexture,vUvPattern);\\n#ifdef X_RAY\\nfloat hiddenFactor=0.5;\\n#else\\nfloat hiddenFactor=0.0;\\n#endif\\nvisibilityFactor=(1.0-mask.y>0.0)? 1.0 : hiddenFactor;visibilityFactor*=(1.0-mask.x)*patternColor.a;color+=visibilityFactor*patternColor.rgb;\\n#endif\\nfloat alpha=max(max(edge.x,edge.y),visibilityFactor);\\n#ifdef ALPHA\\noutputColor=vec4(color,alpha);\\n#else\\noutputColor=vec4(color,max(alpha,inputColor.a));\\n#endif\\n}\";\nvar vertexShader$7 = \"uniform float patternScale;varying vec2 vUvPattern;void mainSupport(const in vec2 uv){vUvPattern=uv*vec2(aspect,1.0)*patternScale;}\";\n/**\r\n * An outline effect.\r\n */\n\nvar OutlineEffect = /*#__PURE__*/function (_Effect15) {\n  _inherits(OutlineEffect, _Effect15);\n\n  var _super37 = _createSuper(OutlineEffect);\n\n  /**\r\n   * Constructs a new outline effect.\r\n   *\r\n   * If you want dark outlines, remember to use an appropriate blend function.\r\n   *\r\n   * @param {Scene} scene - The main scene.\r\n   * @param {Camera} camera - The main camera.\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.SCREEN] - The blend function.  Set this to `BlendFunction.ALPHA` for dark outlines.\r\n   * @param {Number} [options.patternTexture=null] - A pattern texture.\r\n   * @param {Number} [options.edgeStrength=1.0] - The edge strength.\r\n   * @param {Number} [options.pulseSpeed=0.0] - The pulse speed. A value of zero disables the pulse effect.\r\n   * @param {Number} [options.visibleEdgeColor=0xffffff] - The color of visible edges.\r\n   * @param {Number} [options.hiddenEdgeColor=0x22090a] - The color of hidden edges.\r\n   * @param {Number} [options.resolutionScale=0.5] - Deprecated. Use height or width instead.\r\n   * @param {Number} [options.width=Resizer.AUTO_SIZE] - The render width.\r\n   * @param {Number} [options.height=Resizer.AUTO_SIZE] - The render height.\r\n   * @param {KernelSize} [options.kernelSize=KernelSize.VERY_SMALL] - The blur kernel size.\r\n   * @param {Boolean} [options.blur=false] - Whether the outline should be blurred.\r\n   * @param {Boolean} [options.xRay=true] - Whether occluded parts of selected objects should be visible.\r\n   */\n  function OutlineEffect(scene, camera) {\n    var _this26;\n\n    var _ref19 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n        _ref19$blendFunction = _ref19.blendFunction,\n        blendFunction = _ref19$blendFunction === void 0 ? BlendFunction.SCREEN : _ref19$blendFunction,\n        _ref19$patternTexture = _ref19.patternTexture,\n        patternTexture = _ref19$patternTexture === void 0 ? null : _ref19$patternTexture,\n        _ref19$edgeStrength = _ref19.edgeStrength,\n        edgeStrength = _ref19$edgeStrength === void 0 ? 1.0 : _ref19$edgeStrength,\n        _ref19$pulseSpeed = _ref19.pulseSpeed,\n        pulseSpeed = _ref19$pulseSpeed === void 0 ? 0.0 : _ref19$pulseSpeed,\n        _ref19$visibleEdgeCol = _ref19.visibleEdgeColor,\n        visibleEdgeColor = _ref19$visibleEdgeCol === void 0 ? 0xffffff : _ref19$visibleEdgeCol,\n        _ref19$hiddenEdgeColo = _ref19.hiddenEdgeColor,\n        hiddenEdgeColor = _ref19$hiddenEdgeColo === void 0 ? 0x22090a : _ref19$hiddenEdgeColo,\n        _ref19$resolutionScal = _ref19.resolutionScale,\n        resolutionScale = _ref19$resolutionScal === void 0 ? 0.5 : _ref19$resolutionScal,\n        _ref19$width = _ref19.width,\n        width = _ref19$width === void 0 ? Resizer.AUTO_SIZE : _ref19$width,\n        _ref19$height = _ref19.height,\n        height = _ref19$height === void 0 ? Resizer.AUTO_SIZE : _ref19$height,\n        _ref19$kernelSize = _ref19.kernelSize,\n        kernelSize = _ref19$kernelSize === void 0 ? KernelSize.VERY_SMALL : _ref19$kernelSize,\n        _ref19$blur = _ref19.blur,\n        blur = _ref19$blur === void 0 ? false : _ref19$blur,\n        _ref19$xRay = _ref19.xRay,\n        xRay = _ref19$xRay === void 0 ? true : _ref19$xRay;\n\n    _classCallCheck(this, OutlineEffect);\n\n    _this26 = _super37.call(this, \"OutlineEffect\", fragmentShader$n, {\n      uniforms: new Map([[\"maskTexture\", new Uniform(null)], [\"edgeTexture\", new Uniform(null)], [\"edgeStrength\", new Uniform(edgeStrength)], [\"visibleEdgeColor\", new Uniform(new Color(visibleEdgeColor))], [\"hiddenEdgeColor\", new Uniform(new Color(hiddenEdgeColor))], [\"pulse\", new Uniform(1.0)]])\n    }); // Intercept blend function changes.\n\n    _this26.blendMode = function (defines) {\n      return new Proxy(_this26.blendMode, {\n        set: function set(target, name, value) {\n          if (value === BlendFunction.ALPHA) {\n            defines.set(\"ALPHA\", \"1\");\n          } else {\n            defines[\"delete\"](\"ALPHA\");\n          }\n\n          target[name] = value;\n          return true;\n        }\n      });\n    }(_this26.defines);\n\n    _this26.blendMode.blendFunction = blendFunction;\n\n    _this26.setPatternTexture(patternTexture);\n\n    _this26.xRay = xRay;\n    /**\r\n     * The main scene.\r\n     *\r\n     * @type {Scene}\r\n     * @private\r\n     */\n\n    _this26.scene = scene;\n    /**\r\n     * The main camera.\r\n     *\r\n     * @type {Camera}\r\n     * @private\r\n     */\n\n    _this26.camera = camera;\n    /**\r\n     * A render target for the outline mask.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this26.renderTargetMask = new WebGLRenderTarget(1, 1, {\n      minFilter: LinearFilter,\n      magFilter: LinearFilter,\n      stencilBuffer: false,\n      format: RGBFormat\n    });\n    _this26.renderTargetMask.texture.name = \"Outline.Mask\";\n    _this26.uniforms.get(\"maskTexture\").value = _this26.renderTargetMask.texture;\n    /**\r\n     * A render target for the edge detection.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this26.renderTargetEdges = _this26.renderTargetMask.clone();\n    _this26.renderTargetEdges.texture.name = \"Outline.Edges\";\n    _this26.renderTargetEdges.depthBuffer = false;\n    /**\r\n     * A render target for the blurred outline overlay.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this26.renderTargetBlurredEdges = _this26.renderTargetEdges.clone();\n    _this26.renderTargetBlurredEdges.texture.name = \"Outline.BlurredEdges\";\n    /**\r\n     * A clear pass.\r\n     *\r\n     * @type {ClearPass}\r\n     * @private\r\n     */\n\n    _this26.clearPass = new ClearPass();\n    _this26.clearPass.overrideClearColor = new Color(0x000000);\n    _this26.clearPass.overrideClearAlpha = 1.0;\n    /**\r\n     * A depth pass.\r\n     *\r\n     * @type {DepthPass}\r\n     * @private\r\n     */\n\n    _this26.depthPass = new DepthPass(scene, camera);\n    /**\r\n     * A depth comparison mask pass.\r\n     *\r\n     * @type {RenderPass}\r\n     * @private\r\n     */\n\n    _this26.maskPass = new RenderPass(scene, camera, new DepthComparisonMaterial(_this26.depthPass.renderTarget.texture, camera));\n\n    var clearPass = _this26.maskPass.getClearPass();\n\n    clearPass.overrideClearColor = new Color(0xffffff);\n    clearPass.overrideClearAlpha = 1.0;\n    /**\r\n     * A blur pass.\r\n     *\r\n     * @type {BlurPass}\r\n     */\n\n    _this26.blurPass = new BlurPass({\n      resolutionScale: resolutionScale,\n      width: width,\n      height: height,\n      kernelSize: kernelSize\n    });\n    _this26.blurPass.resolution.resizable = _assertThisInitialized(_this26);\n    _this26.blur = blur;\n    /**\r\n     * An outline edge detection pass.\r\n     *\r\n     * @type {ShaderPass}\r\n     * @private\r\n     */\n\n    _this26.outlineEdgesPass = new ShaderPass(new OutlineEdgesMaterial());\n    _this26.outlineEdgesPass.getFullscreenMaterial().uniforms.maskTexture.value = _this26.renderTargetMask.texture;\n    /**\r\n     * The current animation time.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this26.time = 0.0;\n    /**\r\n     * A selection of objects that will be outlined.\r\n     *\r\n     * @type {Selection}\r\n     */\n\n    _this26.selection = new Selection();\n    /**\r\n     * The pulse speed. A value of zero disables the pulse effect.\r\n     *\r\n     * @type {Number}\r\n     */\n\n    _this26.pulseSpeed = pulseSpeed;\n    return _this26;\n  }\n  /**\r\n   * The resolution of this effect.\r\n   *\r\n   * @type {Resizer}\r\n   */\n\n\n  _createClass(OutlineEffect, [{\n    key: \"setPatternTexture\",\n\n    /**\r\n     * Sets the pattern texture.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing the\r\n     * texture.\r\n     *\r\n     * @param {Texture} texture - The new texture.\r\n     */\n    value: function setPatternTexture(texture) {\n      if (texture !== null) {\n        texture.wrapS = texture.wrapT = RepeatWrapping;\n        this.defines.set(\"USE_PATTERN\", \"1\");\n        this.uniforms.set(\"patternScale\", new Uniform(1.0));\n        this.uniforms.set(\"patternTexture\", new Uniform(texture));\n        this.vertexShader = vertexShader$7;\n      } else {\n        this.defines[\"delete\"](\"USE_PATTERN\");\n        this.uniforms[\"delete\"](\"patternScale\");\n        this.uniforms[\"delete\"](\"patternTexture\");\n        this.vertexShader = null;\n      }\n    }\n    /**\r\n     * Returns the current resolution scale.\r\n     *\r\n     * @return {Number} The resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n\n  }, {\n    key: \"getResolutionScale\",\n    value: function getResolutionScale() {\n      return this.resolution.scale;\n    }\n    /**\r\n     * Sets the resolution scale.\r\n     *\r\n     * @param {Number} scale - The new resolution scale.\r\n     * @deprecated Adjust the fixed resolution width or height instead.\r\n     */\n\n  }, {\n    key: \"setResolutionScale\",\n    value: function setResolutionScale(scale) {\n      this.resolution.scale = scale;\n      this.setSize(this.resolution.base.x, this.resolution.base.y);\n    }\n    /**\r\n     * Clears the current selection and selects a list of objects.\r\n     *\r\n     * @param {Object3D[]} objects - The objects that should be outlined. This array will be copied.\r\n     * @return {OutlinePass} This pass.\r\n     * @deprecated Use selection.set instead.\r\n     */\n\n  }, {\n    key: \"setSelection\",\n    value: function setSelection(objects) {\n      this.selection.set(objects);\n      return this;\n    }\n    /**\r\n     * Clears the list of selected objects.\r\n     *\r\n     * @return {OutlinePass} This pass.\r\n     * @deprecated Use selection.clear instead.\r\n     */\n\n  }, {\n    key: \"clearSelection\",\n    value: function clearSelection() {\n      this.selection.clear();\n      return this;\n    }\n    /**\r\n     * Selects an object.\r\n     *\r\n     * @param {Object3D} object - The object that should be outlined.\r\n     * @return {OutlinePass} This pass.\r\n     * @deprecated Use selection.add instead.\r\n     */\n\n  }, {\n    key: \"selectObject\",\n    value: function selectObject(object) {\n      this.selection.add(object);\n      return this;\n    }\n    /**\r\n     * Deselects an object.\r\n     *\r\n     * @param {Object3D} object - The object that should no longer be outlined.\r\n     * @return {OutlinePass} This pass.\r\n     * @deprecated Use selection.delete instead.\r\n     */\n\n  }, {\n    key: \"deselectObject\",\n    value: function deselectObject(object) {\n      this.selection[\"delete\"](object);\n      return this;\n    }\n    /**\r\n     * Updates this effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     */\n\n  }, {\n    key: \"update\",\n    value: function update(renderer, inputBuffer, deltaTime) {\n      var scene = this.scene;\n      var camera = this.camera;\n      var selection = this.selection;\n      var pulse = this.uniforms.get(\"pulse\");\n      var background = scene.background;\n      var mask = camera.layers.mask;\n\n      if (selection.size > 0) {\n        scene.background = null;\n        pulse.value = 1.0;\n\n        if (this.pulseSpeed > 0.0) {\n          pulse.value = 0.625 + Math.cos(this.time * this.pulseSpeed * 10.0) * 0.375;\n        }\n\n        this.time += deltaTime; // Render a custom depth texture and ignore selected objects.\n\n        selection.setVisible(false);\n        this.depthPass.render(renderer);\n        selection.setVisible(true); // Compare the depth of the selected objects with the depth texture.\n\n        camera.layers.set(selection.layer);\n        this.maskPass.render(renderer, this.renderTargetMask); // Restore the camera layer mask and the scene background.\n\n        camera.layers.mask = mask;\n        scene.background = background; // Detect the outline.\n\n        this.outlineEdgesPass.render(renderer, null, this.renderTargetEdges);\n\n        if (this.blur) {\n          this.blurPass.render(renderer, this.renderTargetEdges, this.renderTargetBlurredEdges);\n        }\n      } else if (this.time > 0.0) {\n        this.clearPass.render(renderer, this.renderTargetMask);\n        this.time = 0.0;\n      }\n    }\n    /**\r\n     * Updates the size of internal render targets.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.blurPass.setSize(width, height);\n      this.renderTargetMask.setSize(width, height);\n      width = this.resolution.width;\n      height = this.resolution.height;\n      this.depthPass.setSize(width, height);\n      this.renderTargetEdges.setSize(width, height);\n      this.renderTargetBlurredEdges.setSize(width, height);\n      this.outlineEdgesPass.getFullscreenMaterial().setTexelSize(1.0 / width, 1.0 / height);\n    }\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {\n      this.blurPass.initialize(renderer, alpha);\n      this.depthPass.initialize(renderer, alpha);\n      this.maskPass.initialize(renderer, alpha);\n    }\n  }, {\n    key: \"resolution\",\n    get: function get() {\n      return this.blurPass.resolution;\n    }\n    /**\r\n     * The current width of the internal render targets.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.width instead.\r\n     */\n\n  }, {\n    key: \"width\",\n    get: function get() {\n      return this.resolution.width;\n    }\n    /**\r\n     * Sets the render width.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.width instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.resolution.width = value;\n    }\n    /**\r\n     * The current height of the internal render targets.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.height instead.\r\n     */\n\n  }, {\n    key: \"height\",\n    get: function get() {\n      return this.resolution.height;\n    }\n    /**\r\n     * Sets the render height.\r\n     *\r\n     * @type {Number}\r\n     * @deprecated Use resolution.height instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.resolution.height = value;\n    }\n    /**\r\n     * @type {Number}\r\n     * @deprecated Use selection.layer instead.\r\n     */\n\n  }, {\n    key: \"selectionLayer\",\n    get: function get() {\n      return this.selection.layer;\n    }\n    /**\r\n     * @type {Number}\r\n     * @deprecated Use selection.layer instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.selection.layer = value;\n    }\n    /**\r\n     * Indicates whether dithering is enabled.\r\n     *\r\n     * @type {Boolean}\r\n     * @deprecated Use blurPass.dithering instead.\r\n     */\n\n  }, {\n    key: \"dithering\",\n    get: function get() {\n      return this.blurPass.dithering;\n    }\n    /**\r\n     * Enables or disables dithering.\r\n     *\r\n     * @type {Boolean}\r\n     * @deprecated Use blurPass.dithering instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.blurPass.dithering = value;\n    }\n    /**\r\n     * The blur kernel size.\r\n     *\r\n     * @type {KernelSize}\r\n     * @deprecated Use blurPass.kernelSize instead.\r\n     */\n\n  }, {\n    key: \"kernelSize\",\n    get: function get() {\n      return this.blurPass.kernelSize;\n    }\n    /**\r\n     * Sets the kernel size.\r\n     *\r\n     * @type {KernelSize}\r\n     * @deprecated Use blurPass.kernelSize instead.\r\n     */\n    ,\n    set: function set(value) {\n      this.blurPass.kernelSize = value;\n    }\n    /**\r\n     * Indicates whether the outlines should be blurred.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"blur\",\n    get: function get() {\n      return this.blurPass.enabled;\n    }\n    /**\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      this.blurPass.enabled = value;\n      this.uniforms.get(\"edgeTexture\").value = value ? this.renderTargetBlurredEdges.texture : this.renderTargetEdges.texture;\n    }\n    /**\r\n     * Indicates whether X-Ray outlines are enabled.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"xRay\",\n    get: function get() {\n      return this.defines.has(\"X_RAY\");\n    }\n    /**\r\n     * Enables or disables X-Ray outlines.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.set(\"X_RAY\", \"1\") : this.defines[\"delete\"](\"X_RAY\");\n    }\n  }]);\n\n  return OutlineEffect;\n}(Effect);\n\nvar fragmentShader$o = \"uniform bool active;uniform vec2 d;void mainUv(inout vec2 uv){if(active){uv=vec2(d.x*(floor(uv.x/d.x)+0.5),d.y*(floor(uv.y/d.y)+0.5));}}\";\n/**\r\n * A pixelation effect.\r\n *\r\n * Warning: This effect cannot be merged with convolution effects.\r\n */\n\nvar PixelationEffect = /*#__PURE__*/function (_Effect16) {\n  _inherits(PixelationEffect, _Effect16);\n\n  var _super38 = _createSuper(PixelationEffect);\n\n  /**\r\n   * Constructs a new pixelation effect.\r\n   *\r\n   * @param {Object} [granularity=30.0] - The pixel granularity.\r\n   */\n  function PixelationEffect() {\n    var _this27;\n\n    var granularity = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 30.0;\n\n    _classCallCheck(this, PixelationEffect);\n\n    _this27 = _super38.call(this, \"PixelationEffect\", fragmentShader$o, {\n      uniforms: new Map([[\"active\", new Uniform(false)], [\"d\", new Uniform(new Vector2$1())]])\n    });\n    /**\r\n     * The original resolution.\r\n     *\r\n     * @type {Vector2}\r\n     * @private\r\n     */\n\n    _this27.resolution = new Vector2$1();\n    /**\r\n     * The pixel granularity.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this27.granularity = granularity;\n    return _this27;\n  }\n  /**\r\n   * Returns the pixel granularity.\r\n   *\r\n   * @return {Number} The granularity.\r\n   */\n\n\n  _createClass(PixelationEffect, [{\n    key: \"getGranularity\",\n    value: function getGranularity() {\n      return this.granularity;\n    }\n    /**\r\n     * Sets the pixel granularity.\r\n     *\r\n     * A higher value yields coarser visuals.\r\n     *\r\n     * @param {Number} granularity - The new granularity.\r\n     */\n\n  }, {\n    key: \"setGranularity\",\n    value: function setGranularity(granularity) {\n      granularity = Math.floor(granularity);\n\n      if (granularity % 2 > 0) {\n        granularity += 1;\n      }\n\n      var uniforms = this.uniforms;\n      uniforms.get(\"active\").value = granularity > 0.0;\n      uniforms.get(\"d\").value.set(granularity, granularity).divide(this.resolution);\n      this.granularity = granularity;\n    }\n    /**\r\n     * Updates the granularity.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.resolution.set(width, height);\n      this.setGranularity(this.granularity);\n    }\n  }]);\n\n  return PixelationEffect;\n}(Effect);\n\nvar fragmentShader$p = \"uniform float focus;uniform float focalLength;uniform float fStop;uniform float maxBlur;uniform float luminanceThreshold;uniform float luminanceGain;uniform float bias;uniform float fringe;\\n#ifdef MANUAL_DOF\\nuniform vec4 dof;\\n#endif\\n#ifdef PENTAGON\\nfloat pentagon(const in vec2 coords){const vec4 HS0=vec4(1.0,0.0,0.0,1.0);const vec4 HS1=vec4(0.309016994,0.951056516,0.0,1.0);const vec4 HS2=vec4(-0.809016994,0.587785252,0.0,1.0);const vec4 HS3=vec4(-0.809016994,-0.587785252,0.0,1.0);const vec4 HS4=vec4(0.309016994,-0.951056516,0.0,1.0);const vec4 HS5=vec4(0.0,0.0,1.0,1.0);const vec4 ONE=vec4(1.0);const float P_FEATHER=0.4;const float N_FEATHER=-P_FEATHER;float inOrOut=-4.0;vec4 P=vec4(coords,vec2(RINGS_FLOAT-1.3));vec4 dist=vec4(dot(P,HS0),dot(P,HS1),dot(P,HS2),dot(P,HS3));dist=smoothstep(N_FEATHER,P_FEATHER,dist);inOrOut+=dot(dist,ONE);dist.x=dot(P,HS4);dist.y=HS5.w-abs(P.z);dist=smoothstep(N_FEATHER,P_FEATHER,dist);inOrOut+=dist.x;return clamp(inOrOut,0.0,1.0);}\\n#endif\\nvec3 processTexel(const in vec2 coords,const in float blur){vec2 scale=texelSize*fringe*blur;vec3 c=vec3(texture2D(inputBuffer,coords+vec2(0.0,1.0)*scale).r,texture2D(inputBuffer,coords+vec2(-0.866,-0.5)*scale).g,texture2D(inputBuffer,coords+vec2(0.866,-0.5)*scale).b);float luminance=linearToRelativeLuminance(c);float threshold=max((luminance-luminanceThreshold)*luminanceGain,0.0);return c+mix(vec3(0.0),c,threshold*blur);}float gather(const in float i,const in float j,const in float ringSamples,const in vec2 uv,const in vec2 blurFactor,const in float blur,inout vec3 color){float step=PI2/ringSamples;vec2 wh=vec2(cos(j*step)*i,sin(j*step)*i);\\n#ifdef PENTAGON\\nfloat p=pentagon(wh);\\n#else\\nfloat p=1.0;\\n#endif\\ncolor+=processTexel(wh*blurFactor+uv,blur)*mix(1.0,i/RINGS_FLOAT,bias)*p;return mix(1.0,i/RINGS_FLOAT,bias)*p;}void mainImage(const in vec4 inputColor,const in vec2 uv,const in float depth,out vec4 outputColor){float linearDepth=(-cameraFar*cameraNear/(depth*(cameraFar-cameraNear)-cameraFar));\\n#ifdef MANUAL_DOF\\nfloat focalPlane=linearDepth-focus;float farDoF=(focalPlane-dof.z)/dof.w;float nearDoF=(-focalPlane-dof.x)/dof.y;float blur=(focalPlane>0.0)? farDoF : nearDoF;\\n#else\\nconst float CIRCLE_OF_CONFUSION=0.03;float focalPlaneMM=focus*1000.0;float depthMM=linearDepth*1000.0;float focalPlane=(depthMM*focalLength)/(depthMM-focalLength);float farDoF=(focalPlaneMM*focalLength)/(focalPlaneMM-focalLength);float nearDoF=(focalPlaneMM-focalLength)/(focalPlaneMM*fStop*CIRCLE_OF_CONFUSION);float blur=abs(focalPlane-farDoF)*nearDoF;\\n#endif\\nconst int MAX_RING_SAMPLES=RINGS_INT*SAMPLES_INT;blur=clamp(blur,0.0,1.0);vec3 color=inputColor.rgb;if(blur>=0.05){vec2 blurFactor=blur*maxBlur*texelSize;float s=1.0;int ringSamples;for(int i=1;i<=RINGS_INT;i++){ringSamples=i*SAMPLES_INT;for(int j=0;j<MAX_RING_SAMPLES;j++){if(j>=ringSamples){break;}s+=gather(float(i),float(j),float(ringSamples),uv,blurFactor,blur,color);}}color/=s;}\\n#ifdef SHOW_FOCUS\\nfloat edge=0.002*linearDepth;float m=clamp(smoothstep(0.0,edge,blur),0.0,1.0);float e=clamp(smoothstep(1.0-edge,1.0,blur),0.0,1.0);color=mix(color,vec3(1.0,0.5,0.0),(1.0-m)*0.6);color=mix(color,vec3(0.0,0.5,1.0),((1.0-e)-(1.0-m))*0.2);\\n#endif\\noutputColor=vec4(color,inputColor.a);}\";\n/**\r\n * Depth of Field shader v2.4.\r\n *\r\n * Yields more realistic results but is also more demanding.\r\n *\r\n * Original shader code by Martins Upitis:\r\n *  http://blenderartists.org/forum/showthread.php?237488-GLSL-depth-of-field-with-bokeh-v2-4-(update)\r\n */\n\nvar RealisticBokehEffect = /*#__PURE__*/function (_Effect17) {\n  _inherits(RealisticBokehEffect, _Effect17);\n\n  var _super39 = _createSuper(RealisticBokehEffect);\n\n  /**\r\n   * Constructs a new bokeh effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Number} [options.focus=1.0] - The focus distance in world units.\r\n   * @param {Number} [options.focalLength=24.0] - The focal length of the main camera.\r\n   * @param {Number} [options.fStop=0.9] - The ratio of the lens focal length to the diameter of the entrance pupil (aperture).\r\n   * @param {Number} [options.luminanceThreshold=0.5] - A luminance threshold.\r\n   * @param {Number} [options.luminanceGain=2.0] - A luminance gain factor.\r\n   * @param {Number} [options.bias=0.5] - A blur bias.\r\n   * @param {Number} [options.fringe=0.7] - A blur offset.\r\n   * @param {Number} [options.maxBlur=1.0] - The maximum blur strength.\r\n   * @param {Boolean} [options.rings=3] - The number of blur iterations.\r\n   * @param {Boolean} [options.samples=2] - The amount of samples taken per ring.\r\n   * @param {Boolean} [options.showFocus=false] - Whether the focal point should be highlighted. Useful for debugging.\r\n   * @param {Boolean} [options.manualDoF=false] - Enables manual control over the depth of field.\r\n   * @param {Boolean} [options.pentagon=false] - Enables pentagonal blur shapes. Requires a high number of rings and samples.\r\n   */\n  function RealisticBokehEffect() {\n    var _this28;\n\n    var _ref20 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref20$blendFunction = _ref20.blendFunction,\n        blendFunction = _ref20$blendFunction === void 0 ? BlendFunction.NORMAL : _ref20$blendFunction,\n        _ref20$focus = _ref20.focus,\n        focus = _ref20$focus === void 0 ? 1.0 : _ref20$focus,\n        _ref20$focalLength = _ref20.focalLength,\n        focalLength = _ref20$focalLength === void 0 ? 24.0 : _ref20$focalLength,\n        _ref20$fStop = _ref20.fStop,\n        fStop = _ref20$fStop === void 0 ? 0.9 : _ref20$fStop,\n        _ref20$luminanceThres = _ref20.luminanceThreshold,\n        luminanceThreshold = _ref20$luminanceThres === void 0 ? 0.5 : _ref20$luminanceThres,\n        _ref20$luminanceGain = _ref20.luminanceGain,\n        luminanceGain = _ref20$luminanceGain === void 0 ? 2.0 : _ref20$luminanceGain,\n        _ref20$bias = _ref20.bias,\n        bias = _ref20$bias === void 0 ? 0.5 : _ref20$bias,\n        _ref20$fringe = _ref20.fringe,\n        fringe = _ref20$fringe === void 0 ? 0.7 : _ref20$fringe,\n        _ref20$maxBlur = _ref20.maxBlur,\n        maxBlur = _ref20$maxBlur === void 0 ? 1.0 : _ref20$maxBlur,\n        _ref20$rings = _ref20.rings,\n        rings = _ref20$rings === void 0 ? 3 : _ref20$rings,\n        _ref20$samples = _ref20.samples,\n        samples = _ref20$samples === void 0 ? 2 : _ref20$samples,\n        _ref20$showFocus = _ref20.showFocus,\n        showFocus = _ref20$showFocus === void 0 ? false : _ref20$showFocus,\n        _ref20$manualDoF = _ref20.manualDoF,\n        manualDoF = _ref20$manualDoF === void 0 ? false : _ref20$manualDoF,\n        _ref20$pentagon = _ref20.pentagon,\n        pentagon = _ref20$pentagon === void 0 ? false : _ref20$pentagon;\n\n    _classCallCheck(this, RealisticBokehEffect);\n\n    _this28 = _super39.call(this, \"RealisticBokehEffect\", fragmentShader$p, {\n      blendFunction: blendFunction,\n      attributes: EffectAttribute.CONVOLUTION | EffectAttribute.DEPTH,\n      uniforms: new Map([[\"focus\", new Uniform(focus)], [\"focalLength\", new Uniform(focalLength)], [\"fStop\", new Uniform(fStop)], [\"luminanceThreshold\", new Uniform(luminanceThreshold)], [\"luminanceGain\", new Uniform(luminanceGain)], [\"bias\", new Uniform(bias)], [\"fringe\", new Uniform(fringe)], [\"maxBlur\", new Uniform(maxBlur)]])\n    });\n    _this28.rings = rings;\n    _this28.samples = samples;\n    _this28.showFocus = showFocus;\n    _this28.manualDoF = manualDoF;\n    _this28.pentagon = pentagon;\n    return _this28;\n  }\n  /**\r\n   * The amount of blur iterations.\r\n   *\r\n   * @type {Number}\r\n   */\n\n\n  _createClass(RealisticBokehEffect, [{\n    key: \"rings\",\n    get: function get() {\n      return Number.parseInt(this.defines.get(\"RINGS_INT\"));\n    }\n    /**\r\n     * Sets the amount of blur iterations.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      value = Math.floor(value);\n      this.defines.set(\"RINGS_INT\", value.toFixed(0));\n      this.defines.set(\"RINGS_FLOAT\", value.toFixed(1));\n    }\n    /**\r\n     * The amount of blur samples per ring.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"samples\",\n    get: function get() {\n      return Number.parseInt(this.defines.get(\"SAMPLES_INT\"));\n    }\n    /**\r\n     * Sets the amount of blur samples per ring.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      value = Math.floor(value);\n      this.defines.set(\"SAMPLES_INT\", value.toFixed(0));\n      this.defines.set(\"SAMPLES_FLOAT\", value.toFixed(1));\n    }\n    /**\r\n     * Indicates whether the focal point will be highlighted.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"showFocus\",\n    get: function get() {\n      return this.defines.has(\"SHOW_FOCUS\");\n    }\n    /**\r\n     * Enables or disables focal point highlighting.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.set(\"SHOW_FOCUS\", \"1\") : this.defines[\"delete\"](\"SHOW_FOCUS\");\n    }\n    /**\r\n     * Indicates whether the Depth of Field should be calculated manually.\r\n     *\r\n     * If enabled, the Depth of Field can be adjusted via the `dof` uniform.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"manualDoF\",\n    get: function get() {\n      return this.defines.has(\"MANUAL_DOF\");\n    }\n    /**\r\n     * Enables or disables manual Depth of Field.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      if (value) {\n        this.defines.set(\"MANUAL_DOF\", \"1\");\n        this.uniforms.set(\"dof\", new Uniform(new Vector4(0.2, 1.0, 0.2, 2.0)));\n      } else {\n        this.defines[\"delete\"](\"MANUAL_DOF\");\n        this.uniforms[\"delete\"](\"dof\");\n      }\n    }\n    /**\r\n     * Indicates whether the blur shape should be pentagonal.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"pentagon\",\n    get: function get() {\n      return this.defines.has(\"PENTAGON\");\n    }\n    /**\r\n     * Enables or disables pentagonal blur.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.set(\"PENTAGON\", \"1\") : this.defines[\"delete\"](\"PENTAGON\");\n    }\n  }]);\n\n  return RealisticBokehEffect;\n}(Effect);\n\nvar fragmentShader$q = \"uniform float count;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec2 sl=vec2(sin(uv.y*count),cos(uv.y*count));vec3 scanlines=vec3(sl.x,sl.y,sl.x);outputColor=vec4(scanlines,inputColor.a);}\";\n/**\r\n * A scanline effect.\r\n */\n\nvar ScanlineEffect = /*#__PURE__*/function (_Effect18) {\n  _inherits(ScanlineEffect, _Effect18);\n\n  var _super40 = _createSuper(ScanlineEffect);\n\n  /**\r\n   * Constructs a new scanline effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.OVERLAY] - The blend function of this effect.\r\n   * @param {Number} [options.density=1.25] - The scanline density.\r\n   */\n  function ScanlineEffect() {\n    var _this29;\n\n    var _ref21 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref21$blendFunction = _ref21.blendFunction,\n        blendFunction = _ref21$blendFunction === void 0 ? BlendFunction.OVERLAY : _ref21$blendFunction,\n        _ref21$density = _ref21.density,\n        density = _ref21$density === void 0 ? 1.25 : _ref21$density;\n\n    _classCallCheck(this, ScanlineEffect);\n\n    _this29 = _super40.call(this, \"ScanlineEffect\", fragmentShader$q, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"count\", new Uniform(0.0)]])\n    });\n    /**\r\n     * The original resolution.\r\n     *\r\n     * @type {Vector2}\r\n     * @private\r\n     */\n\n    _this29.resolution = new Vector2$1();\n    /**\r\n     * The amount of scanlines, relative to the screen height.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this29.density = density;\n    return _this29;\n  }\n  /**\r\n   * Returns the current scanline density.\r\n   *\r\n   * @return {Number} The scanline density.\r\n   */\n\n\n  _createClass(ScanlineEffect, [{\n    key: \"getDensity\",\n    value: function getDensity() {\n      return this.density;\n    }\n    /**\r\n     * Sets the scanline density.\r\n     *\r\n     * @param {Number} density - The new scanline density.\r\n     */\n\n  }, {\n    key: \"setDensity\",\n    value: function setDensity(density) {\n      this.density = density;\n      this.setSize(this.resolution.x, this.resolution.y);\n    }\n    /**\r\n     * Updates the size of this pass.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.resolution.set(width, height);\n      this.uniforms.get(\"count\").value = Math.round(height * this.density);\n    }\n  }]);\n\n  return ScanlineEffect;\n}(Effect);\n\nvar fragmentShader$r = \"uniform bool active;uniform vec2 center;uniform float waveSize;uniform float radius;uniform float maxRadius;uniform float amplitude;varying float vSize;void mainUv(inout vec2 uv){if(active){vec2 aspectCorrection=vec2(aspect,1.0);vec2 difference=uv*aspectCorrection-center*aspectCorrection;float distance=sqrt(dot(difference,difference))*vSize;if(distance>radius){if(distance<radius+waveSize){float angle=(distance-radius)*PI2/waveSize;float cosSin=(1.0-cos(angle))*0.5;float extent=maxRadius+waveSize;float decay=max(extent-distance*distance,0.0)/extent;uv-=((cosSin*amplitude*difference)/distance)*decay;}}}}\";\nvar vertexShader$8 = \"uniform float size;uniform float cameraDistance;varying float vSize;void mainSupport(){vSize=(0.1*cameraDistance)/size;}\";\n/**\r\n * Half PI.\r\n *\r\n * @type {Number}\r\n * @private\r\n */\n\nvar HALF_PI = Math.PI * 0.5;\n/**\r\n * A vector.\r\n *\r\n * @type {Vector3}\r\n * @private\r\n */\n\nvar v$1 = new Vector3();\n/**\r\n * A vector.\r\n *\r\n * @type {Vector3}\r\n * @private\r\n */\n\nvar ab = new Vector3();\n/**\r\n * A shock wave effect.\r\n *\r\n * Based on a Gist by Jean-Philippe Sarda:\r\n *  https://gist.github.com/jpsarda/33cea67a9f2ecb0a0eda\r\n *\r\n * Warning: This effect cannot be merged with convolution effects.\r\n */\n\nvar ShockWaveEffect = /*#__PURE__*/function (_Effect19) {\n  _inherits(ShockWaveEffect, _Effect19);\n\n  var _super41 = _createSuper(ShockWaveEffect);\n\n  /**\r\n   * Constructs a new shock wave effect.\r\n   *\r\n   * @param {Camera} camera - The main camera.\r\n   * @param {Vector3} [epicenter] - The world position of the shock wave epicenter.\r\n   * @param {Object} [options] - The options.\r\n   * @param {Number} [options.speed=2.0] - The animation speed.\r\n   * @param {Number} [options.maxRadius=1.0] - The extent of the shock wave.\r\n   * @param {Number} [options.waveSize=0.2] - The wave size.\r\n   * @param {Number} [options.amplitude=0.05] - The distortion amplitude.\r\n   */\n  function ShockWaveEffect(camera) {\n    var _this30;\n\n    var epicenter = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : new Vector3();\n\n    var _ref22 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n        _ref22$speed = _ref22.speed,\n        speed = _ref22$speed === void 0 ? 2.0 : _ref22$speed,\n        _ref22$maxRadius = _ref22.maxRadius,\n        maxRadius = _ref22$maxRadius === void 0 ? 1.0 : _ref22$maxRadius,\n        _ref22$waveSize = _ref22.waveSize,\n        waveSize = _ref22$waveSize === void 0 ? 0.2 : _ref22$waveSize,\n        _ref22$amplitude = _ref22.amplitude,\n        amplitude = _ref22$amplitude === void 0 ? 0.05 : _ref22$amplitude;\n\n    _classCallCheck(this, ShockWaveEffect);\n\n    _this30 = _super41.call(this, \"ShockWaveEffect\", fragmentShader$r, {\n      vertexShader: vertexShader$8,\n      uniforms: new Map([[\"active\", new Uniform(false)], [\"center\", new Uniform(new Vector2$1(0.5, 0.5))], [\"cameraDistance\", new Uniform(1.0)], [\"size\", new Uniform(1.0)], [\"radius\", new Uniform(-waveSize)], [\"maxRadius\", new Uniform(maxRadius)], [\"waveSize\", new Uniform(waveSize)], [\"amplitude\", new Uniform(amplitude)]])\n    });\n    /**\r\n     * The main camera.\r\n     *\r\n     * @type {Camera}\r\n     */\n\n    _this30.camera = camera;\n    /**\r\n     * The epicenter.\r\n     *\r\n     * @type {Vector3}\r\n     * @example shockWavePass.epicenter = myMesh.position;\r\n     */\n\n    _this30.epicenter = epicenter;\n    /**\r\n     * The object position in screen space.\r\n     *\r\n     * @type {Vector3}\r\n     * @private\r\n     */\n\n    _this30.screenPosition = _this30.uniforms.get(\"center\").value;\n    /**\r\n     * The speed of the shock wave animation.\r\n     *\r\n     * @type {Number}\r\n     */\n\n    _this30.speed = speed;\n    /**\r\n     * A time accumulator.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this30.time = 0.0;\n    /**\r\n     * Indicates whether the shock wave animation is active.\r\n     *\r\n     * @type {Boolean}\r\n     * @private\r\n     */\n\n    _this30.active = false;\n    return _this30;\n  }\n  /**\r\n   * Emits the shock wave.\r\n   */\n\n\n  _createClass(ShockWaveEffect, [{\n    key: \"explode\",\n    value: function explode() {\n      this.time = 0.0;\n      this.active = true;\n      this.uniforms.get(\"active\").value = true;\n    }\n    /**\r\n     * Updates this effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [delta] - The time between the last frame and the current one in seconds.\r\n     */\n\n  }, {\n    key: \"update\",\n    value: function update(renderer, inputBuffer, delta) {\n      var epicenter = this.epicenter;\n      var camera = this.camera;\n      var uniforms = this.uniforms;\n      var radius;\n\n      if (this.active) {\n        var waveSize = uniforms.get(\"waveSize\").value; // Calculate direction vectors.\n\n        camera.getWorldDirection(v$1);\n        ab.copy(camera.position).sub(epicenter); // Don't render the effect if the object is behind the camera.\n\n        if (v$1.angleTo(ab) > HALF_PI) {\n          // Scale the effect based on distance to the object.\n          uniforms.get(\"cameraDistance\").value = camera.position.distanceTo(epicenter); // Calculate the screen position of the epicenter.\n\n          v$1.copy(epicenter).project(camera);\n          this.screenPosition.set((v$1.x + 1.0) * 0.5, (v$1.y + 1.0) * 0.5);\n        } // Update the shock wave radius based on time.\n\n\n        this.time += delta * this.speed;\n        radius = this.time - waveSize;\n        uniforms.get(\"radius\").value = radius;\n\n        if (radius >= (uniforms.get(\"maxRadius\").value + waveSize) * 2.0) {\n          this.active = false;\n          uniforms.get(\"active\").value = false;\n        }\n      }\n    }\n  }]);\n\n  return ShockWaveEffect;\n}(Effect);\n/**\r\n * A selective bloom effect.\r\n *\r\n * This effect applies bloom only to selected objects. For this, all objects in\r\n * the scene need to be rendered again: non-selected objects are rendered solid\r\n * black to properly occlude selected objects and the scene background.\r\n *\r\n * Attention: If you don't need to limit bloom to a subset of objects, consider\r\n * using the {@link BloomEffect} instead for better performance.\r\n */\n\n\nvar SelectiveBloomEffect = /*#__PURE__*/function (_BloomEffect) {\n  _inherits(SelectiveBloomEffect, _BloomEffect);\n\n  var _super42 = _createSuper(SelectiveBloomEffect);\n\n  /**\r\n   * Constructs a new selective bloom effect.\r\n   *\r\n   * @param {Scene} scene - The main scene.\r\n   * @param {Camera} camera - The main camera.\r\n   * @param {Object} [options] - The options. See {@link BloomEffect} for details.\r\n   */\n  function SelectiveBloomEffect(scene, camera, options) {\n    var _this31;\n\n    _classCallCheck(this, SelectiveBloomEffect);\n\n    _this31 = _super42.call(this, options);\n    /**\r\n     * The main scene.\r\n     *\r\n     * @type {Scene}\r\n     * @private\r\n     */\n\n    _this31.scene = scene;\n    /**\r\n     * The main camera.\r\n     *\r\n     * @type {Camera}\r\n     * @private\r\n     */\n\n    _this31.camera = camera;\n    /**\r\n     * A clear pass.\r\n     *\r\n     * @type {ClearPass}\r\n     * @private\r\n     */\n\n    _this31.clearPass = new ClearPass(true, true, false);\n    _this31.clearPass.overrideClearColor = new Color(0x000000);\n    /**\r\n     * A render pass.\r\n     *\r\n     * @type {RenderPass}\r\n     * @private\r\n     */\n\n    _this31.renderPass = new RenderPass(scene, camera);\n    _this31.renderPass.clear = false;\n    /**\r\n     * A render pass that renders all objects solid black.\r\n     *\r\n     * @type {RenderPass}\r\n     * @private\r\n     */\n\n    _this31.blackoutPass = new RenderPass(scene, camera, new MeshBasicMaterial({\n      color: 0x000000\n    }));\n    _this31.blackoutPass.clear = false;\n    /**\r\n     * A render pass that only renders the background of the main scene.\r\n     *\r\n     * @type {RenderPass}\r\n     * @private\r\n     */\n\n    _this31.backgroundPass = function () {\n      var backgroundScene = new Scene();\n      var pass = new RenderPass(backgroundScene, camera);\n      backgroundScene.background = scene.background;\n      pass.clear = false;\n      return pass;\n    }();\n    /**\r\n     * A render target.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n\n    _this31.renderTargetSelection = new WebGLRenderTarget(1, 1, {\n      minFilter: LinearFilter,\n      magFilter: LinearFilter,\n      stencilBuffer: false,\n      depthBuffer: true\n    });\n    _this31.renderTargetSelection.texture.name = \"Bloom.Selection\";\n    _this31.renderTargetSelection.texture.generateMipmaps = false;\n    /**\r\n     * A selection of objects.\r\n     *\r\n     * @type {Selection}\r\n     */\n\n    _this31.selection = new Selection();\n    /**\r\n     * Indicates whether the selection should be considered inverted.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    _this31.inverted = false;\n    return _this31;\n  }\n  /**\r\n   * Indicates whether the scene background should be ignored.\r\n   *\r\n   * @type {Boolean}\r\n   */\n\n\n  _createClass(SelectiveBloomEffect, [{\n    key: \"update\",\n\n    /**\r\n     * Updates this effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     */\n    value: function update(renderer, inputBuffer, deltaTime) {\n      var scene = this.scene;\n      var camera = this.camera;\n      var selection = this.selection;\n      var renderTarget = this.renderTargetSelection;\n      var background = scene.background;\n      var mask = camera.layers.mask;\n      this.clearPass.render(renderer, renderTarget);\n\n      if (!this.ignoreBackground) {\n        this.backgroundPass.render(renderer, renderTarget);\n      }\n\n      scene.background = null;\n\n      if (this.inverted) {\n        camera.layers.set(selection.layer);\n        this.blackoutPass.render(renderer, renderTarget);\n        camera.layers.mask = mask;\n        selection.setVisible(false);\n        this.renderPass.render(renderer, renderTarget);\n        selection.setVisible(true);\n      } else {\n        selection.setVisible(false);\n        this.blackoutPass.render(renderer, renderTarget);\n        selection.setVisible(true);\n        camera.layers.set(selection.layer);\n        this.renderPass.render(renderer, renderTarget);\n        camera.layers.mask = mask;\n      }\n\n      scene.background = background;\n\n      _get(_getPrototypeOf(SelectiveBloomEffect.prototype), \"update\", this).call(this, renderer, renderTarget, deltaTime);\n    }\n    /**\r\n     * Updates the size of internal render targets.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      _get(_getPrototypeOf(SelectiveBloomEffect.prototype), \"setSize\", this).call(this, width, height);\n\n      this.backgroundPass.setSize(width, height);\n      this.blackoutPass.setSize(width, height);\n      this.renderPass.setSize(width, height);\n      this.renderTargetSelection.setSize(this.resolution.width, this.resolution.height);\n    }\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {\n      _get(_getPrototypeOf(SelectiveBloomEffect.prototype), \"initialize\", this).call(this, renderer, alpha);\n\n      this.backgroundPass.initialize(renderer, alpha);\n      this.blackoutPass.initialize(renderer, alpha);\n      this.renderPass.initialize(renderer, alpha);\n\n      if (!alpha) {\n        this.renderTargetSelection.texture.format = RGBFormat;\n      }\n    }\n  }, {\n    key: \"ignoreBackground\",\n    get: function get() {\n      return !this.backgroundPass.enabled;\n    }\n    /**\r\n     * Enables or disables background rendering.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      this.backgroundPass.enabled = !value;\n    }\n  }]);\n\n  return SelectiveBloomEffect;\n}(BloomEffect);\n\nvar fragmentShader$s = \"uniform float intensity;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec3 color=vec3(dot(inputColor.rgb,vec3(1.0-0.607*intensity,0.769*intensity,0.189*intensity)),dot(inputColor.rgb,vec3(0.349*intensity,1.0-0.314*intensity,0.168*intensity)),dot(inputColor.rgb,vec3(0.272*intensity,0.534*intensity,1.0-0.869*intensity)));outputColor=vec4(color,inputColor.a);}\";\n/**\r\n * A sepia effect.\r\n */\n\nvar SepiaEffect = /*#__PURE__*/function (_Effect20) {\n  _inherits(SepiaEffect, _Effect20);\n\n  var _super43 = _createSuper(SepiaEffect);\n\n  /**\r\n   * Constructs a new sepia effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Number} [options.intensity=1.0] - The intensity of the effect.\r\n   */\n  function SepiaEffect() {\n    var _ref23 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref23$blendFunction = _ref23.blendFunction,\n        blendFunction = _ref23$blendFunction === void 0 ? BlendFunction.NORMAL : _ref23$blendFunction,\n        _ref23$intensity = _ref23.intensity,\n        intensity = _ref23$intensity === void 0 ? 1.0 : _ref23$intensity;\n\n    _classCallCheck(this, SepiaEffect);\n\n    return _super43.call(this, \"SepiaEffect\", fragmentShader$s, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"intensity\", new Uniform(intensity)]])\n    });\n  }\n\n  return SepiaEffect;\n}(Effect); // Generated with SMAASearchImageData.generate().toCanvas().toDataURL(), cropped, high dynamic range.\n\n\nvar searchImageDataURL = \"data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAAEAAAAAQCAYAAACm53kpAAAAeElEQVRYR+2XSwqAMAxEJ168ePEqwRSKhIIiuHjJqiU0gWE+1CQdApcVAMUAuARaMGCX1MIL/Ow13++9lW2s3mW9MWvsnWc/2fvGygwPAN4E8QzAA4CXAB6AHjG4JTHYI1ey3pcx6FHnEfhLDOIBKAmUBK6/ANUDTlROXAHd9EC1AAAAAElFTkSuQmCC\"; // Generated with SMAAAreaImageData.generate().toCanvas().toDataURL().\n\nvar areaImageDataURL = \"data:image/png;base64,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\";\nvar fragmentShader$t = \"uniform sampler2D weightMap;varying vec2 vOffset0;varying vec2 vOffset1;/***Moves values to a target vector based on a given conditional vector.*/void movec(const in bvec2 c,inout vec2 variable,const in vec2 value){if(c.x){variable.x=value.x;}if(c.y){variable.y=value.y;}}void movec(const in bvec4 c,inout vec4 variable,const in vec4 value){movec(c.xy,variable.xy,value.xy);movec(c.zw,variable.zw,value.zw);}void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){vec4 a;a.x=texture2D(weightMap,vOffset0).a;a.y=texture2D(weightMap,vOffset1).g;a.wz=texture2D(weightMap,uv).rb;vec4 color=inputColor;if(dot(a,vec4(1.0))>=1e-5){bool h=max(a.x,a.z)>max(a.y,a.w);vec4 blendingOffset=vec4(0.0,a.y,0.0,a.w);vec2 blendingWeight=a.yw;movec(bvec4(h),blendingOffset,vec4(a.x,0.0,a.z,0.0));movec(bvec2(h),blendingWeight,a.xz);blendingWeight/=dot(blendingWeight,vec2(1.0));vec4 blendingCoord=blendingOffset*vec4(texelSize,-texelSize)+uv.xyxy;color=blendingWeight.x*texture2D(inputBuffer,blendingCoord.xy);color+=blendingWeight.y*texture2D(inputBuffer,blendingCoord.zw);}outputColor=color;}\";\nvar vertexShader$9 = \"varying vec2 vOffset0;varying vec2 vOffset1;void mainSupport(const in vec2 uv){vOffset0=uv+texelSize*vec2(1.0,0.0);vOffset1=uv+texelSize*vec2(0.0,1.0);}\";\n/**\r\n * Subpixel Morphological Antialiasing (SMAA).\r\n *\r\n * https://github.com/iryoku/smaa/releases/tag/v2.8\r\n */\n\nvar SMAAEffect = /*#__PURE__*/function (_Effect21) {\n  _inherits(SMAAEffect, _Effect21);\n\n  var _super44 = _createSuper(SMAAEffect);\n\n  /**\r\n   * Constructs a new SMAA effect.\r\n   *\r\n   * @param {Image} searchImage - The SMAA search image. Preload this image using the {@link SMAAImageLoader}.\r\n   * @param {Image} areaImage - The SMAA area image. Preload this image using the {@link SMAAImageLoader}.\r\n   * @param {SMAAPreset} [preset=SMAAPreset.HIGH] - An SMAA quality preset.\r\n   */\n  function SMAAEffect(searchImage, areaImage) {\n    var _this32;\n\n    var preset = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : SMAAPreset.HIGH;\n\n    _classCallCheck(this, SMAAEffect);\n\n    _this32 = _super44.call(this, \"SMAAEffect\", fragmentShader$t, {\n      vertexShader: vertexShader$9,\n      blendFunction: BlendFunction.NORMAL,\n      attributes: EffectAttribute.CONVOLUTION,\n      uniforms: new Map([[\"weightMap\", new Uniform(null)]])\n    });\n    /**\r\n     * A render target for the color edge detection.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this32.renderTargetColorEdges = new WebGLRenderTarget(1, 1, {\n      minFilter: LinearFilter,\n      stencilBuffer: false,\n      depthBuffer: false,\n      format: RGBFormat\n    });\n    _this32.renderTargetColorEdges.texture.name = \"SMAA.ColorEdges\";\n    /**\r\n     * A render target for the SMAA weights.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this32.renderTargetWeights = _this32.renderTargetColorEdges.clone();\n    _this32.renderTargetWeights.texture.name = \"SMAA.Weights\";\n    _this32.renderTargetWeights.texture.format = RGBAFormat;\n    _this32.uniforms.get(\"weightMap\").value = _this32.renderTargetWeights.texture;\n    /**\r\n     * A clear pass for the color edges buffer.\r\n     *\r\n     * @type {ClearPass}\r\n     * @private\r\n     */\n\n    _this32.clearPass = new ClearPass(true, false, false);\n    _this32.clearPass.overrideClearColor = new Color(0x000000);\n    _this32.clearPass.overrideClearAlpha = 1.0;\n    /**\r\n     * A color edge detection pass.\r\n     *\r\n     * @type {ShaderPass}\r\n     * @private\r\n     */\n\n    _this32.colorEdgesPass = new ShaderPass(new ColorEdgesMaterial());\n    /**\r\n     * An SMAA weights pass.\r\n     *\r\n     * @type {ShaderPass}\r\n     * @private\r\n     */\n\n    _this32.weightsPass = new ShaderPass(new SMAAWeightsMaterial());\n\n    _this32.weightsPass.getFullscreenMaterial().uniforms.searchTexture.value = function () {\n      var searchTexture = new Texture(searchImage);\n      searchTexture.name = \"SMAA.Search\";\n      searchTexture.magFilter = NearestFilter;\n      searchTexture.minFilter = NearestFilter;\n      searchTexture.format = RGBAFormat;\n      searchTexture.generateMipmaps = false;\n      searchTexture.needsUpdate = true;\n      searchTexture.flipY = true;\n      return searchTexture;\n    }();\n\n    _this32.weightsPass.getFullscreenMaterial().uniforms.areaTexture.value = function () {\n      var areaTexture = new Texture(areaImage);\n      areaTexture.name = \"SMAA.Area\";\n      areaTexture.minFilter = LinearFilter;\n      areaTexture.format = RGBAFormat;\n      areaTexture.generateMipmaps = false;\n      areaTexture.needsUpdate = true;\n      areaTexture.flipY = false;\n      return areaTexture;\n    }();\n\n    _this32.applyPreset(preset);\n\n    return _this32;\n  }\n  /**\r\n   * The internal color edge detection material.\r\n   *\r\n   * @type {ColorEdgesMaterial}\r\n   */\n\n\n  _createClass(SMAAEffect, [{\n    key: \"setEdgeDetectionThreshold\",\n\n    /**\r\n     * Sets the edge detection sensitivity.\r\n     *\r\n     * See {@link ColorEdgesMaterial#setEdgeDetectionThreshold} for more details.\r\n     *\r\n     * @deprecated Use applyPreset or colorEdgesMaterial instead.\r\n     * @param {Number} threshold - The edge detection sensitivity. Range: [0.05, 0.5].\r\n     */\n    value: function setEdgeDetectionThreshold(threshold) {\n      this.colorEdgesPass.getFullscreenMaterial().setEdgeDetectionThreshold(threshold);\n    }\n    /**\r\n     * Sets the maximum amount of horizontal/vertical search steps.\r\n     *\r\n     * See {@link SMAAWeightsMaterial#setOrthogonalSearchSteps} for more details.\r\n     *\r\n     * @deprecated Use applyPreset or weightsMaterial instead.\r\n     * @param {Number} steps - The search steps. Range: [0, 112].\r\n     */\n\n  }, {\n    key: \"setOrthogonalSearchSteps\",\n    value: function setOrthogonalSearchSteps(steps) {\n      this.weightsPass.getFullscreenMaterial().setOrthogonalSearchSteps(steps);\n    }\n    /**\r\n     * Applies the given quality preset.\r\n     *\r\n     * @param {SMAAPreset} preset - The preset.\r\n     */\n\n  }, {\n    key: \"applyPreset\",\n    value: function applyPreset(preset) {\n      var colorEdgesMaterial = this.colorEdgesMaterial;\n      var weightsMaterial = this.weightsMaterial;\n\n      switch (preset) {\n        case SMAAPreset.LOW:\n          colorEdgesMaterial.setEdgeDetectionThreshold(0.15);\n          weightsMaterial.setOrthogonalSearchSteps(4);\n          weightsMaterial.diagonalDetection = false;\n          weightsMaterial.cornerRounding = false;\n          break;\n\n        case SMAAPreset.MEDIUM:\n          colorEdgesMaterial.setEdgeDetectionThreshold(0.1);\n          weightsMaterial.setOrthogonalSearchSteps(8);\n          weightsMaterial.diagonalDetection = false;\n          weightsMaterial.cornerRounding = false;\n          break;\n\n        case SMAAPreset.HIGH:\n          colorEdgesMaterial.setEdgeDetectionThreshold(0.1);\n          weightsMaterial.setOrthogonalSearchSteps(16);\n          weightsMaterial.setDiagonalSearchSteps(8);\n          weightsMaterial.setCornerRounding(25);\n          weightsMaterial.diagonalDetection = true;\n          weightsMaterial.cornerRounding = true;\n          break;\n\n        case SMAAPreset.ULTRA:\n          colorEdgesMaterial.setEdgeDetectionThreshold(0.05);\n          weightsMaterial.setOrthogonalSearchSteps(32);\n          weightsMaterial.setDiagonalSearchSteps(16);\n          weightsMaterial.setCornerRounding(25);\n          weightsMaterial.diagonalDetection = true;\n          weightsMaterial.cornerRounding = true;\n          break;\n      }\n    }\n    /**\r\n     * Updates this effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     */\n\n  }, {\n    key: \"update\",\n    value: function update(renderer, inputBuffer, deltaTime) {\n      this.clearPass.render(renderer, this.renderTargetColorEdges);\n      this.colorEdgesPass.render(renderer, inputBuffer, this.renderTargetColorEdges);\n      this.weightsPass.render(renderer, this.renderTargetColorEdges, this.renderTargetWeights);\n    }\n    /**\r\n     * Updates the size of internal render targets.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      var colorEdgesMaterial = this.colorEdgesPass.getFullscreenMaterial();\n      var weightsMaterial = this.weightsPass.getFullscreenMaterial();\n      this.renderTargetColorEdges.setSize(width, height);\n      this.renderTargetWeights.setSize(width, height);\n      weightsMaterial.uniforms.resolution.value.set(width, height);\n      weightsMaterial.uniforms.texelSize.value.set(1.0 / width, 1.0 / height);\n      colorEdgesMaterial.uniforms.texelSize.value.copy(weightsMaterial.uniforms.texelSize.value);\n    }\n    /**\r\n     * The SMAA search image, encoded as a base64 data URL.\r\n     *\r\n     * Use this image data to create an Image instance and use it together with\r\n     * the area image to create an {@link SMAAEffect}.\r\n     *\r\n     * @type {String}\r\n     * @deprecated Use SMAAImageLoader instead.\r\n     * @example\r\n     * const searchImage = new Image();\r\n     * searchImage.addEventListener(\"load\", progress);\r\n     * searchImage.src = SMAAEffect.searchImageDataURL;\r\n     */\n\n  }, {\n    key: \"colorEdgesMaterial\",\n    get: function get() {\n      return this.colorEdgesPass.getFullscreenMaterial();\n    }\n    /**\r\n     * The internal edge weights material.\r\n     *\r\n     * @type {SMAAWeightsMaterial}\r\n     */\n\n  }, {\n    key: \"weightsMaterial\",\n    get: function get() {\n      return this.weightsPass.getFullscreenMaterial();\n    }\n  }], [{\n    key: \"searchImageDataURL\",\n    get: function get() {\n      return searchImageDataURL;\n    }\n    /**\r\n     * The SMAA area image, encoded as a base64 data URL.\r\n     *\r\n     * Use this image data to create an Image instance and use it together with\r\n     * the search image to create an {@link SMAAEffect}.\r\n     *\r\n     * @type {String}\r\n     * @deprecated Use SMAAImageLoader instead.\r\n     * @example\r\n     * const areaImage = new Image();\r\n     * areaImage.addEventListener(\"load\", progress);\r\n     * areaImage.src = SMAAEffect.areaImageDataURL;\r\n     */\n\n  }, {\n    key: \"areaImageDataURL\",\n    get: function get() {\n      return areaImageDataURL;\n    }\n  }]);\n\n  return SMAAEffect;\n}(Effect);\n/**\r\n * An enumeration of SMAA presets.\r\n *\r\n * @type {Object}\r\n * @property {Number} LOW - Results in around 60% of the maximum quality.\r\n * @property {Number} MEDIUM - Results in around 80% of the maximum quality.\r\n * @property {Number} HIGH - Results in around 95% of the maximum quality.\r\n * @property {Number} ULTRA - Results in around 99% of the maximum quality.\r\n */\n\n\nvar SMAAPreset = {\n  LOW: 0,\n  MEDIUM: 1,\n  HIGH: 2,\n  ULTRA: 3\n};\nvar fragmentShader$u = \"uniform sampler2D normalBuffer;uniform mat4 cameraProjectionMatrix;uniform mat4 cameraInverseProjectionMatrix;uniform vec2 radiusStep;uniform vec2 distanceCutoff;uniform vec2 proximityCutoff;uniform float seed;uniform float luminanceInfluence;uniform float scale;uniform float bias;vec3 getViewPosition(const in vec2 screenPosition,const in float depth,const in float viewZ){float clipW=cameraProjectionMatrix[2][3]*viewZ+cameraProjectionMatrix[3][3];vec4 clipPosition=vec4((vec3(screenPosition,depth)-0.5)*2.0,1.0);clipPosition*=clipW;return(cameraInverseProjectionMatrix*clipPosition).xyz;}float getOcclusion(const in vec3 p,const in vec3 n,const in vec3 sampleViewPosition){vec3 viewDelta=sampleViewPosition-p;float d=length(viewDelta)*scale;return max(0.0,dot(n,viewDelta)/d-bias)/(1.0+pow2(d));}float getAmbientOcclusion(const in vec3 p,const in vec3 n,const in float depth,const in vec2 uv){vec2 radius=radiusStep;float angle=rand(uv+seed)*PI2;float occlusionSum=0.0;for(int i=0;i<SAMPLES_INT;++i){vec2 coord=uv+vec2(cos(angle),sin(angle))*radius;radius+=radiusStep;angle+=ANGLE_STEP;float sampleDepth=readDepth(coord);float viewZ=getViewZ(sampleDepth);\\n#ifdef PERSPECTIVE_CAMERA\\nfloat linearSampleDepth=viewZToOrthographicDepth(viewZ,cameraNear,cameraFar);\\n#else\\nfloat linearSampleDepth=sampleDepth;\\n#endif\\nfloat proximity=abs(depth-linearSampleDepth);if(linearSampleDepth<distanceCutoff.y&&proximity<proximityCutoff.y){float falloff=1.0-smoothstep(proximityCutoff.x,proximityCutoff.y,proximity);vec3 sampleViewPosition=getViewPosition(coord,sampleDepth,viewZ);occlusionSum+=getOcclusion(p,n,sampleViewPosition)*falloff;}}return occlusionSum/SAMPLES_FLOAT;}void mainImage(const in vec4 inputColor,const in vec2 uv,const in float depth,out vec4 outputColor){float ao=1.0;float viewZ=getViewZ(depth);\\n#ifdef PERSPECTIVE_CAMERA\\nfloat linearDepth=viewZToOrthographicDepth(viewZ,cameraNear,cameraFar);\\n#else\\nfloat linearDepth=depth;\\n#endif\\nif(linearDepth<distanceCutoff.y){vec3 viewPosition=getViewPosition(uv,depth,viewZ);vec3 viewNormal=unpackRGBToNormal(texture2D(normalBuffer,uv).xyz);ao-=getAmbientOcclusion(viewPosition,viewNormal,linearDepth,uv);float l=linearToRelativeLuminance(inputColor.rgb);float d=smoothstep(distanceCutoff.x,distanceCutoff.y,linearDepth);float f=max(l*luminanceInfluence,d);ao=mix(ao,1.0,f);}outputColor=vec4(vec3(ao),inputColor.a);}\";\n/**\r\n * A Screen Space Ambient Occlusion (SSAO) effect.\r\n *\r\n * For high quality visuals use two SSAO effect instances in a row with\r\n * different radii, one for rough AO and one for fine details.\r\n *\r\n * This implementation uses a spiral sampling pattern:\r\n *  https://jsfiddle.net/a16ff1p7\r\n */\n\nvar SSAOEffect = /*#__PURE__*/function (_Effect22) {\n  _inherits(SSAOEffect, _Effect22);\n\n  var _super45 = _createSuper(SSAOEffect);\n\n  /**\r\n   * Constructs a new SSAO effect.\r\n   *\r\n   * @param {Camera} camera - The main camera.\r\n   * @param {Texture} normalBuffer - A texture that contains the scene normals. See {@link NormalPass}.\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.MULTIPLY] - The blend function of this effect.\r\n   * @param {Number} [options.samples=11] - The amount of samples per pixel. Should not be a multiple of the ring count.\r\n   * @param {Number} [options.rings=4] - The amount of rings in the occlusion sampling pattern.\r\n   * @param {Number} [options.distanceThreshold=0.97] - A global distance threshold at which the occlusion effect starts to fade out. Range [0.0, 1.0].\r\n   * @param {Number} [options.distanceFalloff=0.03] - The distance falloff. Influences the smoothness of the overall occlusion cutoff. Range [0.0, 1.0].\r\n   * @param {Number} [options.rangeThreshold=0.0005] - A local occlusion range threshold at which the occlusion starts to fade out. Range [0.0, 1.0].\r\n   * @param {Number} [options.rangeFalloff=0.001] - The occlusion range falloff. Influences the smoothness of the proximity cutoff. Range [0.0, 1.0].\r\n   * @param {Number} [options.luminanceInfluence=0.7] - Determines how much the luminance of the scene influences the ambient occlusion.\r\n   * @param {Number} [options.radius=18.25] - The occlusion sampling radius.\r\n   * @param {Number} [options.scale=1.0] - The scale of the ambient occlusion.\r\n   * @param {Number} [options.bias=0.0] - An occlusion bias.\r\n   */\n  function SSAOEffect(camera, normalBuffer) {\n    var _this33;\n\n    var _ref24 = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : {},\n        _ref24$blendFunction = _ref24.blendFunction,\n        blendFunction = _ref24$blendFunction === void 0 ? BlendFunction.MULTIPLY : _ref24$blendFunction,\n        _ref24$samples = _ref24.samples,\n        samples = _ref24$samples === void 0 ? 11 : _ref24$samples,\n        _ref24$rings = _ref24.rings,\n        rings = _ref24$rings === void 0 ? 4 : _ref24$rings,\n        _ref24$distanceThresh = _ref24.distanceThreshold,\n        distanceThreshold = _ref24$distanceThresh === void 0 ? 0.97 : _ref24$distanceThresh,\n        _ref24$distanceFallof = _ref24.distanceFalloff,\n        distanceFalloff = _ref24$distanceFallof === void 0 ? 0.03 : _ref24$distanceFallof,\n        _ref24$rangeThreshold = _ref24.rangeThreshold,\n        rangeThreshold = _ref24$rangeThreshold === void 0 ? 0.0005 : _ref24$rangeThreshold,\n        _ref24$rangeFalloff = _ref24.rangeFalloff,\n        rangeFalloff = _ref24$rangeFalloff === void 0 ? 0.001 : _ref24$rangeFalloff,\n        _ref24$luminanceInflu = _ref24.luminanceInfluence,\n        luminanceInfluence = _ref24$luminanceInflu === void 0 ? 0.7 : _ref24$luminanceInflu,\n        _ref24$radius = _ref24.radius,\n        radius = _ref24$radius === void 0 ? 18.25 : _ref24$radius,\n        _ref24$scale = _ref24.scale,\n        scale = _ref24$scale === void 0 ? 1.0 : _ref24$scale,\n        _ref24$bias = _ref24.bias,\n        bias = _ref24$bias === void 0 ? 0.0 : _ref24$bias;\n\n    _classCallCheck(this, SSAOEffect);\n\n    _this33 = _super45.call(this, \"SSAOEffect\", fragmentShader$u, {\n      blendFunction: blendFunction,\n      attributes: EffectAttribute.DEPTH,\n      defines: new Map([[\"RINGS_INT\", \"0\"], [\"SAMPLES_INT\", \"0\"], [\"SAMPLES_FLOAT\", \"0.0\"]]),\n      uniforms: new Map([[\"normalBuffer\", new Uniform(normalBuffer)], [\"cameraInverseProjectionMatrix\", new Uniform(new Matrix4())], [\"cameraProjectionMatrix\", new Uniform(new Matrix4())], [\"radiusStep\", new Uniform(new Vector2$1())], [\"distanceCutoff\", new Uniform(new Vector2$1())], [\"proximityCutoff\", new Uniform(new Vector2$1())], [\"seed\", new Uniform(Math.random())], [\"luminanceInfluence\", new Uniform(luminanceInfluence)], [\"scale\", new Uniform(scale)], [\"bias\", new Uniform(bias)]])\n    });\n    /**\r\n     * The current sampling radius.\r\n     *\r\n     * @type {Number}\r\n     * @private\r\n     */\n\n    _this33.r = 0.0;\n    /**\r\n     * The current resolution.\r\n     *\r\n     * @type {Vector2}\r\n     * @private\r\n     */\n\n    _this33.resolution = new Vector2$1(1, 1);\n    /**\r\n     * The main camera.\r\n     *\r\n     * @type {Camera}\r\n     * @private\r\n     */\n\n    _this33.camera = camera;\n    _this33.samples = samples;\n    _this33.rings = rings;\n    _this33.radius = radius;\n\n    _this33.setDistanceCutoff(distanceThreshold, distanceFalloff);\n\n    _this33.setProximityCutoff(rangeThreshold, rangeFalloff);\n\n    return _this33;\n  }\n  /**\r\n   * Updates the angle step constant.\r\n   *\r\n   * @private\r\n   */\n\n\n  _createClass(SSAOEffect, [{\n    key: \"updateAngleStep\",\n    value: function updateAngleStep() {\n      this.defines.set(\"ANGLE_STEP\", (Math.PI * 2.0 * this.rings / this.samples).toFixed(11));\n    }\n    /**\r\n     * Updates the radius step uniform.\r\n     *\r\n     * Note: The radius step is a uniform because it changes with the screen size.\r\n     *\r\n     * @private\r\n     */\n\n  }, {\n    key: \"updateRadiusStep\",\n    value: function updateRadiusStep() {\n      var r = this.r / this.samples;\n      this.uniforms.get(\"radiusStep\").value.set(r, r).divide(this.resolution);\n    }\n    /**\r\n     * The amount of occlusion samples per pixel.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"setDistanceCutoff\",\n\n    /**\r\n     * Sets the occlusion distance cutoff.\r\n     *\r\n     * @param {Number} threshold - The distance threshold. Range [0.0, 1.0].\r\n     * @param {Number} falloff - The falloff. Range [0.0, 1.0].\r\n     */\n    value: function setDistanceCutoff(threshold, falloff) {\n      this.uniforms.get(\"distanceCutoff\").value.set(Math.min(Math.max(threshold, 0.0), 1.0), Math.min(Math.max(threshold + falloff, 0.0), 1.0));\n    }\n    /**\r\n     * Sets the occlusion proximity cutoff.\r\n     *\r\n     * @param {Number} threshold - The range threshold. Range [0.0, 1.0].\r\n     * @param {Number} falloff - The falloff. Range [0.0, 1.0].\r\n     */\n\n  }, {\n    key: \"setProximityCutoff\",\n    value: function setProximityCutoff(threshold, falloff) {\n      this.uniforms.get(\"proximityCutoff\").value.set(Math.min(Math.max(threshold, 0.0), 1.0), Math.min(Math.max(threshold + falloff, 0.0), 1.0));\n    }\n    /**\r\n     * Updates the camera projection matrix uniforms.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.resolution.set(width, height);\n      this.updateRadiusStep();\n      this.uniforms.get(\"cameraInverseProjectionMatrix\").value.getInverse(this.camera.projectionMatrix);\n      this.uniforms.get(\"cameraProjectionMatrix\").value.copy(this.camera.projectionMatrix);\n    }\n  }, {\n    key: \"samples\",\n    get: function get() {\n      return Number.parseInt(this.defines.get(\"SAMPLES_INT\"));\n    }\n    /**\r\n     * Sets the amount of occlusion samples per pixel.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      value = Math.floor(value);\n      this.defines.set(\"SAMPLES_INT\", value.toFixed(0));\n      this.defines.set(\"SAMPLES_FLOAT\", value.toFixed(1));\n      this.updateAngleStep();\n      this.updateRadiusStep();\n    }\n    /**\r\n     * The amount of rings in the occlusion sampling spiral pattern.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"rings\",\n    get: function get() {\n      return Number.parseInt(this.defines.get(\"RINGS_INT\"));\n    }\n    /**\r\n     * Sets the amount of rings in the occlusion sampling spiral pattern.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      value = Math.floor(value);\n      this.defines.set(\"RINGS_INT\", value.toFixed(0));\n      this.updateAngleStep();\n    }\n    /**\r\n     * The occlusion sampling radius.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"radius\",\n    get: function get() {\n      return this.r;\n    }\n    /**\r\n     * Sets the occlusion sampling radius.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.r = value;\n      this.updateRadiusStep();\n    }\n  }]);\n\n  return SSAOEffect;\n}(Effect);\n\nvar vertexShader$a = \"uniform float scale;varying vec2 vUv2;void mainSupport(const in vec2 uv){vUv2=uv*vec2(aspect,1.0)*scale;}\";\n/**\r\n * A texture effect.\r\n */\n\nvar TextureEffect = /*#__PURE__*/function (_Effect23) {\n  _inherits(TextureEffect, _Effect23);\n\n  var _super46 = _createSuper(TextureEffect);\n\n  /**\r\n   * Constructs a new texture effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Texture} [options.texture] - A texture.\r\n   * @param {Boolean} [options.aspectCorrection=false] - Whether the texture coordinates should be affected by the aspect ratio.\r\n   */\n  function TextureEffect() {\n    var _this34;\n\n    var _ref25 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref25$blendFunction = _ref25.blendFunction,\n        blendFunction = _ref25$blendFunction === void 0 ? BlendFunction.NORMAL : _ref25$blendFunction,\n        _ref25$texture = _ref25.texture,\n        texture = _ref25$texture === void 0 ? null : _ref25$texture,\n        _ref25$aspectCorrecti = _ref25.aspectCorrection,\n        aspectCorrection = _ref25$aspectCorrecti === void 0 ? false : _ref25$aspectCorrecti;\n\n    _classCallCheck(this, TextureEffect);\n\n    _this34 = _super46.call(this, \"TextureEffect\", fragmentShader$a, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"texture\", new Uniform(texture)]])\n    });\n    _this34.aspectCorrection = aspectCorrection;\n    return _this34;\n  }\n  /**\r\n   * Indicates whether aspect correction is enabled.\r\n   *\r\n   * If enabled, the texture can be scaled using the `scale` uniform.\r\n   *\r\n   * @type {Boolean}\r\n   */\n\n\n  _createClass(TextureEffect, [{\n    key: \"aspectCorrection\",\n    get: function get() {\n      return this.defines.has(\"ASPECT_CORRECTION\");\n    }\n    /**\r\n     * Enables or disables aspect correction.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      if (value) {\n        this.defines.set(\"ASPECT_CORRECTION\", \"1\");\n        this.uniforms.set(\"scale\", new Uniform(1.0));\n        this.vertexShader = vertexShader$a;\n      } else {\n        this.defines[\"delete\"](\"ASPECT_CORRECTION\");\n        this.uniforms[\"delete\"](\"scale\");\n        this.vertexShader = null;\n      }\n    }\n  }]);\n\n  return TextureEffect;\n}(Effect);\n\nvar fragmentShader$v = \"uniform sampler2D luminanceMap;uniform float middleGrey;uniform float maxLuminance;uniform float averageLuminance;vec3 toneMap(vec3 c){\\n#ifdef ADAPTED_LUMINANCE\\nfloat lumAvg=texture2D(luminanceMap,vec2(0.5)).r;\\n#else\\nfloat lumAvg=averageLuminance;\\n#endif\\nfloat lumPixel=linearToRelativeLuminance(c);float lumScaled=(lumPixel*middleGrey)/lumAvg;float lumCompressed=(lumScaled*(1.0+(lumScaled/(maxLuminance*maxLuminance))))/(1.0+lumScaled);return lumCompressed*c;}void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){outputColor=vec4(toneMap(inputColor.rgb),inputColor.a);}\";\n/**\r\n * A tone mapping effect that supports adaptive luminosity.\r\n *\r\n * If adaptivity is enabled, this effect generates a texture that represents the\r\n * luminosity of the current scene and adjusts it over time to simulate the\r\n * optic nerve responding to the amount of light it is receiving.\r\n *\r\n * Reference:\r\n *  GDC2007 - Wolfgang Engel, Post-Processing Pipeline\r\n *  http://perso.univ-lyon1.fr/jean-claude.iehl/Public/educ/GAMA/2007/gdc07/Post-Processing_Pipeline.pdf\r\n */\n\nvar ToneMappingEffect = /*#__PURE__*/function (_Effect24) {\n  _inherits(ToneMappingEffect, _Effect24);\n\n  var _super47 = _createSuper(ToneMappingEffect);\n\n  /**\r\n   * Constructs a new tone mapping effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Boolean} [options.adaptive=true] - Whether the tone mapping should use an adaptive luminance map.\r\n   * @param {Number} [options.resolution=256] - The render texture resolution of the luminance map.\r\n   * @param {Number} [options.middleGrey=0.6] - The middle grey factor.\r\n   * @param {Number} [options.maxLuminance=16.0] - The maximum luminance.\r\n   * @param {Number} [options.averageLuminance=1.0] - The average luminance.\r\n   * @param {Number} [options.adaptationRate=1.0] - The luminance adaptation rate.\r\n   */\n  function ToneMappingEffect() {\n    var _this35;\n\n    var _ref26 = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {},\n        _ref26$blendFunction = _ref26.blendFunction,\n        blendFunction = _ref26$blendFunction === void 0 ? BlendFunction.NORMAL : _ref26$blendFunction,\n        _ref26$adaptive = _ref26.adaptive,\n        adaptive = _ref26$adaptive === void 0 ? true : _ref26$adaptive,\n        _ref26$resolution = _ref26.resolution,\n        resolution = _ref26$resolution === void 0 ? 256 : _ref26$resolution,\n        _ref26$middleGrey = _ref26.middleGrey,\n        middleGrey = _ref26$middleGrey === void 0 ? 0.6 : _ref26$middleGrey,\n        _ref26$maxLuminance = _ref26.maxLuminance,\n        maxLuminance = _ref26$maxLuminance === void 0 ? 16.0 : _ref26$maxLuminance,\n        _ref26$averageLuminan = _ref26.averageLuminance,\n        averageLuminance = _ref26$averageLuminan === void 0 ? 1.0 : _ref26$averageLuminan,\n        _ref26$adaptationRate = _ref26.adaptationRate,\n        adaptationRate = _ref26$adaptationRate === void 0 ? 2.0 : _ref26$adaptationRate;\n\n    _classCallCheck(this, ToneMappingEffect);\n\n    _this35 = _super47.call(this, \"ToneMappingEffect\", fragmentShader$v, {\n      blendFunction: blendFunction,\n      uniforms: new Map([[\"luminanceMap\", new Uniform(null)], [\"middleGrey\", new Uniform(middleGrey)], [\"maxLuminance\", new Uniform(maxLuminance)], [\"averageLuminance\", new Uniform(averageLuminance)]])\n    });\n    /**\r\n     * The render target for the current luminance.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     * @todo Use RED format in WebGL 2.0 and remove LinearMipMapLinearFilter in next major release.\r\n     */\n\n    _this35.renderTargetLuminance = new WebGLRenderTarget(1, 1, {\n      minFilter: LinearMipmapLinearFilter !== undefined ? LinearMipmapLinearFilter : LinearMipMapLinearFilter,\n      magFilter: LinearFilter,\n      stencilBuffer: false,\n      depthBuffer: false,\n      format: RGBFormat\n    });\n    _this35.renderTargetLuminance.texture.name = \"ToneMapping.Luminance\";\n    _this35.renderTargetLuminance.texture.generateMipmaps = true;\n    /**\r\n     * The render target for adapted luminance.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this35.renderTargetAdapted = _this35.renderTargetLuminance.clone();\n    _this35.renderTargetAdapted.texture.name = \"ToneMapping.AdaptedLuminance\";\n    _this35.renderTargetAdapted.texture.generateMipmaps = false;\n    _this35.renderTargetAdapted.texture.minFilter = LinearFilter;\n    /**\r\n     * A render target that holds a copy of the adapted luminance.\r\n     *\r\n     * @type {WebGLRenderTarget}\r\n     * @private\r\n     */\n\n    _this35.renderTargetPrevious = _this35.renderTargetAdapted.clone();\n    _this35.renderTargetPrevious.texture.name = \"ToneMapping.PreviousLuminance\";\n    /**\r\n     * A save pass.\r\n     *\r\n     * @type {SavePass}\r\n     * @private\r\n     */\n\n    _this35.savePass = new SavePass(_this35.renderTargetPrevious, false);\n    /**\r\n     * A luminance shader pass.\r\n     *\r\n     * @type {ShaderPass}\r\n     * @private\r\n     */\n\n    _this35.luminancePass = new ShaderPass(new LuminanceMaterial());\n\n    var luminanceMaterial = _this35.luminancePass.getFullscreenMaterial();\n\n    luminanceMaterial.useThreshold = false;\n    /**\r\n     * An adaptive luminance shader pass.\r\n     *\r\n     * @type {ShaderPass}\r\n     * @private\r\n     */\n\n    _this35.adaptiveLuminancePass = new ShaderPass(new AdaptiveLuminanceMaterial());\n    _this35.adaptationRate = adaptationRate;\n    _this35.resolution = resolution;\n    _this35.adaptive = adaptive;\n    return _this35;\n  }\n  /**\r\n   * The resolution of the render targets.\r\n   *\r\n   * @type {Number}\r\n   */\n\n\n  _createClass(ToneMappingEffect, [{\n    key: \"update\",\n\n    /**\r\n     * Updates this effect.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {WebGLRenderTarget} inputBuffer - A frame buffer that contains the result of the previous pass.\r\n     * @param {Number} [deltaTime] - The time between the last frame and the current one in seconds.\r\n     */\n    value: function update(renderer, inputBuffer, deltaTime) {\n      if (this.adaptive) {\n        // Render the luminance of the current scene into a mipmap render target.\n        this.luminancePass.render(renderer, inputBuffer, this.renderTargetLuminance); // Use the frame delta to adapt the luminance over time.\n\n        var uniforms = this.adaptiveLuminancePass.getFullscreenMaterial().uniforms;\n        uniforms.previousLuminanceBuffer.value = this.renderTargetPrevious.texture;\n        uniforms.currentLuminanceBuffer.value = this.renderTargetLuminance.texture;\n        uniforms.deltaTime.value = deltaTime;\n        this.adaptiveLuminancePass.render(renderer, null, this.renderTargetAdapted); // Save the adapted luminance for the next frame.\n\n        this.savePass.render(renderer, this.renderTargetAdapted);\n      }\n    }\n    /**\r\n     * Updates the size of internal render targets.\r\n     *\r\n     * @param {Number} width - The width.\r\n     * @param {Number} height - The height.\r\n     */\n\n  }, {\n    key: \"setSize\",\n    value: function setSize(width, height) {\n      this.savePass.setSize(width, height);\n    }\n    /**\r\n     * Performs initialization tasks.\r\n     *\r\n     * @param {WebGLRenderer} renderer - The renderer.\r\n     * @param {Boolean} alpha - Whether the renderer uses the alpha channel or not.\r\n     */\n\n  }, {\n    key: \"initialize\",\n    value: function initialize(renderer, alpha) {\n      var clearPass = new ClearPass(true, false, false);\n      clearPass.overrideClearColor = new Color(0x7fffff);\n      clearPass.render(renderer, this.renderTargetPrevious);\n      clearPass.dispose();\n    }\n  }, {\n    key: \"resolution\",\n    get: function get() {\n      return this.renderTargetLuminance.width;\n    }\n    /**\r\n     * Sets the resolution of the internal render targets.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      // Round the given value to the next power of two.\n      var exponent = Math.max(0, Math.ceil(Math.log2(value)));\n      value = Math.pow(2, exponent);\n      this.renderTargetLuminance.setSize(value, value);\n      this.renderTargetPrevious.setSize(value, value);\n      this.renderTargetAdapted.setSize(value, value);\n      this.adaptiveLuminancePass.getFullscreenMaterial().defines.MIP_LEVEL_1X1 = exponent.toFixed(1);\n    }\n    /**\r\n     * Indicates whether this pass uses adaptive luminance.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n  }, {\n    key: \"adaptive\",\n    get: function get() {\n      return this.defines.has(\"ADAPTED_LUMINANCE\");\n    }\n    /**\r\n     * Enables or disables adaptive luminance.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      if (value) {\n        this.defines.set(\"ADAPTED_LUMINANCE\", \"1\");\n        this.uniforms.get(\"luminanceMap\").value = this.renderTargetAdapted.texture;\n      } else {\n        this.defines[\"delete\"](\"ADAPTED_LUMINANCE\");\n        this.uniforms.get(\"luminanceMap\").value = null;\n      }\n    }\n    /**\r\n     * The luminance adaptation rate.\r\n     *\r\n     * @type {Number}\r\n     */\n\n  }, {\n    key: \"adaptationRate\",\n    get: function get() {\n      return this.adaptiveLuminancePass.getFullscreenMaterial().uniforms.tau.value;\n    }\n    /**\r\n     * @type {Number}\r\n     */\n    ,\n    set: function set(value) {\n      this.adaptiveLuminancePass.getFullscreenMaterial().uniforms.tau.value = value;\n    }\n    /**\r\n     * @type {Number}\r\n     * @deprecated\r\n     */\n\n  }, {\n    key: \"distinction\",\n    get: function get() {\n      console.warn(this.name, \"The distinction field has been removed.\");\n      return 1.0;\n    }\n    /**\r\n     * @type {Number}\r\n     * @deprecated\r\n     */\n    ,\n    set: function set(value) {\n      console.warn(this.name, \"The distinction field has been removed.\");\n    }\n  }]);\n\n  return ToneMappingEffect;\n}(Effect);\n\nvar fragmentShader$w = \"uniform float offset;uniform float darkness;void mainImage(const in vec4 inputColor,const in vec2 uv,out vec4 outputColor){const vec2 center=vec2(0.5);vec3 color=inputColor.rgb;\\n#ifdef ESKIL\\nvec2 coord=(uv-center)*vec2(offset);color=mix(color,vec3(1.0-darkness),dot(coord,coord));\\n#else\\nfloat d=distance(uv,center);color*=smoothstep(0.8,offset*0.799,d*(darkness+offset));\\n#endif\\noutputColor=vec4(color,inputColor.a);}\";\n/**\r\n * A vignette effect.\r\n */\n\nvar VignetteEffect = /*#__PURE__*/function (_Effect25) {\n  _inherits(VignetteEffect, _Effect25);\n\n  var _super48 = _createSuper(VignetteEffect);\n\n  /**\r\n   * Constructs a new vignette effect.\r\n   *\r\n   * @param {Object} [options] - The options.\r\n   * @param {BlendFunction} [options.blendFunction=BlendFunction.NORMAL] - The blend function of this effect.\r\n   * @param {Boolean} [options.eskil=false] - Enables Eskil's vignette technique.\r\n   * @param {Number} [options.offset=0.5] - The vignette offset.\r\n   * @param {Number} [options.darkness=0.5] - The vignette darkness.\r\n   */\n  function VignetteEffect() {\n    var _this36;\n\n    var options = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};\n\n    _classCallCheck(this, VignetteEffect);\n\n    var settings = Object.assign({\n      blendFunction: BlendFunction.NORMAL,\n      eskil: false,\n      offset: 0.5,\n      darkness: 0.5\n    }, options);\n    _this36 = _super48.call(this, \"VignetteEffect\", fragmentShader$w, {\n      blendFunction: settings.blendFunction,\n      uniforms: new Map([[\"offset\", new Uniform(settings.offset)], [\"darkness\", new Uniform(settings.darkness)]])\n    });\n    _this36.eskil = settings.eskil;\n    return _this36;\n  }\n  /**\r\n   * Indicates whether Eskil's vignette technique is enabled.\r\n   *\r\n   * @type {Boolean}\r\n   */\n\n\n  _createClass(VignetteEffect, [{\n    key: \"eskil\",\n    get: function get() {\n      return this.defines.has(\"ESKIL\");\n    }\n    /**\r\n     * Enables or disables Eskil's vignette technique.\r\n     *\r\n     * You'll need to call {@link EffectPass#recompile} after changing this value.\r\n     *\r\n     * @type {Boolean}\r\n     */\n    ,\n    set: function set(value) {\n      value ? this.defines.set(\"ESKIL\", \"1\") : this.defines[\"delete\"](\"ESKIL\");\n    }\n  }]);\n\n  return VignetteEffect;\n}(Effect);\n/**\r\n * Creates a new canvas from raw image data.\r\n *\r\n * @private\r\n * @param {Number} width - The image width.\r\n * @param {Number} height - The image height.\r\n * @param {Uint8ClampedArray} data - The image data.\r\n * @return {Canvas} The canvas.\r\n */\n\n\nfunction createCanvas(width, height, data) {\n  var canvas = document.createElementNS(\"http://www.w3.org/1999/xhtml\", \"canvas\");\n  var context = canvas.getContext(\"2d\");\n  var imageData = context.createImageData(width, height);\n  imageData.data.set(data);\n  canvas.width = width;\n  canvas.height = height;\n  context.putImageData(imageData, 0, 0);\n  return canvas;\n}\n/**\r\n * A container for raw image data.\r\n */\n\n\nvar RawImageData = /*#__PURE__*/function () {\n  /**\r\n   * Constructs a new image data container.\r\n   *\r\n   * @param {Number} [width=0] - The width of the image.\r\n   * @param {Number} [height=0] - The height of the image.\r\n   * @param {Uint8ClampedArray} [data=null] - The image data.\r\n   */\n  function RawImageData() {\n    var width = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n    var height = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n    var data = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : null;\n\n    _classCallCheck(this, RawImageData);\n\n    /**\r\n     * The width of the image.\r\n     *\r\n     * @type {Number}\r\n     */\n    this.width = width;\n    /**\r\n     * The height of the image.\r\n     *\r\n     * @type {Number}\r\n     */\n\n    this.height = height;\n    /**\r\n     * The image data.\r\n     *\r\n     * @type {Uint8ClampedArray}\r\n     */\n\n    this.data = data;\n  }\n  /**\r\n   * Creates a canvas from this image data.\r\n   *\r\n   * @return {Canvas} The canvas or null if it couldn't be created.\r\n   */\n\n\n  _createClass(RawImageData, [{\n    key: \"toCanvas\",\n    value: function toCanvas() {\n      return typeof document === \"undefined\" ? null : createCanvas(this.width, this.height, this.data);\n    }\n    /**\r\n     * Creates a new image data container.\r\n     *\r\n     * @param {Object} data - Raw image data.\r\n     * @return {RawImageData} The image data.\r\n     */\n\n  }], [{\n    key: \"from\",\n    value: function from(data) {\n      return new RawImageData(data.width, data.height, data.data);\n    }\n  }]);\n\n  return RawImageData;\n}();\n\nvar workerProgram = \"!function(){\\\"use strict\\\";function e(e,t){if(!(e instanceof t))throw new TypeError(\\\"Cannot call a class as a function\\\")}function t(e,t){for(var a=0;a<t.length;a++){var n=t[a];n.enumerable=n.enumerable||!1,n.configurable=!0,\\\"value\\\"in n&&(n.writable=!0),Object.defineProperty(e,n.key,n)}}function a(e,a,n){return a&&t(e.prototype,a),n&&t(e,n),e}var n=function(){function t(){var a=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0,s=arguments.length>2&&void 0!==arguments[2]?arguments[2]:null;e(this,t),this.width=a,this.height=n,this.data=s}return a(t,[{key:\\\"toCanvas\\\",value:function(){return\\\"undefined\\\"==typeof document?null:(e=this.width,t=this.height,a=this.data,n=document.createElementNS(\\\"http://www.w3.org/1999/xhtml\\\",\\\"canvas\\\"),s=n.getContext(\\\"2d\\\"),(r=s.createImageData(e,t)).data.set(a),n.width=e,n.height=t,s.putImageData(r,0,0),n);var e,t,a,n,s,r}}],[{key:\\\"from\\\",value:function(e){return new t(e.width,e.height,e.data)}}]),t}(),s=function(){function t(){var a=arguments.length>0&&void 0!==arguments[0]?arguments[0]:0,n=arguments.length>1&&void 0!==arguments[1]?arguments[1]:0;e(this,t),this.x=a,this.y=n}return a(t,[{key:\\\"set\\\",value:function(e,t){return this.x=e,this.y=t,this}},{key:\\\"equals\\\",value:function(e){return this===e||this.x===e.x&&this.y===e.y}}]),t}(),r=function t(){e(this,t),this.min=new s,this.max=new s},i=new r,y=new r,c=new Float32Array([0,-.25,.25,-.125,.125,-.375,.375]),u=[new Float32Array([0,0]),new Float32Array([.25,-.25]),new Float32Array([-.25,.25]),new Float32Array([.125,-.125]),new Float32Array([-.125,.125])],h=[new Uint8Array([0,0]),new Uint8Array([3,0]),new Uint8Array([0,3]),new Uint8Array([3,3]),new Uint8Array([1,0]),new Uint8Array([4,0]),new Uint8Array([1,3]),new Uint8Array([4,3]),new Uint8Array([0,1]),new Uint8Array([3,1]),new Uint8Array([0,4]),new Uint8Array([3,4]),new Uint8Array([1,1]),new Uint8Array([4,1]),new Uint8Array([1,4]),new Uint8Array([4,4])],o=[new Uint8Array([0,0]),new Uint8Array([1,0]),new Uint8Array([0,2]),new Uint8Array([1,2]),new Uint8Array([2,0]),new Uint8Array([3,0]),new Uint8Array([2,2]),new Uint8Array([3,2]),new Uint8Array([0,1]),new Uint8Array([1,1]),new Uint8Array([0,3]),new Uint8Array([1,3]),new Uint8Array([2,1]),new Uint8Array([3,1]),new Uint8Array([2,3]),new Uint8Array([3,3])];function w(e,t,a){return e+(t-e)*a}function x(e,t){var a,n=t.min,s=t.max,r=.5*Math.sqrt(2*n.x),i=.5*Math.sqrt(2*n.y),y=.5*Math.sqrt(2*s.x),c=.5*Math.sqrt(2*s.y),u=(a=e/32,Math.min(Math.max(a,0),1));return n.set(w(r,n.x,u),w(i,n.y,u)),s.set(w(y,s.x,u),w(c,s.y,u)),t}function f(e,t,a,n){var s,r,i,y,c=t.x-e.x,u=t.y-e.y,h=a,o=a+1,w=e.y+u*(h-e.x)/c,x=e.y+u*(o-e.x)/c;return h>=e.x&&h<t.x||o>e.x&&o<=t.x?Math.sign(w)===Math.sign(x)||Math.abs(w)<1e-4||Math.abs(x)<1e-4?(s=(w+x)/2)<0?n.set(Math.abs(s),0):n.set(0,Math.abs(s)):(r=(y=-e.y*c/u+e.x)>e.x?w*(y-Math.trunc(y))/2:0,i=y<t.x?x*(1-(y-Math.trunc(y)))/2:0,(s=Math.abs(r)>Math.abs(i)?r:-i)<0?n.set(Math.abs(r),Math.abs(i)):n.set(Math.abs(i),Math.abs(r))):n.set(0,0),n}function l(e,t,a,n,s){var r=i.min,c=i.max,u=y.min,h=y.max,o=y,w=.5+n,l=.5+n-1,b=t+a+1;switch(e){case 0:s.set(0,0);break;case 1:t<=a?f(r.set(0,l),c.set(b/2,0),t,s):s.set(0,0);break;case 2:t>=a?f(r.set(b/2,0),c.set(b,l),t,s):s.set(0,0);break;case 3:f(r.set(0,l),c.set(b/2,0),t,u),f(r.set(b/2,0),c.set(b,l),t,h),x(b,o),s.set(u.x+h.x,u.y+h.y);break;case 4:t<=a?f(r.set(0,w),c.set(b/2,0),t,s):s.set(0,0);break;case 5:s.set(0,0);break;case 6:Math.abs(n)>0?(f(r.set(0,w),c.set(b,l),t,u),f(r.set(0,w),c.set(b/2,0),t,h),f(r.set(b/2,0),c.set(b,l),t,s),h.set(h.x+s.x,h.y+s.y),s.set((u.x+h.x)/2,(u.y+h.y)/2)):f(r.set(0,w),c.set(b,l),t,s);break;case 7:f(r.set(0,w),c.set(b,l),t,s);break;case 8:t>=a?f(r.set(b/2,0),c.set(b,w),t,s):s.set(0,0);break;case 9:Math.abs(n)>0?(f(r.set(0,l),c.set(b,w),t,u),f(r.set(0,l),c.set(b/2,0),t,h),f(r.set(b/2,0),c.set(b,w),t,s),h.set(h.x+s.x,h.y+s.y),s.set((u.x+h.x)/2,(u.y+h.y)/2)):f(r.set(0,l),c.set(b,w),t,s);break;case 10:s.set(0,0);break;case 11:f(r.set(0,l),c.set(b,w),t,s);break;case 12:f(r.set(0,w),c.set(b/2,0),t,u),f(r.set(b/2,0),c.set(b,w),t,h),x(b,o),s.set(u.x+h.x,u.y+h.y);break;case 13:f(r.set(0,l),c.set(b,w),t,s);break;case 14:f(r.set(0,w),c.set(b,l),t,s);break;case 15:s.set(0,0)}return s}function b(e,t,a,n){var s=e.equals(t);if(!s){var r=(e.x+t.x)/2,i=(e.y+t.y)/2;s=(t.y-e.y)*(a-r)+(e.x-t.x)*(n-i)>0}return s}function A(e,t,a,n){var s,r,i;for(s=0,i=0;i<30;++i)for(r=0;r<30;++r)b(e,t,a+r/29,n+i/29)&&++s;return s/900}function v(e,t,a,n,s,r){var i=o[e],y=i[0],c=i[1];return y>0&&(t.x+=s[0],t.y+=s[1]),c>0&&(a.x+=s[0],a.y+=s[1]),r.set(1-A(t,a,1+n,0+n),A(t,a,1+n,1+n))}function k(e,t,a,n,s){var r=i.min,c=i.max,u=y.min,h=y.max,o=t+a+1;switch(e){case 0:v(e,r.set(1,1),c.set(1+o,1+o),t,n,u),v(e,r.set(1,0),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 1:v(e,r.set(1,0),c.set(0+o,0+o),t,n,u),v(e,r.set(1,0),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 2:v(e,r.set(0,0),c.set(1+o,0+o),t,n,u),v(e,r.set(1,0),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 3:v(e,r.set(1,0),c.set(1+o,0+o),t,n,s);break;case 4:v(e,r.set(1,1),c.set(0+o,0+o),t,n,u),v(e,r.set(1,1),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 5:v(e,r.set(1,1),c.set(0+o,0+o),t,n,u),v(e,r.set(1,0),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 6:v(e,r.set(1,1),c.set(1+o,0+o),t,n,s);break;case 7:v(e,r.set(1,1),c.set(1+o,0+o),t,n,u),v(e,r.set(1,0),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 8:v(e,r.set(0,0),c.set(1+o,1+o),t,n,u),v(e,r.set(1,0),c.set(1+o,1+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 9:v(e,r.set(1,0),c.set(1+o,1+o),t,n,s);break;case 10:v(e,r.set(0,0),c.set(1+o,1+o),t,n,u),v(e,r.set(1,0),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 11:v(e,r.set(1,0),c.set(1+o,1+o),t,n,u),v(e,r.set(1,0),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 12:v(e,r.set(1,1),c.set(1+o,1+o),t,n,s);break;case 13:v(e,r.set(1,1),c.set(1+o,1+o),t,n,u),v(e,r.set(1,0),c.set(1+o,1+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 14:v(e,r.set(1,1),c.set(1+o,1+o),t,n,u),v(e,r.set(1,1),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2);break;case 15:v(e,r.set(1,1),c.set(1+o,1+o),t,n,u),v(e,r.set(1,0),c.set(1+o,0+o),t,n,h),s.set((u.x+h.x)/2,(u.y+h.y)/2)}return s}function U(e,t,a){var n,r,i,y,c,u,h,o,w=new s;for(n=0,r=e.length;n<r;++n)for(h=(u=e[n]).data,o=u.width,y=0;y<o;++y)for(i=0;i<o;++i)a?l(n,i,y,t,w):k(n,i,y,t,w),h[c=2*(y*o+i)]=255*w.x,h[c+1]=255*w.y}function d(e,t,a,n,r,i){var y,c,u,h,o,w,x,f,l,b,A=new s,v=i.data,k=i.width;for(y=0,c=t.length;y<c;++y)for(x=a[y],l=(f=t[y]).data,b=f.width,h=0;h<n;++h)for(u=0;u<n;++u)A.set(x[0]*n+e.x+u,x[1]*n+e.y+h),w=r?2*(h*h*b+u*u):2*(h*b+u),v[o=4*(A.y*k+A.x)]=l[w],v[o+1]=l[w+1],v[o+2]=0,v[o+3]=255}var g=function(){function t(){e(this,t)}return a(t,null,[{key:\\\"generate\\\",value:function(){var e,t,a=5*c.length*16,r=new Uint8ClampedArray(160*a*4),i=new n(160,a,r),y=Math.pow(15,2)+1,w=[],x=[],f=new s;for(e=0;e<16;++e)w.push(new n(y,y,new Uint8ClampedArray(y*y*2),2)),x.push(new n(20,20,new Uint8ClampedArray(800),2));for(e=0,t=c.length;e<t;++e)U(w,c[e],!0),f.set(0,80*e),d(f,w,h,16,!0,i);for(e=0,t=u.length;e<t;++e)U(x,u[e],!1),f.set(80,80*e),d(f,x,o,20,!1,i);return i}}]),t}(),m=new Map([[p([0,0,0,0]),[0,0,0,0]],[p([0,0,0,1]),[0,0,0,1]],[p([0,0,1,0]),[0,0,1,0]],[p([0,0,1,1]),[0,0,1,1]],[p([0,1,0,0]),[0,1,0,0]],[p([0,1,0,1]),[0,1,0,1]],[p([0,1,1,0]),[0,1,1,0]],[p([0,1,1,1]),[0,1,1,1]],[p([1,0,0,0]),[1,0,0,0]],[p([1,0,0,1]),[1,0,0,1]],[p([1,0,1,0]),[1,0,1,0]],[p([1,0,1,1]),[1,0,1,1]],[p([1,1,0,0]),[1,1,0,0]],[p([1,1,0,1]),[1,1,0,1]],[p([1,1,1,0]),[1,1,1,0]],[p([1,1,1,1]),[1,1,1,1]]]);function M(e,t,a){return e+(t-e)*a}function p(e){var t=M(e[0],e[1],.75),a=M(e[2],e[3],.75);return M(t,a,.875)}function C(e,t){var a=0;return 1===t[3]&&1!==e[1]&&1!==e[3]&&(a+=1),1===a&&1===t[2]&&1!==e[0]&&1!==e[2]&&(a+=1),a}var q=function(){function t(){e(this,t)}return a(t,null,[{key:\\\"generate\\\",value:function(){var e,t,a,s,r,i,y,c,u,h,o=new Uint8ClampedArray(2178),w=new Uint8ClampedArray(4096);for(t=0;t<33;++t)for(e=0;e<66;++e)a=.03125*e,s=.03125*t,m.has(a)&&m.has(s)&&(i=m.get(a),y=m.get(s),o[r=66*t+e]=127*(c=i,h=void 0,h=0,1===(u=y)[3]&&(h+=1),1===h&&1===u[2]&&1!==c[1]&&1!==c[3]&&(h+=1),h),o[r+33]=127*C(i,y));for(r=0,t=17;t<33;++t)for(e=0;e<64;++e,r+=4)w[r]=o[66*t+e],w[r+3]=255;return new n(64,16,w)}}]),t}();self.addEventListener(\\\"message\\\",(function(e){var t=g.generate(),a=q.generate();postMessage({areaImageData:t,searchImageData:a},[t.data.buffer,a.data.buffer]),close()}))}();\\n\";\n/**\r\n * Generates the SMAA data images.\r\n *\r\n * @private\r\n * @param {Boolean} [disableCache=false] - Determines whether the generated image data should be cached.\r\n * @return {Promise} A promise that returns the search image and area image blobs.\r\n */\n\nfunction generate() {\n  var disableCache = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : false;\n  var workerURL = URL.createObjectURL(new Blob([workerProgram], {\n    type: \"text/javascript\"\n  }));\n  var worker = new Worker(workerURL);\n  return new Promise(function (resolve, reject) {\n    worker.addEventListener(\"error\", function (event) {\n      return reject(event.error);\n    });\n    worker.addEventListener(\"message\", function (event) {\n      var searchImageData = RawImageData.from(event.data.searchImageData);\n      var areaImageData = RawImageData.from(event.data.areaImageData);\n      var urls = [searchImageData.toCanvas().toDataURL(), areaImageData.toCanvas().toDataURL()];\n\n      if (!disableCache && window.localStorage !== undefined) {\n        localStorage.setItem(\"smaa-search\", urls[0]);\n        localStorage.setItem(\"smaa-area\", urls[1]);\n      }\n\n      URL.revokeObjectURL(workerURL);\n      resolve(urls);\n    });\n    worker.postMessage(null);\n  });\n}\n/**\r\n * An SMAA image loader.\r\n *\r\n * This loader uses a worker thread to generate the search and area images. The\r\n * Generated data URLs will be cached using localStorage, if available. To\r\n * disable caching, please refer to {@link SMAAImageLoader.disableCache}.\r\n *\r\n * @experimental Added for testing, API might change in patch or minor releases.\r\n */\n\n\nvar SMAAImageLoader = /*#__PURE__*/function () {\n  /**\r\n   * Constructs a new SMAA image loader.\r\n   *\r\n   * @param {LoadingManager} [loadingManager] - A loading manager.\r\n   */\n  function SMAAImageLoader() {\n    var loadingManager = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : new LoadingManager();\n\n    _classCallCheck(this, SMAAImageLoader);\n\n    /**\r\n     * A loading manager.\r\n     *\r\n     * @type {LoadingManager}\r\n     */\n    this.loadingManager = loadingManager;\n    /**\r\n     * Indicates whether data image caching is disabled.\r\n     *\r\n     * @type {Boolean}\r\n     */\n\n    this.disableCache = false;\n  }\n  /**\r\n   * Loads the SMAA data images.\r\n   *\r\n   * @param {Function} [onLoad] - A function to call when the loading process is done.\r\n   * @param {Function} [onError] - A function to call when an error occurs.\r\n   * @return {Promise} A promise that returns the search image and area image as a tupel.\r\n   */\n\n\n  _createClass(SMAAImageLoader, [{\n    key: \"load\",\n    value: function load() {\n      var _this37 = this;\n\n      var onLoad = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : function () {};\n      var onError = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : function () {};\n      var externalManager = this.loadingManager;\n      var internalManager = new LoadingManager();\n      externalManager.itemStart(\"smaa-search\");\n      externalManager.itemStart(\"smaa-area\");\n      internalManager.itemStart(\"smaa-search\");\n      internalManager.itemStart(\"smaa-area\");\n      return new Promise(function (resolve, reject) {\n        var cachedURLs = !_this37.disableCache && window.localStorage !== undefined ? [localStorage.getItem(\"smaa-search\"), localStorage.getItem(\"smaa-area\")] : [null, null];\n        var promise = cachedURLs[0] !== null && cachedURLs[1] !== null ? Promise.resolve(cachedURLs) : generate(_this37.disableCache);\n        promise.then(function (urls) {\n          var result = [new Image(), new Image()];\n\n          internalManager.onLoad = function () {\n            onLoad(result);\n            resolve(result);\n          };\n\n          result[0].addEventListener(\"load\", function () {\n            externalManager.itemEnd(\"smaa-search\");\n            internalManager.itemEnd(\"smaa-search\");\n          });\n          result[1].addEventListener(\"load\", function () {\n            externalManager.itemEnd(\"smaa-area\");\n            internalManager.itemEnd(\"smaa-area\");\n          });\n          result[0].src = urls[0];\n          result[1].src = urls[1];\n        })[\"catch\"](function (error) {\n          externalManager.itemError(\"smaa-search\");\n          externalManager.itemError(\"smaa-area\");\n          onError(error);\n          reject(error);\n        });\n      });\n    }\n  }]);\n\n  return SMAAImageLoader;\n}();\n/**\r\n * A 2D vector.\r\n *\r\n * @private\r\n */\n\n\nvar Vector2 = /*#__PURE__*/function () {\n  /**\r\n   * Constructs a new vector.\r\n   *\r\n   * @param {Number} [x=0] - The initial x value.\r\n   * @param {Number} [y=0] - The initial y value.\r\n   */\n  function Vector2() {\n    var x = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : 0;\n    var y = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : 0;\n\n    _classCallCheck(this, Vector2);\n\n    this.x = x;\n    this.y = y;\n  }\n  /**\r\n   * Sets the components of this vector.\r\n   *\r\n   * @param {Number} x - The new x value.\r\n   * @param {Number} y - The new y value.\r\n   * @return {Vector2} This vector.\r\n   */\n\n\n  _createClass(Vector2, [{\n    key: \"set\",\n    value: function set(x, y) {\n      this.x = x;\n      this.y = y;\n      return this;\n    }\n    /**\r\n     * Checks if the given vector equals this vector.\r\n     *\r\n     * @param {Vector2} v - A vector.\r\n     * @return {Boolean} Whether this vector equals the given one.\r\n     */\n\n  }, {\n    key: \"equals\",\n    value: function equals(v) {\n      return this === v || this.x === v.x && this.y === v.y;\n    }\n  }]);\n\n  return Vector2;\n}();\n/**\r\n * A 2D box.\r\n *\r\n * @private\r\n */\n\n\nvar Box2 =\n/**\r\n * Constructs a new box.\r\n */\nfunction Box2() {\n  _classCallCheck(this, Box2);\n\n  this.min = new Vector2();\n  this.max = new Vector2();\n};\n/**\r\n * A box.\r\n *\r\n * @type {Box2}\r\n * @private\r\n */\n\n\nvar b0 = new Box2();\n/**\r\n * A box.\r\n *\r\n * @type {Box2}\r\n * @private\r\n */\n\nvar b1 = new Box2();\n/**\r\n * The orthogonal texture size.\r\n *\r\n * @type {Number}\r\n * @private\r\n */\n\nvar ORTHOGONAL_SIZE = 16;\n/**\r\n * The diagonal texture size.\r\n *\r\n * @type {Number}\r\n * @private\r\n */\n\nvar DIAGONAL_SIZE = 20;\n/**\r\n * The number of samples for calculating areas in the diagonal textures.\r\n * Diagonal areas are calculated using brute force sampling.\r\n *\r\n * @type {Number}\r\n * @private\r\n */\n\nvar DIAGONAL_SAMPLES = 30;\n/**\r\n * The maximum distance for smoothing U-shapes.\r\n *\r\n * @type {Number}\r\n * @private\r\n */\n\nvar SMOOTH_MAX_DISTANCE = 32;\n/**\r\n * Subsampling offsets for orthogonal areas.\r\n *\r\n * @type {Float32Array}\r\n * @private\r\n */\n\nvar orthogonalSubsamplingOffsets = new Float32Array([0.0, -0.25, 0.25, -0.125, 0.125, -0.375, 0.375]);\n/**\r\n * Subsampling offset pairs for diagonal areas.\r\n *\r\n * @type {Float32Array[]}\r\n * @private\r\n */\n\nvar diagonalSubsamplingOffsets = [new Float32Array([0.0, 0.0]), new Float32Array([0.25, -0.25]), new Float32Array([-0.25, 0.25]), new Float32Array([0.125, -0.125]), new Float32Array([-0.125, 0.125])];\n/**\r\n * Orthogonal pattern positioning coordinates.\r\n *\r\n * Used for placing each pattern subtexture into a specific spot.\r\n *\r\n * @type {Uint8Array[]}\r\n * @private\r\n */\n\nvar orthogonalEdges = [new Uint8Array([0, 0]), new Uint8Array([3, 0]), new Uint8Array([0, 3]), new Uint8Array([3, 3]), new Uint8Array([1, 0]), new Uint8Array([4, 0]), new Uint8Array([1, 3]), new Uint8Array([4, 3]), new Uint8Array([0, 1]), new Uint8Array([3, 1]), new Uint8Array([0, 4]), new Uint8Array([3, 4]), new Uint8Array([1, 1]), new Uint8Array([4, 1]), new Uint8Array([1, 4]), new Uint8Array([4, 4])];\n/**\r\n * Diagonal pattern positioning coordinates.\r\n *\r\n * Used for placing each pattern subtexture into a specific spot.\r\n *\r\n * @type {Uint8Array[]}\r\n * @private\r\n */\n\nvar diagonalEdges = [new Uint8Array([0, 0]), new Uint8Array([1, 0]), new Uint8Array([0, 2]), new Uint8Array([1, 2]), new Uint8Array([2, 0]), new Uint8Array([3, 0]), new Uint8Array([2, 2]), new Uint8Array([3, 2]), new Uint8Array([0, 1]), new Uint8Array([1, 1]), new Uint8Array([0, 3]), new Uint8Array([1, 3]), new Uint8Array([2, 1]), new Uint8Array([3, 1]), new Uint8Array([2, 3]), new Uint8Array([3, 3])];\n/**\r\n * Linearly interpolates between two values.\r\n *\r\n * @private\r\n * @param {Number} a - The initial value.\r\n * @param {Number} b - The target value.\r\n * @param {Number} p - The interpolation value.\r\n * @return {Number} The interpolated value.\r\n */\n\nfunction lerp(a, b, p) {\n  return a + (b - a) * p;\n}\n/**\r\n * Clamps a value to the range [0, 1].\r\n *\r\n * @private\r\n * @param {Number} a - The value.\r\n * @return {Number} The saturated value.\r\n */\n\n\nfunction saturate(a) {\n  return Math.min(Math.max(a, 0.0), 1.0);\n}\n/**\r\n * A smoothing function for small U-patterns.\r\n *\r\n * @private\r\n * @param {Number} d - A smoothing factor.\r\n * @param {Box2} b - The area that should be smoothed.\r\n * @return {Box2} The smoothed area.\r\n */\n\n\nfunction smoothArea(d, b) {\n  var a1 = b.min;\n  var a2 = b.max;\n  var b1X = Math.sqrt(a1.x * 2.0) * 0.5;\n  var b1Y = Math.sqrt(a1.y * 2.0) * 0.5;\n  var b2X = Math.sqrt(a2.x * 2.0) * 0.5;\n  var b2Y = Math.sqrt(a2.y * 2.0) * 0.5;\n  var p = saturate(d / SMOOTH_MAX_DISTANCE);\n  a1.set(lerp(b1X, a1.x, p), lerp(b1Y, a1.y, p));\n  a2.set(lerp(b2X, a2.x, p), lerp(b2Y, a2.y, p));\n  return b;\n}\n/**\r\n * Calculates the area under the line p1 -> p2, for the pixels (x, x + 1).\r\n *\r\n * @private\r\n * @param {Vector2} p1 - The starting point of the line.\r\n * @param {Vector2} p2 - The ending point of the line.\r\n * @param {Number} x - The pixel index.\r\n * @param {Vector2} result - A target vector to store the area in.\r\n * @return {Vector2} The area.\r\n */\n\n\nfunction calculateOrthogonalArea(p1, p2, x, result) {\n  var dX = p2.x - p1.x;\n  var dY = p2.y - p1.y;\n  var x1 = x;\n  var x2 = x + 1.0;\n  var y1 = p1.y + dY * (x1 - p1.x) / dX;\n  var y2 = p1.y + dY * (x2 - p1.x) / dX;\n  var a, a1, a2, t; // Check if x is inside the area.\n\n  if (x1 >= p1.x && x1 < p2.x || x2 > p1.x && x2 <= p2.x) {\n    // Check if this is a trapezoid.\n    if (Math.sign(y1) === Math.sign(y2) || Math.abs(y1) < 1e-4 || Math.abs(y2) < 1e-4) {\n      a = (y1 + y2) / 2.0;\n\n      if (a < 0.0) {\n        result.set(Math.abs(a), 0.0);\n      } else {\n        result.set(0.0, Math.abs(a));\n      }\n    } else {\n      // Two triangles.\n      t = -p1.y * dX / dY + p1.x;\n      a1 = t > p1.x ? y1 * (t - Math.trunc(t)) / 2.0 : 0.0;\n      a2 = t < p2.x ? y2 * (1.0 - (t - Math.trunc(t))) / 2.0 : 0.0;\n      a = Math.abs(a1) > Math.abs(a2) ? a1 : -a2;\n\n      if (a < 0.0) {\n        result.set(Math.abs(a1), Math.abs(a2));\n      } else {\n        result.set(Math.abs(a2), Math.abs(a1));\n      }\n    }\n  } else {\n    result.set(0, 0);\n  }\n\n  return result;\n}\n/**\r\n * Calculates the area for a given pattern and distances to the left and to the\r\n * right, biased by an offset.\r\n *\r\n * @private\r\n * @param {Number} pattern - A pattern index.\r\n * @param {Number} left - The left distance.\r\n * @param {Number} right - The right distance.\r\n * @param {Number} offset - An offset.\r\n * @param {Vector2} result - A target vector to store the area in.\r\n * @return {Vector2} The orthogonal area.\r\n */\n\n\nfunction calculateOrthogonalAreaForPattern(pattern, left, right, offset, result) {\n  var p1 = b0.min;\n  var p2 = b0.max;\n  var a1 = b1.min;\n  var a2 = b1.max;\n  var a = b1;\n  /* o1           |\r\n   *      .-------´\r\n   * o2   |\r\n   *\r\n   *      <---d--->\r\n   */\n\n  var o1 = 0.5 + offset;\n  var o2 = 0.5 + offset - 1.0;\n  var d = left + right + 1;\n\n  switch (pattern) {\n    case 0:\n      {\n        //    ------\n        result.set(0, 0);\n        break;\n      }\n\n    case 1:\n      {\n        /*   .------\r\n         *   |\r\n         *\r\n         * The offset is only applied to L patterns in the crossing edge side to\r\n         * make it converge with the unfiltered pattern 0.\r\n         * The pattern 0 must not be filtered to avoid artifacts.\r\n         */\n        if (left <= right) {\n          calculateOrthogonalArea(p1.set(0.0, o2), p2.set(d / 2.0, 0.0), left, result);\n        } else {\n          result.set(0, 0);\n        }\n\n        break;\n      }\n\n    case 2:\n      {\n        /*    ------.\r\n         *          |\r\n         */\n        if (left >= right) {\n          calculateOrthogonalArea(p1.set(d / 2.0, 0.0), p2.set(d, o2), left, result);\n        } else {\n          result.set(0, 0);\n        }\n\n        break;\n      }\n\n    case 3:\n      {\n        /*   .------.\r\n         *   |      |\r\n         */\n        calculateOrthogonalArea(p1.set(0.0, o2), p2.set(d / 2.0, 0.0), left, a1);\n        calculateOrthogonalArea(p1.set(d / 2.0, 0.0), p2.set(d, o2), left, a2);\n        smoothArea(d, a);\n        result.set(a1.x + a2.x, a1.y + a2.y);\n        break;\n      }\n\n    case 4:\n      {\n        /*   |\r\n         *   `------\r\n         */\n        if (left <= right) {\n          calculateOrthogonalArea(p1.set(0.0, o1), p2.set(d / 2.0, 0.0), left, result);\n        } else {\n          result.set(0, 0);\n        }\n\n        break;\n      }\n\n    case 5:\n      {\n        /*   |\r\n         *   +------\r\n         *   |\r\n         */\n        result.set(0, 0);\n        break;\n      }\n\n    case 6:\n      {\n        /*   |\r\n         *   `------.\r\n         *          |\r\n         *\r\n         * A problem of not offseting L patterns (see above) is that for certain\r\n         * max search distances, the pixels in the center of a Z pattern will\r\n         * detect the full Z pattern, while the pixels in the sides will detect an\r\n         * L pattern. To avoid discontinuities, the full offsetted Z\r\n         * revectorization is blended with partially offsetted L patterns.\r\n         */\n        if (Math.abs(offset) > 0.0) {\n          calculateOrthogonalArea(p1.set(0.0, o1), p2.set(d, o2), left, a1);\n          calculateOrthogonalArea(p1.set(0.0, o1), p2.set(d / 2.0, 0.0), left, a2);\n          calculateOrthogonalArea(p1.set(d / 2.0, 0.0), p2.set(d, o2), left, result);\n          a2.set(a2.x + result.x, a2.y + result.y);\n          result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        } else {\n          calculateOrthogonalArea(p1.set(0.0, o1), p2.set(d, o2), left, result);\n        }\n\n        break;\n      }\n\n    case 7:\n      {\n        /*   |\r\n         *   +------.\r\n         *   |      |\r\n         */\n        calculateOrthogonalArea(p1.set(0.0, o1), p2.set(d, o2), left, result);\n        break;\n      }\n\n    case 8:\n      {\n        /*          |\r\n         *    ------´\r\n         */\n        if (left >= right) {\n          calculateOrthogonalArea(p1.set(d / 2.0, 0.0), p2.set(d, o1), left, result);\n        } else {\n          result.set(0, 0);\n        }\n\n        break;\n      }\n\n    case 9:\n      {\n        /*          |\r\n         *   .------´\r\n         *   |\r\n         */\n        if (Math.abs(offset) > 0.0) {\n          calculateOrthogonalArea(p1.set(0.0, o2), p2.set(d, o1), left, a1);\n          calculateOrthogonalArea(p1.set(0.0, o2), p2.set(d / 2.0, 0.0), left, a2);\n          calculateOrthogonalArea(p1.set(d / 2.0, 0.0), p2.set(d, o1), left, result);\n          a2.set(a2.x + result.x, a2.y + result.y);\n          result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        } else {\n          calculateOrthogonalArea(p1.set(0.0, o2), p2.set(d, o1), left, result);\n        }\n\n        break;\n      }\n\n    case 10:\n      {\n        /*          |\r\n         *    ------+\r\n         *          |\r\n         */\n        result.set(0, 0);\n        break;\n      }\n\n    case 11:\n      {\n        /*          |\r\n         *   .------+\r\n         *   |      |\r\n         */\n        calculateOrthogonalArea(p1.set(0.0, o2), p2.set(d, o1), left, result);\n        break;\n      }\n\n    case 12:\n      {\n        /*   |      |\r\n         *   `------´\r\n         */\n        calculateOrthogonalArea(p1.set(0.0, o1), p2.set(d / 2.0, 0.0), left, a1);\n        calculateOrthogonalArea(p1.set(d / 2.0, 0.0), p2.set(d, o1), left, a2);\n        smoothArea(d, a);\n        result.set(a1.x + a2.x, a1.y + a2.y);\n        break;\n      }\n\n    case 13:\n      {\n        /*   |      |\r\n         *   +------´\r\n         *   |\r\n         */\n        calculateOrthogonalArea(p1.set(0.0, o2), p2.set(d, o1), left, result);\n        break;\n      }\n\n    case 14:\n      {\n        /*   |      |\r\n         *   `------+\r\n         *          |\r\n         */\n        calculateOrthogonalArea(p1.set(0.0, o1), p2.set(d, o2), left, result);\n        break;\n      }\n\n    case 15:\n      {\n        /*   |      |\r\n         *   +------+\r\n         *   |      |\r\n         */\n        result.set(0, 0);\n        break;\n      }\n  }\n\n  return result;\n}\n/**\r\n * Determines whether the given pixel is inside the specified area.\r\n *\r\n * @private\r\n * @param {Vector2} p1 - The lower bounds of the area.\r\n * @param {Vector2} p2 - The upper bounds of the area.\r\n * @param {Vector2} x - The X-coordinates.\r\n * @param {Vector2} y - The Y-coordinates.\r\n * @return {Vector2} Whether the pixel lies inside the area.\r\n */\n\n\nfunction isInsideArea(p1, p2, x, y) {\n  var result = p1.equals(p2);\n\n  if (!result) {\n    var xm = (p1.x + p2.x) / 2.0;\n    var ym = (p1.y + p2.y) / 2.0;\n    var a = p2.y - p1.y;\n    var b = p1.x - p2.x;\n    var c = a * (x - xm) + b * (y - ym);\n    result = c > 0.0;\n  }\n\n  return result;\n}\n/**\r\n * Calculates the area under the line p1 -> p2 for the pixel p using brute force\r\n * sampling.\r\n *\r\n * @private\r\n * @param {Vector2} p1 - The lower bounds of the area.\r\n * @param {Vector2} p2 - The upper bounds of the area.\r\n * @param {Number} pX - The X-coordinates.\r\n * @param {Number} pY - The Y-coordinates.\r\n * @return {Number} The amount of pixels inside the area relative to the total amount of sampled pixels.\r\n */\n\n\nfunction calculateDiagonalAreaForPixel(p1, p2, pX, pY) {\n  var a;\n  var x, y;\n  var offsetX, offsetY;\n\n  for (a = 0, y = 0; y < DIAGONAL_SAMPLES; ++y) {\n    for (x = 0; x < DIAGONAL_SAMPLES; ++x) {\n      offsetX = x / (DIAGONAL_SAMPLES - 1.0);\n      offsetY = y / (DIAGONAL_SAMPLES - 1.0);\n\n      if (isInsideArea(p1, p2, pX + offsetX, pY + offsetY)) {\n        ++a;\n      }\n    }\n  }\n\n  return a / (DIAGONAL_SAMPLES * DIAGONAL_SAMPLES);\n}\n/**\r\n * Calculates the area under the line p1 -> p2. This includes the pixel and its\r\n * opposite.\r\n *\r\n * @private\r\n * @param {Number} pattern - A pattern index.\r\n * @param {Vector2} p1 - The lower bounds of the area.\r\n * @param {Vector2} p2 - The upper bounds of the area.\r\n * @param {Number} left - The left distance.\r\n * @param {Float32Array} offset - An offset.\r\n * @param {Vector2} result - A target vector to store the area in.\r\n * @return {Vector2} The area.\r\n */\n\n\nfunction calculateDiagonalArea(pattern, p1, p2, left, offset, result) {\n  var e = diagonalEdges[pattern];\n  var e1 = e[0];\n  var e2 = e[1];\n\n  if (e1 > 0) {\n    p1.x += offset[0];\n    p1.y += offset[1];\n  }\n\n  if (e2 > 0) {\n    p2.x += offset[0];\n    p2.y += offset[1];\n  }\n\n  return result.set(1.0 - calculateDiagonalAreaForPixel(p1, p2, 1.0 + left, 0.0 + left), calculateDiagonalAreaForPixel(p1, p2, 1.0 + left, 1.0 + left));\n}\n/**\r\n * Calculates the area for a given pattern and distances to the left and to the\r\n * right, biased by an offset.\r\n *\r\n * @private\r\n * @param {Number} pattern - A pattern index.\r\n * @param {Number} left - The left distance.\r\n * @param {Number} right - The right distance.\r\n * @param {Float32Array} offset - An offset.\r\n * @param {Vector2} result - A target vector to store the area in.\r\n * @return {Vector2} The orthogonal area.\r\n */\n\n\nfunction calculateDiagonalAreaForPattern(pattern, left, right, offset, result) {\n  var p1 = b0.min;\n  var p2 = b0.max;\n  var a1 = b1.min;\n  var a2 = b1.max;\n  var d = left + right + 1;\n  /* There is some Black Magic involved in the diagonal area calculations.\r\n   *\r\n   * Unlike orthogonal patterns, the \"null\" pattern (one without crossing edges)\r\n   * must be filtered, and the ends of both the \"null\" and L patterns are not\r\n   * known: L and U patterns have different endings, and the adjacent pattern is\r\n   * unknown. Therefore, a blend of both possibilities is computed.\r\n   */\n\n  switch (pattern) {\n    case 0:\n      {\n        /*         .-´\r\n         *       .-´\r\n         *     .-´\r\n         *   .-´\r\n         *   ´\r\n         */\n        // First possibility.\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 1.0 + d), left, offset, a1); // Second possibility.\n\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2); // Blend both possibilities together.\n\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 1:\n      {\n        /*         .-´\r\n         *       .-´\r\n         *     .-´\r\n         *   .-´\r\n         *   |\r\n         *   |\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(0.0 + d, 0.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 2:\n      {\n        /*         .----\r\n         *       .-´\r\n         *     .-´\r\n         *   .-´\r\n         *   ´\r\n         */\n        calculateDiagonalArea(pattern, p1.set(0.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 3:\n      {\n        /*\r\n         *         .----\r\n         *       .-´\r\n         *     .-´\r\n         *   .-´\r\n         *   |\r\n         *   |\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, result);\n        break;\n      }\n\n    case 4:\n      {\n        /*         .-´\r\n         *       .-´\r\n         *     .-´\r\n         * ----´\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(0.0 + d, 0.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 5:\n      {\n        /*         .-´\r\n         *       .-´\r\n         *     .-´\r\n         * --.-´\r\n         *   |\r\n         *   |\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(0.0 + d, 0.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 6:\n      {\n        /*         .----\r\n         *       .-´\r\n         *     .-´\r\n         * ----´\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 0.0 + d), left, offset, result);\n        break;\n      }\n\n    case 7:\n      {\n        /*         .----\r\n         *       .-´\r\n         *     .-´\r\n         * --.-´\r\n         *   |\r\n         *   |\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 0.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 8:\n      {\n        /*         |\r\n         *         |\r\n         *       .-´\r\n         *     .-´\r\n         *   .-´\r\n         *   ´\r\n         */\n        calculateDiagonalArea(pattern, p1.set(0.0, 0.0), p2.set(1.0 + d, 1.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 1.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 9:\n      {\n        /*         |\r\n         *         |\r\n         *       .-´\r\n         *     .-´\r\n         *   .-´\r\n         *   |\r\n         *   |\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 1.0 + d), left, offset, result);\n        break;\n      }\n\n    case 10:\n      {\n        /*         |\r\n         *         .----\r\n         *       .-´\r\n         *     .-´\r\n         *   .-´\r\n         *   ´\r\n         */\n        calculateDiagonalArea(pattern, p1.set(0.0, 0.0), p2.set(1.0 + d, 1.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 11:\n      {\n        /*         |\r\n         *         .----\r\n         *       .-´\r\n         *     .-´\r\n         *   .-´\r\n         *   |\r\n         *   |\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 1.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 12:\n      {\n        /*         |\r\n         *         |\r\n         *       .-´\r\n         *     .-´\r\n         * ----´\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 1.0 + d), left, offset, result);\n        break;\n      }\n\n    case 13:\n      {\n        /*         |\r\n         *         |\r\n         *       .-´\r\n         *     .-´\r\n         * --.-´\r\n         *   |\r\n         *   |\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 1.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 1.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 14:\n      {\n        /*         |\r\n         *         .----\r\n         *       .-´\r\n         *     .-´\r\n         * ----´\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 1.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n\n    case 15:\n      {\n        /*         |\r\n         *         .----\r\n         *       .-´\r\n         *     .-´\r\n         * --.-´\r\n         *   |\r\n         *   |\r\n         */\n        calculateDiagonalArea(pattern, p1.set(1.0, 1.0), p2.set(1.0 + d, 1.0 + d), left, offset, a1);\n        calculateDiagonalArea(pattern, p1.set(1.0, 0.0), p2.set(1.0 + d, 0.0 + d), left, offset, a2);\n        result.set((a1.x + a2.x) / 2.0, (a1.y + a2.y) / 2.0);\n        break;\n      }\n  }\n\n  return result;\n}\n/**\r\n * Calculates orthogonal or diagonal patterns for a given offset.\r\n *\r\n * @private\r\n * @param {RawImageData[]} patterns - The patterns to assemble.\r\n * @param {Number|Float32Array} offset - A pattern offset. Diagonal offsets are pairs.\r\n * @param {Boolean} orthogonal - Whether the patterns are orthogonal or diagonal.\r\n */\n\n\nfunction generatePatterns(patterns, offset, orthogonal) {\n  var result = new Vector2();\n  var i, l;\n  var x, y;\n  var c;\n  var pattern;\n  var data, size;\n\n  for (i = 0, l = patterns.length; i < l; ++i) {\n    pattern = patterns[i];\n    data = pattern.data;\n    size = pattern.width;\n\n    for (y = 0; y < size; ++y) {\n      for (x = 0; x < size; ++x) {\n        if (orthogonal) {\n          calculateOrthogonalAreaForPattern(i, x, y, offset, result);\n        } else {\n          calculateDiagonalAreaForPattern(i, x, y, offset, result);\n        }\n\n        c = (y * size + x) * 2;\n        data[c] = result.x * 255;\n        data[c + 1] = result.y * 255;\n      }\n    }\n  }\n}\n/**\r\n * Assembles orthogonal or diagonal patterns into the final area image.\r\n *\r\n * @private\r\n * @param {Vector2} base - A base position.\r\n * @param {RawImageData[]} patterns - The patterns to assemble.\r\n * @param {Uint8Array[]} edges - Edge coordinate pairs, used for positioning.\r\n * @param {Number} size - The pattern size.\r\n * @param {Boolean} orthogonal - Whether the patterns are orthogonal or diagonal.\r\n * @param {RawImageData} target - The target image data.\r\n */\n\n\nfunction assemble(base, patterns, edges, size, orthogonal, target) {\n  var p = new Vector2();\n  var dstData = target.data;\n  var dstWidth = target.width;\n  var i, l;\n  var x, y;\n  var c, d;\n  var edge;\n  var pattern;\n  var srcData, srcWidth;\n\n  for (i = 0, l = patterns.length; i < l; ++i) {\n    edge = edges[i];\n    pattern = patterns[i];\n    srcData = pattern.data;\n    srcWidth = pattern.width;\n\n    for (y = 0; y < size; ++y) {\n      for (x = 0; x < size; ++x) {\n        p.set(edge[0] * size + base.x + x, edge[1] * size + base.y + y);\n        c = (p.y * dstWidth + p.x) * 4;\n        /* The texture coordinates of orthogonal patterns are compressed\r\n        quadratically to reach longer distances for a given texture size. */\n\n        d = orthogonal ? (y * y * srcWidth + x * x) * 2 : (y * srcWidth + x) * 2;\n        dstData[c] = srcData[d];\n        dstData[c + 1] = srcData[d + 1];\n        dstData[c + 2] = 0;\n        dstData[c + 3] = 255;\n      }\n    }\n  }\n}\n/**\r\n * SMAA area image data.\r\n *\r\n * This texture allows to obtain the area for a certain pattern and distances\r\n * to the left and to the right of the identified line.\r\n *\r\n * Based on the official python scripts:\r\n *  https://github.com/iryoku/smaa/tree/master/Scripts\r\n */\n\n\nvar SMAAAreaImageData = /*#__PURE__*/function () {\n  function SMAAAreaImageData() {\n    _classCallCheck(this, SMAAAreaImageData);\n  }\n\n  _createClass(SMAAAreaImageData, null, [{\n    key: \"generate\",\n\n    /**\r\n     * Creates a new area image.\r\n     *\r\n     * @return {RawImageData} The generated image data.\r\n     */\n    value: function generate() {\n      var width = 2 * 5 * ORTHOGONAL_SIZE;\n      var height = orthogonalSubsamplingOffsets.length * 5 * ORTHOGONAL_SIZE;\n      var data = new Uint8ClampedArray(width * height * 4);\n      var result = new RawImageData(width, height, data);\n      var orthogonalPatternSize = Math.pow(ORTHOGONAL_SIZE - 1, 2) + 1;\n      var diagonalPatternSize = DIAGONAL_SIZE;\n      var orthogonalPatterns = [];\n      var diagonalPatterns = [];\n      var base = new Vector2();\n      var i, l; // Prepare 16 image data sets for the orthogonal and diagonal subtextures.\n\n      for (i = 0; i < 16; ++i) {\n        orthogonalPatterns.push(new RawImageData(orthogonalPatternSize, orthogonalPatternSize, new Uint8ClampedArray(orthogonalPatternSize * orthogonalPatternSize * 2), 2));\n        diagonalPatterns.push(new RawImageData(diagonalPatternSize, diagonalPatternSize, new Uint8ClampedArray(diagonalPatternSize * diagonalPatternSize * 2), 2));\n      }\n\n      for (i = 0, l = orthogonalSubsamplingOffsets.length; i < l; ++i) {\n        // Generate 16 orthogonal patterns for each offset.\n        generatePatterns(orthogonalPatterns, orthogonalSubsamplingOffsets[i], true); // Assemble the orthogonal patterns and place them on the left side.\n\n        base.set(0, 5 * ORTHOGONAL_SIZE * i);\n        assemble(base, orthogonalPatterns, orthogonalEdges, ORTHOGONAL_SIZE, true, result);\n      }\n\n      for (i = 0, l = diagonalSubsamplingOffsets.length; i < l; ++i) {\n        // Generate 16 diagonal patterns for each offset.\n        generatePatterns(diagonalPatterns, diagonalSubsamplingOffsets[i], false); // Assemble the diagonal patterns and place them on the right side.\n\n        base.set(5 * ORTHOGONAL_SIZE, 4 * DIAGONAL_SIZE * i);\n        assemble(base, diagonalPatterns, diagonalEdges, DIAGONAL_SIZE, false, result);\n      }\n\n      return result;\n    }\n  }]);\n\n  return SMAAAreaImageData;\n}();\n/**\r\n * This dictionary returns which edges are active for a certain bilinear fetch:\r\n * it's the reverse lookup of the bilinear function.\r\n *\r\n * @type {Map}\r\n * @private\r\n */\n\n\nvar edges = new Map([[bilinear([0, 0, 0, 0]), [0, 0, 0, 0]], [bilinear([0, 0, 0, 1]), [0, 0, 0, 1]], [bilinear([0, 0, 1, 0]), [0, 0, 1, 0]], [bilinear([0, 0, 1, 1]), [0, 0, 1, 1]], [bilinear([0, 1, 0, 0]), [0, 1, 0, 0]], [bilinear([0, 1, 0, 1]), [0, 1, 0, 1]], [bilinear([0, 1, 1, 0]), [0, 1, 1, 0]], [bilinear([0, 1, 1, 1]), [0, 1, 1, 1]], [bilinear([1, 0, 0, 0]), [1, 0, 0, 0]], [bilinear([1, 0, 0, 1]), [1, 0, 0, 1]], [bilinear([1, 0, 1, 0]), [1, 0, 1, 0]], [bilinear([1, 0, 1, 1]), [1, 0, 1, 1]], [bilinear([1, 1, 0, 0]), [1, 1, 0, 0]], [bilinear([1, 1, 0, 1]), [1, 1, 0, 1]], [bilinear([1, 1, 1, 0]), [1, 1, 1, 0]], [bilinear([1, 1, 1, 1]), [1, 1, 1, 1]]]);\n/**\r\n * Linearly interpolates between two values.\r\n *\r\n * @private\r\n * @param {Number} a - The initial value.\r\n * @param {Number} b - The target value.\r\n * @param {Number} p - The interpolation value.\r\n * @return {Number} The interpolated value.\r\n */\n\nfunction lerp$1(a, b, p) {\n  return a + (b - a) * p;\n}\n/**\r\n * Calculates the bilinear fetch for a certain edge combination.\r\n *\r\n *     e[0]       e[1]\r\n *\r\n *              x <-------- Sample Position: (-0.25, -0.125)\r\n *     e[2]       e[3] <--- Current Pixel [3]: (0.0, 0.0)\r\n *\r\n * @private\r\n * @param {Number[]} e - The edge combination.\r\n * @return {Number} The interpolated value.\r\n */\n\n\nfunction bilinear(e) {\n  var a = lerp$1(e[0], e[1], 1.0 - 0.25);\n  var b = lerp$1(e[2], e[3], 1.0 - 0.25);\n  return lerp$1(a, b, 1.0 - 0.125);\n}\n/**\r\n * Computes the delta distance to add in the last step of searches to the left.\r\n *\r\n * @private\r\n * @param {Number[]} left - The left edge combination.\r\n * @param {Number[]} top - The top edge combination.\r\n * @return {Number} The left delta distance.\r\n */\n\n\nfunction deltaLeft(left, top) {\n  var d = 0; // If there is an edge, continue.\n\n  if (top[3] === 1) {\n    d += 1;\n  }\n  /* If an edge was previously found, there is another edge and there are no\r\n  crossing edges, continue. */\n\n\n  if (d === 1 && top[2] === 1 && left[1] !== 1 && left[3] !== 1) {\n    d += 1;\n  }\n\n  return d;\n}\n/**\r\n * Computes the delta distance to add in the last step of searches to the right.\r\n *\r\n * @private\r\n * @param {Number[]} left - The left edge combination.\r\n * @param {Number[]} top - The top edge combination.\r\n * @return {Number} The right delta distance.\r\n */\n\n\nfunction deltaRight(left, top) {\n  var d = 0; // If there is an edge, and no crossing edges, continue.\n\n  if (top[3] === 1 && left[1] !== 1 && left[3] !== 1) {\n    d += 1;\n  }\n  /* If an edge was previously found, there is another edge and there are no\r\n  crossing edges, continue. */\n\n\n  if (d === 1 && top[2] === 1 && left[0] !== 1 && left[2] !== 1) {\n    d += 1;\n  }\n\n  return d;\n}\n/**\r\n * SMAA search image data.\r\n *\r\n * This image stores information about how many pixels the line search\r\n * algorithm must advance in the last step.\r\n *\r\n * Based on the official python scripts:\r\n *  https://github.com/iryoku/smaa/tree/master/Scripts\r\n */\n\n\nvar SMAASearchImageData = /*#__PURE__*/function () {\n  function SMAASearchImageData() {\n    _classCallCheck(this, SMAASearchImageData);\n  }\n\n  _createClass(SMAASearchImageData, null, [{\n    key: \"generate\",\n\n    /**\r\n     * Creates a new search image.\r\n     *\r\n     * @return {RawImageData} The generated image data.\r\n     */\n    value: function generate() {\n      var width = 66;\n      var height = 33;\n      var halfWidth = width / 2;\n      var croppedWidth = 64;\n      var croppedHeight = 16;\n      var data = new Uint8ClampedArray(width * height);\n      var croppedData = new Uint8ClampedArray(croppedWidth * croppedHeight * 4);\n      var x, y;\n      var s, t, i;\n      var e1, e2; // Calculate delta distances.\n\n      for (y = 0; y < height; ++y) {\n        for (x = 0; x < width; ++x) {\n          s = 0.03125 * x;\n          t = 0.03125 * y;\n\n          if (edges.has(s) && edges.has(t)) {\n            e1 = edges.get(s);\n            e2 = edges.get(t);\n            i = y * width + x; // Maximize the dynamic range to help the compression.\n\n            data[i] = 127 * deltaLeft(e1, e2);\n            data[i + halfWidth] = 127 * deltaRight(e1, e2);\n          }\n        }\n      } // Crop the result to powers-of-two to make it BC4-friendly.\n\n\n      for (i = 0, y = height - croppedHeight; y < height; ++y) {\n        for (x = 0; x < croppedWidth; ++x, i += 4) {\n          croppedData[i] = data[y * width + x];\n          croppedData[i + 3] = 255;\n        }\n      }\n\n      return new RawImageData(croppedWidth, croppedHeight, croppedData);\n    }\n  }]);\n\n  return SMAASearchImageData;\n}();\n\nexport { AdaptiveLuminanceMaterial, BlendFunction, BlendMode, BloomEffect, BlurPass, BokehEffect, BrightnessContrastEffect, ChromaticAberrationEffect, ClearMaskPass, ClearPass, ColorAverageEffect, ColorDepthEffect, ColorEdgesMaterial, ConvolutionMaterial, CopyMaterial, DepthComparisonMaterial, DepthEffect, DepthMaskMaterial, DepthPass, Disposable, DotScreenEffect, Effect, EffectAttribute, EffectComposer, EffectMaterial, EffectPass, GammaCorrectionEffect, GlitchEffect, GlitchMode, GodRaysEffect, GodRaysMaterial, GridEffect, HueSaturationEffect, Initializable, KernelSize, LuminanceMaterial, MaskPass, NoiseEffect, NormalPass, OutlineEdgesMaterial, OutlineEffect, Pass, PixelationEffect, RawImageData, RealisticBokehEffect, RenderPass, Resizable, Resizer, SMAAAreaImageData, SMAAEffect, SMAAImageLoader, SMAAPreset, SMAASearchImageData, SMAAWeightsMaterial, SSAOEffect, SavePass, ScanlineEffect, Selection, SelectiveBloomEffect, SepiaEffect, ShaderPass, ShockWaveEffect, TextureEffect, ToneMappingEffect, VignetteEffect, WebGLExtension };"],"sourceRoot":""}