three-stdlib 2.22.8 → 2.22.10

package/dist/postprocessing/SSRPass.mjs

@@ -1,231 +1,210 @@
-import { Color, DepthTexture, UnsignedShortType, NearestFilter, WebGLRenderTarget, LinearFilter, RGBAFormat, HalfFloatType, ShaderMaterial, UniformsUtils, NoBlending, MeshNormalMaterial, MeshBasicMaterial, SrcAlphaFactor, OneMinusSrcAlphaFactor, AddEquation, NormalBlending } from "three";
-import { FullScreenQuad, Pass } from "./Pass.mjs";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { Color, DepthTexture, UnsignedShortType, NearestFilter, WebGLRenderTarget, HalfFloatType, ShaderMaterial, UniformsUtils, NoBlending, MeshNormalMaterial, MeshBasicMaterial, SrcAlphaFactor, OneMinusSrcAlphaFactor, AddEquation, NormalBlending } from "three";
+import { Pass, FullScreenQuad } from "./Pass.mjs";
 import { SSRShader, SSRBlurShader, SSRDepthShader } from "../shaders/SSRShader.mjs";
 import { CopyShader } from "../shaders/CopyShader.mjs";
-var SSRPass = function({
-  renderer,
-  scene,
-  camera,
-  width,
-  height,
-  selects,
-  encoding,
-  isPerspectiveCamera = true,
-  isBouncing = false,
-  morphTargets = false,
-  groundReflector
-}) {
-  this.width = width !== void 0 ? width : 512;
-  this.height = height !== void 0 ? height : 512;
-  this.clear = true;
-  this.renderer = renderer;
-  this.scene = scene;
-  this.camera = camera;
-  this.groundReflector = groundReflector;
-  this.opacity = SSRShader.uniforms.opacity.value;
-  this.output = 0;
-  this.maxDistance = SSRShader.uniforms.maxDistance.value;
-  this.surfDist = SSRShader.uniforms.surfDist.value;
-  this.encoding = encoding;
-  this.tempColor = new Color();
-  this._selects = selects;
-  this.isSelective = Array.isArray(this._selects);
-  Object.defineProperty(this, "selects", {
-    get() {
-      return this._selects;
-    },
-    set(val) {
-      if (this._selects === val)
-        return;
-      this._selects = val;
-      if (Array.isArray(val)) {
-        this.isSelective = true;
-        this.ssrMaterial.defines.isSelective = true;
-        this.ssrMaterial.needsUpdate = true;
-      } else {
-        this.isSelective = false;
-        this.ssrMaterial.defines.isSelective = false;
+const _SSRPass = class extends Pass {
+  constructor({ renderer, scene, camera, width, height, selects, bouncing = false, groundReflector }) {
+    super();
+    this.width = width !== void 0 ? width : 512;
+    this.height = height !== void 0 ? height : 512;
+    this.clear = true;
+    this.renderer = renderer;
+    this.scene = scene;
+    this.camera = camera;
+    this.groundReflector = groundReflector;
+    this.opacity = SSRShader.uniforms.opacity.value;
+    this.output = 0;
+    this.maxDistance = SSRShader.uniforms.maxDistance.value;
+    this.thickness = SSRShader.uniforms.thickness.value;
+    this.tempColor = new Color();
+    this._selects = selects;
+    this.selective = Array.isArray(this._selects);
+    Object.defineProperty(this, "selects", {
+      get() {
+        return this._selects;
+      },
+      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(this, "bouncing", {
+      get() {
+        return this._bouncing;
+      },
+      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.defines.DISTANCE_ATTENUATION;
+    Object.defineProperty(this, "distanceAttenuation", {
+      get() {
+        return this._distanceAttenuation;
+      },
+      set(val) {
+        if (this._distanceAttenuation === val)
+          return;
+        this._distanceAttenuation = val;
+        this.ssrMaterial.defines.DISTANCE_ATTENUATION = val;
         this.ssrMaterial.needsUpdate = true;
       }
-    }
-  });
-  this._isBouncing = isBouncing;
-  Object.defineProperty(this, "isBouncing", {
-    get() {
-      return this._isBouncing;
-    },
-    set(val) {
-      if (this._isBouncing === val)
-        return;
-      this._isBouncing = val;
-      if (val) {
-        this.ssrMaterial.uniforms["tDiffuse"].value = this.prevRenderTarget.texture;
-      } else {
-        this.ssrMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
+    });
+    this._fresnel = SSRShader.defines.FRESNEL;
+    Object.defineProperty(this, "fresnel", {
+      get() {
+        return this._fresnel;
+      },
+      set(val) {
+        if (this._fresnel === val)
+          return;
+        this._fresnel = val;
+        this.ssrMaterial.defines.FRESNEL = val;
+        this.ssrMaterial.needsUpdate = true;
       }
-    }
-  });
-  this.isBlur = true;
-  this._isDistanceAttenuation = SSRShader.defines.isDistanceAttenuation;
-  Object.defineProperty(this, "isDistanceAttenuation", {
-    get() {
-      return this._isDistanceAttenuation;
-    },
-    set(val) {
-      if (this._isDistanceAttenuation === val)
-        return;
-      this._isDistanceAttenuation = val;
-      this.ssrMaterial.defines.isDistanceAttenuation = val;
-      this.ssrMaterial.needsUpdate = true;
-    }
-  });
-  this._isFresnel = SSRShader.defines.isFresnel;
-  Object.defineProperty(this, "isFresnel", {
-    get() {
-      return this._isFresnel;
-    },
-    set(val) {
-      if (this._isFresnel === val)
-        return;
-      this._isFresnel = val;
-      this.ssrMaterial.defines.isFresnel = val;
-      this.ssrMaterial.needsUpdate = true;
-    }
-  });
-  this._isInfiniteThick = SSRShader.defines.isInfiniteThick;
-  Object.defineProperty(this, "isInfiniteThick", {
-    get() {
-      return this._isInfiniteThick;
-    },
-    set(val) {
-      if (this._isInfiniteThick === val)
-        return;
-      this._isInfiniteThick = val;
-      this.ssrMaterial.defines.isInfiniteThick = val;
-      this.ssrMaterial.needsUpdate = true;
-    }
-  });
-  this.thickTolerance = SSRShader.uniforms.thickTolerance.value;
-  var depthTexture = new DepthTexture();
-  depthTexture.type = UnsignedShortType;
-  depthTexture.minFilter = NearestFilter;
-  depthTexture.maxFilter = NearestFilter;
-  this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat,
-    depthTexture,
-    depthBuffer: true
-  });
-  this.prevRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat
-  });
-  this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-    minFilter: NearestFilter,
-    magFilter: NearestFilter,
-    format: RGBAFormat,
-    type: HalfFloatType
-  });
-  this.metalnessRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-    minFilter: NearestFilter,
-    magFilter: NearestFilter,
-    format: RGBAFormat
-  });
-  this.ssrRenderTarget = new WebGLRenderTarget(this.width, this.height, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat
-  });
-  this.blurRenderTarget = this.ssrRenderTarget.clone();
-  this.blurRenderTarget2 = this.ssrRenderTarget.clone();
-  if (SSRShader === void 0) {
-    console.error("THREE.SSRPass: The pass relies on SSRShader.");
-  }
-  this.ssrMaterial = new ShaderMaterial({
-    defines: Object.assign(
-      {
-        MAX_STEP: Math.sqrt(window.innerWidth * window.innerWidth + window.innerHeight * window.innerHeight)
+    });
+    this._infiniteThick = SSRShader.defines.INFINITE_THICK;
+    Object.defineProperty(this, "infiniteThick", {
+      get() {
+        return this._infiniteThick;
       },
-      SSRShader.defines
-    ),
-    uniforms: UniformsUtils.clone(SSRShader.uniforms),
-    vertexShader: SSRShader.vertexShader,
-    fragmentShader: SSRShader.fragmentShader,
-    blending: NoBlending
-  });
-  if (!isPerspectiveCamera) {
-    this.ssrMaterial.defines.isPerspectiveCamera = isPerspectiveCamera;
+      set(val) {
+        if (this._infiniteThick === val)
+          return;
+        this._infiniteThick = val;
+        this.ssrMaterial.defines.INFINITE_THICK = val;
+        this.ssrMaterial.needsUpdate = true;
+      }
+    });
+    const depthTexture = new DepthTexture();
+    depthTexture.type = UnsignedShortType;
+    depthTexture.minFilter = NearestFilter;
+    depthTexture.magFilter = NearestFilter;
+    this.beautyRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      type: HalfFloatType,
+      depthTexture,
+      depthBuffer: true
+    });
+    this.prevRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter
+    });
+    this.normalRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      type: HalfFloatType
+    });
+    this.metalnessRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      type: HalfFloatType
+    });
+    this.ssrRenderTarget = new WebGLRenderTarget(this.width, this.height, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter
+    });
+    this.blurRenderTarget = this.ssrRenderTarget.clone();
+    this.blurRenderTarget2 = this.ssrRenderTarget.clone();
+    this.ssrMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSRShader.defines, {
+        MAX_STEP: Math.sqrt(this.width * this.width + this.height * this.height)
+      }),
+      uniforms: UniformsUtils.clone(SSRShader.uniforms),
+      vertexShader: SSRShader.vertexShader,
+      fragmentShader: SSRShader.fragmentShader,
+      blending: 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);
+    this.normalMaterial = new MeshNormalMaterial();
+    this.normalMaterial.blending = NoBlending;
+    this.metalnessOnMaterial = new MeshBasicMaterial({
+      color: "white"
+    });
+    this.metalnessOffMaterial = new MeshBasicMaterial({
+      color: "black"
+    });
+    this.blurMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSRBlurShader.defines),
+      uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+      vertexShader: SSRBlurShader.vertexShader,
+      fragmentShader: SSRBlurShader.fragmentShader
+    });
+    this.blurMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
+    this.blurMaterial.uniforms["resolution"].value.set(this.width, this.height);
+    this.blurMaterial2 = new ShaderMaterial({
+      defines: Object.assign({}, SSRBlurShader.defines),
+      uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
+      vertexShader: SSRBlurShader.vertexShader,
+      fragmentShader: SSRBlurShader.fragmentShader
+    });
+    this.blurMaterial2.uniforms["tDiffuse"].value = this.blurRenderTarget.texture;
+    this.blurMaterial2.uniforms["resolution"].value.set(this.width, this.height);
+    this.depthRenderMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SSRDepthShader.defines),
+      uniforms: UniformsUtils.clone(SSRDepthShader.uniforms),
+      vertexShader: SSRDepthShader.vertexShader,
+      fragmentShader: SSRDepthShader.fragmentShader,
+      blending: 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;
+    this.copyMaterial = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(CopyShader.uniforms),
+      vertexShader: CopyShader.vertexShader,
+      fragmentShader: CopyShader.fragmentShader,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      blendSrc: SrcAlphaFactor,
+      blendDst: OneMinusSrcAlphaFactor,
+      blendEquation: AddEquation,
+      blendSrcAlpha: SrcAlphaFactor,
+      blendDstAlpha: OneMinusSrcAlphaFactor,
+      blendEquationAlpha: AddEquation
+      // premultipliedAlpha:true,
+    });
+    this.fsQuad = new FullScreenQuad(null);
+    this.originalClearColor = new Color();
   }
-  this.ssrMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
-  this.ssrMaterial.uniforms["tNormal"].value = this.normalRenderTarget.texture;
-  this.ssrMaterial.defines.isSelective = this.isSelective;
-  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["surfDist"].value = this.surfDist;
-  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);
-  this.normalMaterial = new MeshNormalMaterial({ morphTargets });
-  this.normalMaterial.blending = NoBlending;
-  this.metalnessOnMaterial = new MeshBasicMaterial({
-    color: "white"
-  });
-  this.metalnessOffMaterial = new MeshBasicMaterial({
-    color: "black"
-  });
-  this.blurMaterial = new ShaderMaterial({
-    defines: Object.assign({}, SSRBlurShader.defines),
-    uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-    vertexShader: SSRBlurShader.vertexShader,
-    fragmentShader: SSRBlurShader.fragmentShader
-  });
-  this.blurMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
-  this.blurMaterial.uniforms["resolution"].value.set(this.width, this.height);
-  this.blurMaterial2 = new ShaderMaterial({
-    defines: Object.assign({}, SSRBlurShader.defines),
-    uniforms: UniformsUtils.clone(SSRBlurShader.uniforms),
-    vertexShader: SSRBlurShader.vertexShader,
-    fragmentShader: SSRBlurShader.fragmentShader
-  });
-  this.blurMaterial2.uniforms["tDiffuse"].value = this.blurRenderTarget.texture;
-  this.blurMaterial2.uniforms["resolution"].value.set(this.width, this.height);
-  this.depthRenderMaterial = new ShaderMaterial({
-    defines: Object.assign({}, SSRDepthShader.defines),
-    uniforms: UniformsUtils.clone(SSRDepthShader.uniforms),
-    vertexShader: SSRDepthShader.vertexShader,
-    fragmentShader: SSRDepthShader.fragmentShader,
-    blending: 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;
-  this.copyMaterial = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(CopyShader.uniforms),
-    vertexShader: CopyShader.vertexShader,
-    fragmentShader: CopyShader.fragmentShader,
-    transparent: true,
-    depthTest: false,
-    depthWrite: false,
-    blendSrc: SrcAlphaFactor,
-    blendDst: OneMinusSrcAlphaFactor,
-    blendEquation: AddEquation,
-    blendSrcAlpha: SrcAlphaFactor,
-    blendDstAlpha: OneMinusSrcAlphaFactor,
-    blendEquationAlpha: AddEquation
-    // premultipliedAlpha:true,
-  });
-  this.fsQuad = new FullScreenQuad(null);
-  this.originalClearColor = new Color();
-};
-SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
-  constructor: SSRPass,
-  dispose: function() {
+  dispose() {
     this.beautyRenderTarget.dispose();
     this.prevRenderTarget.dispose();
     this.normalRenderTarget.dispose();
@@ -241,18 +220,12 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
     this.copyMaterial.dispose();
     this.depthRenderMaterial.dispose();
     this.fsQuad.dispose();
-  },
-  render: function(renderer, writeBuffer) {
-    if (this.encoding) {
-      if ("colorSpace" in this.beautyRenderTarget.texture) {
-        this.beautyRenderTarget.texture.colorSpace = this.encoding === 3001 ? "srgb" : "srgb-linear";
-      } else {
-        this.beautyRenderTarget.texture.encoding = this.encoding;
-      }
-    }
+  }
+  render(renderer, writeBuffer) {
     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;
     }
@@ -260,25 +233,24 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
     if (this.groundReflector)
       this.groundReflector.visible = false;
     this.renderOverride(renderer, this.normalMaterial, this.normalRenderTarget, 0, 0);
-    if (this.isSelective) {
+    if (this.selective) {
       this.renderMetalness(renderer, this.metalnessOnMaterial, this.metalnessRenderTarget, 0, 0);
     }
     this.ssrMaterial.uniforms["opacity"].value = this.opacity;
     this.ssrMaterial.uniforms["maxDistance"].value = this.maxDistance;
-    this.ssrMaterial.uniforms["surfDist"].value = this.surfDist;
-    this.ssrMaterial.uniforms["thickTolerance"].value = this.thickTolerance;
+    this.ssrMaterial.uniforms["thickness"].value = this.thickness;
     this.renderPass(renderer, this.ssrMaterial, this.ssrRenderTarget);
-    if (this.isBlur) {
+    if (this.blur) {
       this.renderPass(renderer, this.blurMaterial, this.blurRenderTarget);
       this.renderPass(renderer, this.blurMaterial2, this.blurRenderTarget2);
     }
     switch (this.output) {
-      case SSRPass.OUTPUT.Default:
-        if (this.isBouncing) {
+      case _SSRPass.OUTPUT.Default:
+        if (this.bouncing) {
           this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
           this.copyMaterial.blending = NoBlending;
           this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
-          if (this.isBlur)
+          if (this.blur)
             this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget2.texture;
           else
             this.copyMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
@@ -291,7 +263,7 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
           this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
           this.copyMaterial.blending = NoBlending;
           this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
-          if (this.isBlur)
+          if (this.blur)
             this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget2.texture;
           else
             this.copyMaterial.uniforms["tDiffuse"].value = this.ssrRenderTarget.texture;
@@ -299,15 +271,15 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
           this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
         }
         break;
-      case SSRPass.OUTPUT.SSR:
-        if (this.isBlur)
+      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 = NoBlending;
         this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
-        if (this.isBouncing) {
-          if (this.isBlur)
+        if (this.bouncing) {
+          if (this.blur)
             this.copyMaterial.uniforms["tDiffuse"].value = this.blurRenderTarget2.texture;
           else
             this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
@@ -318,20 +290,20 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
           this.renderPass(renderer, this.copyMaterial, this.prevRenderTarget);
         }
         break;
-      case SSRPass.OUTPUT.Beauty:
+      case _SSRPass.OUTPUT.Beauty:
         this.copyMaterial.uniforms["tDiffuse"].value = this.beautyRenderTarget.texture;
         this.copyMaterial.blending = NoBlending;
         this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
         break;
-      case SSRPass.OUTPUT.Depth:
+      case _SSRPass.OUTPUT.Depth:
         this.renderPass(renderer, this.depthRenderMaterial, this.renderToScreen ? null : writeBuffer);
         break;
-      case SSRPass.OUTPUT.Normal:
+      case _SSRPass.OUTPUT.Normal:
         this.copyMaterial.uniforms["tDiffuse"].value = this.normalRenderTarget.texture;
         this.copyMaterial.blending = NoBlending;
         this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
         break;
-      case SSRPass.OUTPUT.Metalness:
+      case _SSRPass.OUTPUT.Metalness:
         this.copyMaterial.uniforms["tDiffuse"].value = this.metalnessRenderTarget.texture;
         this.copyMaterial.blending = NoBlending;
         this.renderPass(renderer, this.copyMaterial, this.renderToScreen ? null : writeBuffer);
@@ -339,11 +311,11 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
       default:
         console.warn("THREE.SSRPass: Unknown output type.");
     }
-  },
-  renderPass: function(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+  }
+  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
     this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
-    var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
-    var originalAutoClear = renderer.autoClear;
+    const originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+    const originalAutoClear = renderer.autoClear;
     renderer.setRenderTarget(renderTarget);
     renderer.autoClear = false;
     if (clearColor !== void 0 && clearColor !== null) {
@@ -356,11 +328,11 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
     renderer.autoClear = originalAutoClear;
     renderer.setClearColor(this.originalClearColor);
     renderer.setClearAlpha(originalClearAlpha);
-  },
-  renderOverride: function(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+  }
+  renderOverride(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
     this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
-    var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
-    var originalAutoClear = renderer.autoClear;
+    const originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+    const originalAutoClear = renderer.autoClear;
     renderer.setRenderTarget(renderTarget);
     renderer.autoClear = false;
     clearColor = overrideMaterial.clearColor || clearColor;
@@ -376,11 +348,11 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
     renderer.autoClear = originalAutoClear;
     renderer.setClearColor(this.originalClearColor);
     renderer.setClearAlpha(originalClearAlpha);
-  },
-  renderMetalness: function(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
+  }
+  renderMetalness(renderer, overrideMaterial, renderTarget, clearColor, clearAlpha) {
     this.originalClearColor.copy(renderer.getClearColor(this.tempColor));
-    var originalClearAlpha = renderer.getClearAlpha(this.tempColor);
-    var originalAutoClear = renderer.autoClear;
+    const originalClearAlpha = renderer.getClearAlpha(this.tempColor);
+    const originalAutoClear = renderer.autoClear;
     renderer.setRenderTarget(renderTarget);
     renderer.autoClear = false;
     clearColor = overrideMaterial.clearColor || clearColor;
@@ -391,7 +363,7 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
       renderer.clear();
     }
     this.scene.traverseVisible((child) => {
-      child._SSRPassMaterialBack = child.material;
+      child._SSRPassBackupMaterial = child.material;
       if (this._selects.includes(child)) {
         child.material = this.metalnessOnMaterial;
       } else {
@@ -400,13 +372,13 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
     });
     renderer.render(this.scene, this.camera);
     this.scene.traverseVisible((child) => {
-      child.material = child._SSRPassMaterialBack;
+      child.material = child._SSRPassBackupMaterial;
     });
     renderer.autoClear = originalAutoClear;
     renderer.setClearColor(this.originalClearColor);
     renderer.setClearAlpha(originalClearAlpha);
-  },
-  setSize: function(width, height) {
+  }
+  setSize(width, height) {
     this.width = width;
     this.height = height;
     this.ssrMaterial.defines.MAX_STEP = Math.sqrt(width * width + height * height);
@@ -424,15 +396,16 @@ SSRPass.prototype = Object.assign(Object.create(Pass.prototype), {
     this.blurMaterial.uniforms["resolution"].value.set(width, height);
     this.blurMaterial2.uniforms["resolution"].value.set(width, height);
   }
-});
-SSRPass.OUTPUT = {
+};
+let SSRPass = _SSRPass;
+__publicField(SSRPass, "OUTPUT", {
   Default: 0,
   SSR: 1,
   Beauty: 3,
   Depth: 4,
   Normal: 5,
   Metalness: 7
-};
+});
 export {
   SSRPass
 };

package/dist/postprocessing/TAARenderPass.d.ts

@@ -1,8 +1,8 @@
-import { Scene, Camera, ColorRepresentation } from 'three'
+import { Scene, Camera, Color } from 'three'
 
 import { SSAARenderPass } from './SSAARenderPass'
 
 export class TAARenderPass extends SSAARenderPass {
-  constructor(scene: Scene, camera: Camera, clearColor: ColorRepresentation, clearAlpha: number)
+  constructor(scene: Scene, camera: Camera, clearColor: Color | string | number, clearAlpha: number)
   accumulate: boolean
 }