opal-js_wrap-three 0.1.1 → 0.1.2

data/lib-opal/js_wrap/three/postprocessing/SSRPass.js

@@ -0,0 +1,537 @@
+(function (global, factory) {
+  if (typeof define === "function" && define.amd) {
+    define(["exports", "three", "./Pass.js", "../shaders/SSRShader.js", "../shaders/CopyShader.js"], factory);
+  } else if (typeof exports !== "undefined") {
+    factory(exports, require("three"), require("./Pass.js"), require("../shaders/SSRShader.js"), require("../shaders/CopyShader.js"));
+  } else {
+    var mod = {
+      exports: {}
+    };
+    factory(mod.exports, global.three, global.Pass, global.SSRShader, global.CopyShader);
+    global.SSRPass = mod.exports;
+  }
+})(typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : this, function (_exports, _three, _Pass2, _SSRShader, _CopyShader) {
+  "use strict";
+
+  Object.defineProperty(_exports, "__esModule", {
+    value: true
+  });
+  _exports.SSRPass = void 0;
+
+  function _classCallCheck(instance, Constructor) { if (!(instance instanceof Constructor)) { throw new TypeError("Cannot call a class as a function"); } }
+
+  function _defineProperties(target, props) { for (var i = 0; i < props.length; i++) { var descriptor = props[i]; descriptor.enumerable = descriptor.enumerable || false; descriptor.configurable = true; if ("value" in descriptor) descriptor.writable = true; Object.defineProperty(target, descriptor.key, descriptor); } }
+
+  function _createClass(Constructor, protoProps, staticProps) { if (protoProps) _defineProperties(Constructor.prototype, protoProps); if (staticProps) _defineProperties(Constructor, staticProps); Object.defineProperty(Constructor, "prototype", { writable: false }); return Constructor; }
+
+  function _inherits(subClass, superClass) { if (typeof superClass !== "function" && superClass !== null) { throw new TypeError("Super expression must either be null or a function"); } Object.defineProperty(subClass, "prototype", { value: Object.create(superClass && superClass.prototype, { constructor: { value: subClass, writable: true, configurable: true } }), writable: false }); if (superClass) _setPrototypeOf(subClass, superClass); }
+
+  function _setPrototypeOf(o, p) { _setPrototypeOf = Object.setPrototypeOf || function _setPrototypeOf(o, p) { o.__proto__ = p; return o; }; return _setPrototypeOf(o, p); }
+
+  function _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); }; }
+
+  function _possibleConstructorReturn(self, call) { if (call && (typeof call === "object" || typeof call === "function")) { return call; } else if (call !== void 0) { throw new TypeError("Derived constructors may only return object or undefined"); } return _assertThisInitialized(self); }
+
+  function _assertThisInitialized(self) { if (self === void 0) { throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); } return self; }
+
+  function _isNativeReflectConstruct() { if (typeof Reflect === "undefined" || !Reflect.construct) return false; if (Reflect.construct.sham) return false; if (typeof Proxy === "function") return true; try { Boolean.prototype.valueOf.call(Reflect.construct(Boolean, [], function () {})); return true; } catch (e) { return false; } }
+
+  function _getPrototypeOf(o) { _getPrototypeOf = Object.setPrototypeOf ? Object.getPrototypeOf : function _getPrototypeOf(o) { return o.__proto__ || Object.getPrototypeOf(o); }; return _getPrototypeOf(o); }
+
+  var SSRPass = /*#__PURE__*/function (_Pass) {
+    _inherits(SSRPass, _Pass);
+
+    var _super = _createSuper(SSRPass);
+
+    function SSRPass(_ref) {
+      var _this;
+
+      var renderer = _ref.renderer,
+          scene = _ref.scene,
+          camera = _ref.camera,
+          width = _ref.width,
+          height = _ref.height,
+          selects = _ref.selects,
+          _ref$bouncing = _ref.bouncing,
+          bouncing = _ref$bouncing === void 0 ? false : _ref$bouncing,
+          groundReflector = _ref.groundReflector;
+
+      _classCallCheck(this, SSRPass);
+
+      _this = _super.call(this);
+      _this.width = width !== undefined ? width : 512;
+      _this.height = height !== undefined ? height : 512;
+      _this.clear = true;
+      _this.renderer = renderer;
+      _this.scene = scene;
+      _this.camera = camera;
+      _this.groundReflector = groundReflector;
+      _this.opacity = _SSRShader.SSRShader.uniforms.opacity.value;
+      _this.output = 0;
+      _this.maxDistance = _SSRShader.SSRShader.uniforms.maxDistance.value;
+      _this.thickness = _SSRShader.SSRShader.uniforms.thickness.value;
+      _this.tempColor = new _three.Color();
+      _this._selects = selects;
+      _this.selective = Array.isArray(_this._selects);
+      Object.defineProperty(_assertThisInitialized(_this), 'selects', {
+        get: function get() {
+          return this._selects;
+        },
+        set: function set(val) {
+          if (this._selects === val) return;
+          this._selects = val;
+
+          if (Array.isArray(val)) {
+            this.selective = true;
+            this.ssrMaterial.defines.SELECTIVE = true;
+            this.ssrMaterial.needsUpdate = true;
+          } else {
+            this.selective = false;
+            this.ssrMaterial.defines.SELECTIVE = false;
+            this.ssrMaterial.needsUpdate = true;
+          }
+        }
+      });
+      _this._bouncing = bouncing;
+      Object.defineProperty(_assertThisInitialized(_this), 'bouncing', {
+        get: function get() {
+          return this._bouncing;
+        },
+        set: function set(val) {
+          if (this._bouncing === val) return;
+          this._bouncing = val;
+
+          if (val) {
+            this.ssrMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture;
+          } else {
+            this.ssrMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture;
+          }
+        }
+      });
+      _this.blur = true;
+      _this._distanceAttenuation = _SSRShader.SSRShader.defines.DISTANCE_ATTENUATION;
+      Object.defineProperty(_assertThisInitialized(_this), 'distanceAttenuation', {
+        get: function get() {
+          return this._distanceAttenuation;
+        },
+        set: function set(val) {
+          if (this._distanceAttenuation === val) return;
+          this._distanceAttenuation = val;
+          this.ssrMaterial.defines.DISTANCE_ATTENUATION = val;
+          this.ssrMaterial.needsUpdate = true;
+        }
+      });
+      _this._fresnel = _SSRShader.SSRShader.defines.FRESNEL;
+      Object.defineProperty(_assertThisInitialized(_this), 'fresnel', {
+        get: function get() {
+          return this._fresnel;
+        },
+        set: function set(val) {
+          if (this._fresnel === val) return;
+          this._fresnel = val;
+          this.ssrMaterial.defines.FRESNEL = val;
+          this.ssrMaterial.needsUpdate = true;
+        }
+      });
+      _this._infiniteThick = _SSRShader.SSRShader.defines.INFINITE_THICK;
+      Object.defineProperty(_assertThisInitialized(_this), 'infiniteThick', {
+        get: function get() {
+          return this._infiniteThick;
+        },
+        set: function set(val) {
+          if (this._infiniteThick === val) return;
+          this._infiniteThick = val;
+          this.ssrMaterial.defines.INFINITE_THICK = val;
+          this.ssrMaterial.needsUpdate = true;
+        }
+      }); // beauty render target with depth buffer
+
+      var depthTexture = new _three.DepthTexture();
+      depthTexture.type = _three.UnsignedShortType;
+      depthTexture.minFilter = _three.NearestFilter;
+      depthTexture.magFilter = _three.NearestFilter;
+      _this.beautyRenderTarget = new _three.WebGLRenderTarget(_this.width, _this.height, {
+        minFilter: _three.NearestFilter,
+        magFilter: _three.NearestFilter,
+        format: _three.RGBAFormat,
+        depthTexture: depthTexture,
+        depthBuffer: true
+      }); //for bouncing
+
+      _this.prevRenderTarget = new _three.WebGLRenderTarget(_this.width, _this.height, {
+        minFilter: _three.NearestFilter,
+        magFilter: _three.NearestFilter,
+        format: _three.RGBAFormat
+      }); // normal render target
+
+      _this.normalRenderTarget = new _three.WebGLRenderTarget(_this.width, _this.height, {
+        minFilter: _three.NearestFilter,
+        magFilter: _three.NearestFilter,
+        format: _three.RGBAFormat,
+        type: _three.HalfFloatType
+      }); // metalness render target
+
+      _this.metalnessRenderTarget = new _three.WebGLRenderTarget(_this.width, _this.height, {
+        minFilter: _three.NearestFilter,
+        magFilter: _three.NearestFilter,
+        format: _three.RGBAFormat
+      }); // ssr render target
+
+      _this.ssrRenderTarget = new _three.WebGLRenderTarget(_this.width, _this.height, {
+        minFilter: _three.NearestFilter,
+        magFilter: _three.NearestFilter,
+        format: _three.RGBAFormat
+      });
+      _this.blurRenderTarget = _this.ssrRenderTarget.clone();
+      _this.blurRenderTarget2 = _this.ssrRenderTarget.clone(); // this.blurRenderTarget3 = this.ssrRenderTarget.clone();
+      // ssr material
+
+      if (_SSRShader.SSRShader === undefined) {
+        console.error('THREE.SSRPass: The pass relies on SSRShader.');
+      }
+
+      _this.ssrMaterial = new _three.ShaderMaterial({
+        defines: Object.assign({}, _SSRShader.SSRShader.defines, {
+          MAX_STEP: Math.sqrt(_this.width * _this.width + _this.height * _this.height)
+        }),
+        uniforms: _three.UniformsUtils.clone(_SSRShader.SSRShader.uniforms),
+        vertexShader: _SSRShader.SSRShader.vertexShader,
+        fragmentShader: _SSRShader.SSRShader.fragmentShader,
+        blending: _three.NoBlending
+      });
+      _this.ssrMaterial.uniforms['tDiffuse'].value = _this.beautyRenderTarget.texture;
+      _this.ssrMaterial.uniforms['tNormal'].value = _this.normalRenderTarget.texture;
+      _this.ssrMaterial.defines.SELECTIVE = _this.selective;
+      _this.ssrMaterial.needsUpdate = true;
+      _this.ssrMaterial.uniforms['tMetalness'].value = _this.metalnessRenderTarget.texture;
+      _this.ssrMaterial.uniforms['tDepth'].value = _this.beautyRenderTarget.depthTexture;
+      _this.ssrMaterial.uniforms['cameraNear'].value = _this.camera.near;
+      _this.ssrMaterial.uniforms['cameraFar'].value = _this.camera.far;
+      _this.ssrMaterial.uniforms['thickness'].value = _this.thickness;
+
+      _this.ssrMaterial.uniforms['resolution'].value.set(_this.width, _this.height);
+
+      _this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(_this.camera.projectionMatrix);
+
+      _this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(_this.camera.projectionMatrixInverse); // normal material
+
+
+      _this.normalMaterial = new _three.MeshNormalMaterial();
+      _this.normalMaterial.blending = _three.NoBlending; // metalnessOn material
+
+      _this.metalnessOnMaterial = new _three.MeshBasicMaterial({
+        color: 'white'
+      }); // metalnessOff material
+
+      _this.metalnessOffMaterial = new _three.MeshBasicMaterial({
+        color: 'black'
+      }); // blur material
+
+      _this.blurMaterial = new _three.ShaderMaterial({
+        defines: Object.assign({}, _SSRShader.SSRBlurShader.defines),
+        uniforms: _three.UniformsUtils.clone(_SSRShader.SSRBlurShader.uniforms),
+        vertexShader: _SSRShader.SSRBlurShader.vertexShader,
+        fragmentShader: _SSRShader.SSRBlurShader.fragmentShader
+      });
+      _this.blurMaterial.uniforms['tDiffuse'].value = _this.ssrRenderTarget.texture;
+
+      _this.blurMaterial.uniforms['resolution'].value.set(_this.width, _this.height); // blur material 2
+
+
+      _this.blurMaterial2 = new _three.ShaderMaterial({
+        defines: Object.assign({}, _SSRShader.SSRBlurShader.defines),
+        uniforms: _three.UniformsUtils.clone(_SSRShader.SSRBlurShader.uniforms),
+        vertexShader: _SSRShader.SSRBlurShader.vertexShader,
+        fragmentShader: _SSRShader.SSRBlurShader.fragmentShader
+      });
+      _this.blurMaterial2.uniforms['tDiffuse'].value = _this.blurRenderTarget.texture;
+
+      _this.blurMaterial2.uniforms['resolution'].value.set(_this.width, _this.height); // // blur material 3
+      // this.blurMaterial3 = new ShaderMaterial({
+      //   defines: Object.assign({}, SSRBlurShader.defines),
+      //   uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+      //   vertexShader: SSRBlurShader.vertexShader,
+      //   fragmentShader: SSRBlurShader.fragmentShader
+      // });
+      // this.blurMaterial3.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;
+      // this.blurMaterial3.uniforms['resolution'].value.set(this.width, this.height);
+      // material for rendering the depth
+
+
+      _this.depthRenderMaterial = new _three.ShaderMaterial({
+        defines: Object.assign({}, _SSRShader.SSRDepthShader.defines),
+        uniforms: _three.UniformsUtils.clone(_SSRShader.SSRDepthShader.uniforms),
+        vertexShader: _SSRShader.SSRDepthShader.vertexShader,
+        fragmentShader: _SSRShader.SSRDepthShader.fragmentShader,
+        blending: _three.NoBlending
+      });
+      _this.depthRenderMaterial.uniforms['tDepth'].value = _this.beautyRenderTarget.depthTexture;
+      _this.depthRenderMaterial.uniforms['cameraNear'].value = _this.camera.near;
+      _this.depthRenderMaterial.uniforms['cameraFar'].value = _this.camera.far; // material for rendering the content of a render target
+
+      _this.copyMaterial = new _three.ShaderMaterial({
+        uniforms: _three.UniformsUtils.clone(_CopyShader.CopyShader.uniforms),
+        vertexShader: _CopyShader.CopyShader.vertexShader,
+        fragmentShader: _CopyShader.CopyShader.fragmentShader,
+        transparent: true,
+        depthTest: false,
+        depthWrite: false,
+        blendSrc: _three.SrcAlphaFactor,
+        blendDst: _three.OneMinusSrcAlphaFactor,
+        blendEquation: _three.AddEquation,
+        blendSrcAlpha: _three.SrcAlphaFactor,
+        blendDstAlpha: _three.OneMinusSrcAlphaFactor,
+        blendEquationAlpha: _three.AddEquation // premultipliedAlpha:true,
+
+      });
+      _this.fsQuad = new _Pass2.FullScreenQuad(null);
+      _this.originalClearColor = new _three.Color();
+      return _this;
+    }
+
+    _createClass(SSRPass, [{
+      key: "dispose",
+      value: function dispose() {
+        // dispose render targets
+        this.beautyRenderTarget.dispose();
+        this.prevRenderTarget.dispose();
+        this.normalRenderTarget.dispose();
+        this.metalnessRenderTarget.dispose();
+        this.ssrRenderTarget.dispose();
+        this.blurRenderTarget.dispose();
+        this.blurRenderTarget2.dispose(); // this.blurRenderTarget3.dispose();
+        // dispose materials
+
+        this.normalMaterial.dispose();
+        this.metalnessOnMaterial.dispose();
+        this.metalnessOffMaterial.dispose();
+        this.blurMaterial.dispose();
+        this.blurMaterial2.dispose();
+        this.copyMaterial.dispose();
+        this.depthRenderMaterial.dispose(); // dipsose full screen quad
+
+        this.fsQuad.dispose();
+      }
+    }, {
+      key: "render",
+      value: function render(renderer, writeBuffer
+      /*, readBuffer, deltaTime, maskActive */
+      ) {
+        // render beauty and depth
+        renderer.setRenderTarget(this.beautyRenderTarget);
+        renderer.clear();
+
+        if (this.groundReflector) {
+          this.groundReflector.visible = false;
+          this.groundReflector.doRender(this.renderer, this.scene, this.camera);
+          this.groundReflector.visible = true;
+        }
+
+        renderer.render(this.scene, this.camera);
+        if (this.groundReflector) this.groundReflector.visible = false; // render normals
+
+        this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0); // render metalnesses
+
+        if (this.selective) {
+          this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0);
+        } // render SSR
+
+
+        this.ssrMaterial.uniforms['opacity'].value = this.opacity;
+        this.ssrMaterial.uniforms['maxDistance'].value = this.maxDistance;
+        this.ssrMaterial.uniforms['thickness'].value = this.thickness;
+        this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget); // render blur
+
+        if (this.blur) {
+          this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget);
+          this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2); // this.renderPass(renderer, this.blurMaterial3, this.blurRenderTarget3);
+        } // output result to screen
+
+
+        switch (this.output) {
+          case SSRPass.OUTPUT.Default:
+            if (this.bouncing) {
+              this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture;
+              this.copyMaterial.blending = _three.NoBlending;
+              this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
+              if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture;
+              this.copyMaterial.blending = _three.NormalBlending;
+              this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
+              this.copyMaterial.uniforms['tDiffuse'].value = this.prevRenderTarget.texture;
+              this.copyMaterial.blending = _three.NoBlending;
+              this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            } else {
+              this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture;
+              this.copyMaterial.blending = _three.NoBlending;
+              this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+              if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture;
+              this.copyMaterial.blending = _three.NormalBlending;
+              this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            }
+
+            break;
+
+          case SSRPass.OUTPUT.SSR:
+            if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;else this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+
+            if (this.bouncing) {
+              if (this.blur) this.copyMaterial.uniforms['tDiffuse'].value = this.blurRenderTarget2.texture;else this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture;
+              this.copyMaterial.blending = _three.NoBlending;
+              this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
+              this.copyMaterial.uniforms['tDiffuse'].value = this.ssrRenderTarget.texture;
+              this.copyMaterial.blending = _three.NormalBlending;
+              this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
+            }
+
+            break;
+
+          case SSRPass.OUTPUT.Beauty:
+            this.copyMaterial.uniforms['tDiffuse'].value = this.beautyRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          case SSRPass.OUTPUT.Depth:
+            this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          case SSRPass.OUTPUT.Normal:
+            this.copyMaterial.uniforms['tDiffuse'].value = this.normalRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          case SSRPass.OUTPUT.Metalness:
+            this.copyMaterial.uniforms['tDiffuse'].value = this.metalnessRenderTarget.texture;
+            this.copyMaterial.blending = _three.NoBlending;
+            this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
+            break;
+
+          default:
+            console.warn('THREE.SSRPass: Unknown output type.');
+        }
+      }
+    }, {
+      key: "renderPass",
+      value: function renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+        // save original state
+        this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
+        var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+        var originalAutoClear = renderer.autoClear;
+        renderer.setRenderTarget(renderTarget); // setup pass state
+
+        renderer.autoClear = false;
+
+        if (clearColor !== undefined && clearColor !== null) {
+          renderer.setClearColor(clearColor);
+          renderer.setClearAlpha(clearAlpha || 0.0);
+          renderer.clear();
+        }
+
+        this.fsQuad.material = passMaterial;
+        this.fsQuad.render(renderer); // restore original state
+
+        renderer.autoClear = originalAutoClear;
+        renderer.setClearColor(this.originalClearColor);
+        renderer.setClearAlpha(originalClearAlpha);
+      }
+    }, {
+      key: "renderOverride",
+      value: function renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+        this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
+        var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+        var originalAutoClear = renderer.autoClear;
+        renderer.setRenderTarget(renderTarget);
+        renderer.autoClear = false;
+        clearColor = overrideMaterial.clearColor || clearColor;
+        clearAlpha = overrideMaterial.clearAlpha || clearAlpha;
+
+        if (clearColor !== undefined && clearColor !== null) {
+          renderer.setClearColor(clearColor);
+          renderer.setClearAlpha(clearAlpha || 0.0);
+          renderer.clear();
+        }
+
+        this.scene.overrideMaterial = overrideMaterial;
+        renderer.render(this.scene, this.camera);
+        this.scene.overrideMaterial = null; // restore original state
+
+        renderer.autoClear = originalAutoClear;
+        renderer.setClearColor(this.originalClearColor);
+        renderer.setClearAlpha(originalClearAlpha);
+      }
+    }, {
+      key: "renderMetalness",
+      value: function renderMetalness(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+        var _this2 = this;
+
+        this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
+        var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+        var originalAutoClear = renderer.autoClear;
+        renderer.setRenderTarget(renderTarget);
+        renderer.autoClear = false;
+        clearColor = overrideMaterial.clearColor || clearColor;
+        clearAlpha = overrideMaterial.clearAlpha || clearAlpha;
+
+        if (clearColor !== undefined && clearColor !== null) {
+          renderer.setClearColor(clearColor);
+          renderer.setClearAlpha(clearAlpha || 0.0);
+          renderer.clear();
+        }
+
+        this.scene.traverseVisible(function (child) {
+          child._SSRPassBackupMaterial = child.material;
+
+          if (_this2._selects.includes(child)) {
+            child.material = _this2.metalnessOnMaterial;
+          } else {
+            child.material = _this2.metalnessOffMaterial;
+          }
+        });
+        renderer.render(this.scene, this.camera);
+        this.scene.traverseVisible(function (child) {
+          child.material = child._SSRPassBackupMaterial;
+        }); // restore original state
+
+        renderer.autoClear = originalAutoClear;
+        renderer.setClearColor(this.originalClearColor);
+        renderer.setClearAlpha(originalClearAlpha);
+      }
+    }, {
+      key: "setSize",
+      value: function setSize(width, height) {
+        this.width = width;
+        this.height = height;
+        this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height);
+        this.ssrMaterial.needsUpdate = true;
+        this.beautyRenderTarget.setSize(width, height);
+        this.prevRenderTarget.setSize(width, height);
+        this.ssrRenderTarget.setSize(width, height);
+        this.normalRenderTarget.setSize(width, height);
+        this.metalnessRenderTarget.setSize(width, height);
+        this.blurRenderTarget.setSize(width, height);
+        this.blurRenderTarget2.setSize(width, height); // this.blurRenderTarget3.setSize(width, height);
+
+        this.ssrMaterial.uniforms['resolution'].value.set(width, height);
+        this.ssrMaterial.uniforms['cameraProjectionMatrix'].value.copy(this.camera.projectionMatrix);
+        this.ssrMaterial.uniforms['cameraInverseProjectionMatrix'].value.copy(this.camera.projectionMatrixInverse);
+        this.blurMaterial.uniforms['resolution'].value.set(width, height);
+        this.blurMaterial2.uniforms['resolution'].value.set(width, height);
+      }
+    }]);
+
+    return SSRPass;
+  }(_Pass2.Pass);
+
+  _exports.SSRPass = SSRPass;
+  SSRPass.OUTPUT = {
+    'Default': 0,
+    'SSR': 1,
+    'Beauty': 3,
+    'Depth': 4,
+    'Normal': 5,
+    'Metalness': 7
+  };
+});