three-stdlib 2.22.9 → 2.23.0

package/dist/postprocessing/SAOPass.mjs

@@ -1,142 +1,126 @@
-import { Color, Vector2, WebGLRenderTarget, LinearFilter, RGBAFormat, NearestFilter, DepthTexture, UnsignedShortType, MeshDepthMaterial, RGBADepthPacking, NoBlending, MeshNormalMaterial, ShaderMaterial, UniformsUtils, CustomBlending, DstColorFactor, ZeroFactor, AddEquation, DstAlphaFactor } 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, Vector2, WebGLRenderTarget, HalfFloatType, NearestFilter, DepthTexture, UnsignedShortType, MeshDepthMaterial, RGBADepthPacking, NoBlending, MeshNormalMaterial, ShaderMaterial, UniformsUtils, CustomBlending, DstColorFactor, ZeroFactor, AddEquation, DstAlphaFactor } from "three";
+import { Pass, FullScreenQuad } from "./Pass.mjs";
 import { SAOShader } from "../shaders/SAOShader.mjs";
 import { DepthLimitedBlurShader, BlurShaderUtils } from "../shaders/DepthLimitedBlurShader.mjs";
 import { CopyShader } from "../shaders/CopyShader.mjs";
 import { UnpackDepthRGBAShader } from "../shaders/UnpackDepthRGBAShader.mjs";
-var SAOPass = function(scene, camera, depthTexture, useNormals, resolution) {
-  this.scene = scene;
-  this.camera = camera;
-  this.clear = true;
-  this.needsSwap = false;
-  this.supportsDepthTextureExtension = depthTexture !== void 0 ? depthTexture : false;
-  this.supportsNormalTexture = useNormals !== void 0 ? useNormals : false;
-  this.originalClearColor = new Color();
-  this._oldClearColor = new Color();
-  this.oldClearAlpha = 1;
-  this.params = {
-    output: 0,
-    saoBias: 0.5,
-    saoIntensity: 0.18,
-    saoScale: 1,
-    saoKernelRadius: 100,
-    saoMinResolution: 0,
-    saoBlur: true,
-    saoBlurRadius: 8,
-    saoBlurStdDev: 4,
-    saoBlurDepthCutoff: 0.01
-  };
-  this.resolution = resolution !== void 0 ? new Vector2(resolution.x, resolution.y) : new Vector2(256, 256);
-  this.saoRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
-    minFilter: LinearFilter,
-    magFilter: LinearFilter,
-    format: RGBAFormat
-  });
-  this.blurIntermediateRenderTarget = this.saoRenderTarget.clone();
-  this.beautyRenderTarget = this.saoRenderTarget.clone();
-  this.normalRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
-    minFilter: NearestFilter,
-    magFilter: NearestFilter,
-    format: RGBAFormat
-  });
-  this.depthRenderTarget = this.normalRenderTarget.clone();
-  if (this.supportsDepthTextureExtension) {
-    var depthTexture = new DepthTexture();
-    depthTexture.type = UnsignedShortType;
-    this.beautyRenderTarget.depthTexture = depthTexture;
-    this.beautyRenderTarget.depthBuffer = true;
-  }
-  this.depthMaterial = new MeshDepthMaterial();
-  this.depthMaterial.depthPacking = RGBADepthPacking;
-  this.depthMaterial.blending = NoBlending;
-  this.normalMaterial = new MeshNormalMaterial();
-  this.normalMaterial.blending = NoBlending;
-  if (SAOShader === void 0) {
-    console.error("THREE.SAOPass relies on SAOShader");
-  }
-  this.saoMaterial = new ShaderMaterial({
-    defines: Object.assign({}, SAOShader.defines),
-    fragmentShader: SAOShader.fragmentShader,
-    vertexShader: SAOShader.vertexShader,
-    uniforms: UniformsUtils.clone(SAOShader.uniforms)
-  });
-  this.saoMaterial.extensions.derivatives = true;
-  this.saoMaterial.defines["DEPTH_PACKING"] = this.supportsDepthTextureExtension ? 0 : 1;
-  this.saoMaterial.defines["NORMAL_TEXTURE"] = this.supportsNormalTexture ? 1 : 0;
-  this.saoMaterial.defines["PERSPECTIVE_CAMERA"] = this.camera.isPerspectiveCamera ? 1 : 0;
-  this.saoMaterial.uniforms["tDepth"].value = this.supportsDepthTextureExtension ? depthTexture : this.depthRenderTarget.texture;
-  this.saoMaterial.uniforms["tNormal"].value = this.normalRenderTarget.texture;
-  this.saoMaterial.uniforms["size"].value.set(this.resolution.x, this.resolution.y);
-  this.saoMaterial.uniforms["cameraInverseProjectionMatrix"].value.copy(this.camera.projectionMatrixInverse);
-  this.saoMaterial.uniforms["cameraProjectionMatrix"].value = this.camera.projectionMatrix;
-  this.saoMaterial.blending = NoBlending;
-  if (DepthLimitedBlurShader === void 0) {
-    console.error("THREE.SAOPass relies on DepthLimitedBlurShader");
-  }
-  this.vBlurMaterial = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
-    defines: Object.assign({}, DepthLimitedBlurShader.defines),
-    vertexShader: DepthLimitedBlurShader.vertexShader,
-    fragmentShader: DepthLimitedBlurShader.fragmentShader
-  });
-  this.vBlurMaterial.defines["DEPTH_PACKING"] = this.supportsDepthTextureExtension ? 0 : 1;
-  this.vBlurMaterial.defines["PERSPECTIVE_CAMERA"] = this.camera.isPerspectiveCamera ? 1 : 0;
-  this.vBlurMaterial.uniforms["tDiffuse"].value = this.saoRenderTarget.texture;
-  this.vBlurMaterial.uniforms["tDepth"].value = this.supportsDepthTextureExtension ? depthTexture : this.depthRenderTarget.texture;
-  this.vBlurMaterial.uniforms["size"].value.set(this.resolution.x, this.resolution.y);
-  this.vBlurMaterial.blending = NoBlending;
-  this.hBlurMaterial = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
-    defines: Object.assign({}, DepthLimitedBlurShader.defines),
-    vertexShader: DepthLimitedBlurShader.vertexShader,
-    fragmentShader: DepthLimitedBlurShader.fragmentShader
-  });
-  this.hBlurMaterial.defines["DEPTH_PACKING"] = this.supportsDepthTextureExtension ? 0 : 1;
-  this.hBlurMaterial.defines["PERSPECTIVE_CAMERA"] = this.camera.isPerspectiveCamera ? 1 : 0;
-  this.hBlurMaterial.uniforms["tDiffuse"].value = this.blurIntermediateRenderTarget.texture;
-  this.hBlurMaterial.uniforms["tDepth"].value = this.supportsDepthTextureExtension ? depthTexture : this.depthRenderTarget.texture;
-  this.hBlurMaterial.uniforms["size"].value.set(this.resolution.x, this.resolution.y);
-  this.hBlurMaterial.blending = NoBlending;
-  if (CopyShader === void 0) {
-    console.error("THREE.SAOPass relies on CopyShader");
-  }
-  this.materialCopy = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(CopyShader.uniforms),
-    vertexShader: CopyShader.vertexShader,
-    fragmentShader: CopyShader.fragmentShader,
-    blending: NoBlending
-  });
-  this.materialCopy.transparent = true;
-  this.materialCopy.depthTest = false;
-  this.materialCopy.depthWrite = false;
-  this.materialCopy.blending = CustomBlending;
-  this.materialCopy.blendSrc = DstColorFactor;
-  this.materialCopy.blendDst = ZeroFactor;
-  this.materialCopy.blendEquation = AddEquation;
-  this.materialCopy.blendSrcAlpha = DstAlphaFactor;
-  this.materialCopy.blendDstAlpha = ZeroFactor;
-  this.materialCopy.blendEquationAlpha = AddEquation;
-  if (UnpackDepthRGBAShader === void 0) {
-    console.error("THREE.SAOPass relies on UnpackDepthRGBAShader");
+class SAOPass extends Pass {
+  constructor(scene, camera, useDepthTexture = false, useNormals = false, resolution = new Vector2(256, 256)) {
+    super();
+    this.scene = scene;
+    this.camera = camera;
+    this.clear = true;
+    this.needsSwap = false;
+    this.supportsDepthTextureExtension = useDepthTexture;
+    this.supportsNormalTexture = useNormals;
+    this.originalClearColor = new Color();
+    this._oldClearColor = new Color();
+    this.oldClearAlpha = 1;
+    this.params = {
+      output: 0,
+      saoBias: 0.5,
+      saoIntensity: 0.18,
+      saoScale: 1,
+      saoKernelRadius: 100,
+      saoMinResolution: 0,
+      saoBlur: true,
+      saoBlurRadius: 8,
+      saoBlurStdDev: 4,
+      saoBlurDepthCutoff: 0.01
+    };
+    this.resolution = new Vector2(resolution.x, resolution.y);
+    this.saoRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, { type: HalfFloatType });
+    this.blurIntermediateRenderTarget = this.saoRenderTarget.clone();
+    this.beautyRenderTarget = this.saoRenderTarget.clone();
+    this.normalRenderTarget = new WebGLRenderTarget(this.resolution.x, this.resolution.y, {
+      minFilter: NearestFilter,
+      magFilter: NearestFilter,
+      type: HalfFloatType
+    });
+    this.depthRenderTarget = this.normalRenderTarget.clone();
+    let depthTexture;
+    if (this.supportsDepthTextureExtension) {
+      depthTexture = new DepthTexture();
+      depthTexture.type = UnsignedShortType;
+      this.beautyRenderTarget.depthTexture = depthTexture;
+      this.beautyRenderTarget.depthBuffer = true;
+    }
+    this.depthMaterial = new MeshDepthMaterial();
+    this.depthMaterial.depthPacking = RGBADepthPacking;
+    this.depthMaterial.blending = NoBlending;
+    this.normalMaterial = new MeshNormalMaterial();
+    this.normalMaterial.blending = NoBlending;
+    this.saoMaterial = new ShaderMaterial({
+      defines: Object.assign({}, SAOShader.defines),
+      fragmentShader: SAOShader.fragmentShader,
+      vertexShader: SAOShader.vertexShader,
+      uniforms: UniformsUtils.clone(SAOShader.uniforms)
+    });
+    this.saoMaterial.extensions.derivatives = true;
+    this.saoMaterial.defines["DEPTH_PACKING"] = this.supportsDepthTextureExtension ? 0 : 1;
+    this.saoMaterial.defines["NORMAL_TEXTURE"] = this.supportsNormalTexture ? 1 : 0;
+    this.saoMaterial.defines["PERSPECTIVE_CAMERA"] = this.camera.isPerspectiveCamera ? 1 : 0;
+    this.saoMaterial.uniforms["tDepth"].value = this.supportsDepthTextureExtension ? depthTexture : this.depthRenderTarget.texture;
+    this.saoMaterial.uniforms["tNormal"].value = this.normalRenderTarget.texture;
+    this.saoMaterial.uniforms["size"].value.set(this.resolution.x, this.resolution.y);
+    this.saoMaterial.uniforms["cameraInverseProjectionMatrix"].value.copy(this.camera.projectionMatrixInverse);
+    this.saoMaterial.uniforms["cameraProjectionMatrix"].value = this.camera.projectionMatrix;
+    this.saoMaterial.blending = NoBlending;
+    this.vBlurMaterial = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
+      defines: Object.assign({}, DepthLimitedBlurShader.defines),
+      vertexShader: DepthLimitedBlurShader.vertexShader,
+      fragmentShader: DepthLimitedBlurShader.fragmentShader
+    });
+    this.vBlurMaterial.defines["DEPTH_PACKING"] = this.supportsDepthTextureExtension ? 0 : 1;
+    this.vBlurMaterial.defines["PERSPECTIVE_CAMERA"] = this.camera.isPerspectiveCamera ? 1 : 0;
+    this.vBlurMaterial.uniforms["tDiffuse"].value = this.saoRenderTarget.texture;
+    this.vBlurMaterial.uniforms["tDepth"].value = this.supportsDepthTextureExtension ? depthTexture : this.depthRenderTarget.texture;
+    this.vBlurMaterial.uniforms["size"].value.set(this.resolution.x, this.resolution.y);
+    this.vBlurMaterial.blending = NoBlending;
+    this.hBlurMaterial = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(DepthLimitedBlurShader.uniforms),
+      defines: Object.assign({}, DepthLimitedBlurShader.defines),
+      vertexShader: DepthLimitedBlurShader.vertexShader,
+      fragmentShader: DepthLimitedBlurShader.fragmentShader
+    });
+    this.hBlurMaterial.defines["DEPTH_PACKING"] = this.supportsDepthTextureExtension ? 0 : 1;
+    this.hBlurMaterial.defines["PERSPECTIVE_CAMERA"] = this.camera.isPerspectiveCamera ? 1 : 0;
+    this.hBlurMaterial.uniforms["tDiffuse"].value = this.blurIntermediateRenderTarget.texture;
+    this.hBlurMaterial.uniforms["tDepth"].value = this.supportsDepthTextureExtension ? depthTexture : this.depthRenderTarget.texture;
+    this.hBlurMaterial.uniforms["size"].value.set(this.resolution.x, this.resolution.y);
+    this.hBlurMaterial.blending = NoBlending;
+    this.materialCopy = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(CopyShader.uniforms),
+      vertexShader: CopyShader.vertexShader,
+      fragmentShader: CopyShader.fragmentShader,
+      blending: NoBlending
+    });
+    this.materialCopy.transparent = true;
+    this.materialCopy.depthTest = false;
+    this.materialCopy.depthWrite = false;
+    this.materialCopy.blending = CustomBlending;
+    this.materialCopy.blendSrc = DstColorFactor;
+    this.materialCopy.blendDst = ZeroFactor;
+    this.materialCopy.blendEquation = AddEquation;
+    this.materialCopy.blendSrcAlpha = DstAlphaFactor;
+    this.materialCopy.blendDstAlpha = ZeroFactor;
+    this.materialCopy.blendEquationAlpha = AddEquation;
+    this.depthCopy = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(UnpackDepthRGBAShader.uniforms),
+      vertexShader: UnpackDepthRGBAShader.vertexShader,
+      fragmentShader: UnpackDepthRGBAShader.fragmentShader,
+      blending: NoBlending
+    });
+    this.fsQuad = new FullScreenQuad(null);
   }
-  this.depthCopy = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(UnpackDepthRGBAShader.uniforms),
-    vertexShader: UnpackDepthRGBAShader.vertexShader,
-    fragmentShader: UnpackDepthRGBAShader.fragmentShader,
-    blending: NoBlending
-  });
-  this.fsQuad = new FullScreenQuad(null);
-};
-SAOPass.OUTPUT = {
-  Beauty: 1,
-  Default: 0,
-  SAO: 2,
-  Depth: 3,
-  Normal: 4
-};
-SAOPass.prototype = Object.assign(Object.create(Pass.prototype), {
-  constructor: SAOPass,
-  render: function(renderer, writeBuffer, readBuffer) {
+  render(renderer, writeBuffer, readBuffer) {
     if (this.renderToScreen) {
       this.materialCopy.blending = NoBlending;
       this.materialCopy.uniforms["tDiffuse"].value = readBuffer.texture;
@@ -148,7 +132,7 @@ SAOPass.prototype = Object.assign(Object.create(Pass.prototype), {
     }
     renderer.getClearColor(this._oldClearColor);
     this.oldClearAlpha = renderer.getClearAlpha();
-    var oldAutoClear = renderer.autoClear;
+    const oldAutoClear = renderer.autoClear;
     renderer.autoClear = false;
     renderer.setRenderTarget(this.depthRenderTarget);
     renderer.clear();
@@ -159,7 +143,7 @@ SAOPass.prototype = Object.assign(Object.create(Pass.prototype), {
     this.saoMaterial.uniforms["minResolution"].value = this.params.saoMinResolution;
     this.saoMaterial.uniforms["cameraNear"].value = this.camera.near;
     this.saoMaterial.uniforms["cameraFar"].value = this.camera.far;
-    var depthCutoff = this.params.saoBlurDepthCutoff * (this.camera.far - this.camera.near);
+    const depthCutoff = this.params.saoBlurDepthCutoff * (this.camera.far - this.camera.near);
     this.vBlurMaterial.uniforms["depthCutoff"].value = depthCutoff;
     this.hBlurMaterial.uniforms["depthCutoff"].value = depthCutoff;
     this.vBlurMaterial.uniforms["cameraNear"].value = this.camera.near;
@@ -198,7 +182,7 @@ SAOPass.prototype = Object.assign(Object.create(Pass.prototype), {
       this.renderPass(renderer, this.vBlurMaterial, this.blurIntermediateRenderTarget, 16777215, 1);
       this.renderPass(renderer, this.hBlurMaterial, this.saoRenderTarget, 16777215, 1);
     }
-    var outputMaterial = this.materialCopy;
+    let outputMaterial = this.materialCopy;
     if (this.params.output === 3) {
       if (this.supportsDepthTextureExtension) {
         this.materialCopy.uniforms["tDiffuse"].value = this.beautyRenderTarget.depthTexture;
@@ -223,11 +207,11 @@ SAOPass.prototype = Object.assign(Object.create(Pass.prototype), {
     this.renderPass(renderer, outputMaterial, this.renderToScreen ? null : readBuffer);
     renderer.setClearColor(this._oldClearColor, this.oldClearAlpha);
     renderer.autoClear = oldAutoClear;
-  },
-  renderPass: function(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
+  }
+  renderPass(renderer, passMaterial, renderTarget, clearColor, clearAlpha) {
     renderer.getClearColor(this.originalClearColor);
-    var originalClearAlpha = renderer.getClearAlpha();
-    var originalAutoClear = renderer.autoClear;
+    const originalClearAlpha = renderer.getClearAlpha();
+    const originalAutoClear = renderer.autoClear;
     renderer.setRenderTarget(renderTarget);
     renderer.autoClear = false;
     if (clearColor !== void 0 && clearColor !== null) {
@@ -240,11 +224,11 @@ SAOPass.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) {
     renderer.getClearColor(this.originalClearColor);
-    var originalClearAlpha = renderer.getClearAlpha();
-    var originalAutoClear = renderer.autoClear;
+    const originalClearAlpha = renderer.getClearAlpha();
+    const originalAutoClear = renderer.autoClear;
     renderer.setRenderTarget(renderTarget);
     renderer.autoClear = false;
     clearColor = overrideMaterial.clearColor || clearColor;
@@ -260,8 +244,8 @@ SAOPass.prototype = Object.assign(Object.create(Pass.prototype), {
     renderer.autoClear = originalAutoClear;
     renderer.setClearColor(this.originalClearColor);
     renderer.setClearAlpha(originalClearAlpha);
-  },
-  setSize: function(width, height) {
+  }
+  setSize(width, height) {
     this.beautyRenderTarget.setSize(width, height);
     this.saoRenderTarget.setSize(width, height);
     this.blurIntermediateRenderTarget.setSize(width, height);
@@ -276,6 +260,28 @@ SAOPass.prototype = Object.assign(Object.create(Pass.prototype), {
     this.hBlurMaterial.uniforms["size"].value.set(width, height);
     this.hBlurMaterial.needsUpdate = true;
   }
+  dispose() {
+    this.saoRenderTarget.dispose();
+    this.blurIntermediateRenderTarget.dispose();
+    this.beautyRenderTarget.dispose();
+    this.normalRenderTarget.dispose();
+    this.depthRenderTarget.dispose();
+    this.depthMaterial.dispose();
+    this.normalMaterial.dispose();
+    this.saoMaterial.dispose();
+    this.vBlurMaterial.dispose();
+    this.hBlurMaterial.dispose();
+    this.materialCopy.dispose();
+    this.depthCopy.dispose();
+    this.fsQuad.dispose();
+  }
+}
+__publicField(SAOPass, "OUTPUT", {
+  Beauty: 1,
+  Default: 0,
+  SAO: 2,
+  Depth: 3,
+  Normal: 4
 });
 export {
   SAOPass

package/dist/postprocessing/SSAARenderPass.d.ts

@@ -1,17 +1,17 @@
-import { Scene, Camera, ColorRepresentation, ShaderMaterial, WebGLRenderTarget } from 'three'
+import { Scene, Camera, Color, ShaderMaterial, WebGLRenderTarget } from 'three'
 
-import { Pass } from './Pass'
+import { Pass, FullScreenQuad } from './Pass'
 
 export class SSAARenderPass extends Pass {
-  constructor(scene: Scene, camera: Camera, clearColor?: ColorRepresentation, clearAlpha?: number)
+  constructor(scene: Scene, camera: Camera, clearColor?: Color | string | number, clearAlpha?: number)
   scene: Scene
   camera: Camera
   sampleLevel: number
   unbiased: boolean
-  clearColor: ColorRepresentation
+  clearColor: Color | string | number
   clearAlpha: number
   copyUniforms: object
   copyMaterial: ShaderMaterial
-  fsQuad: object
+  fsQuad: FullScreenQuad
   sampleRenderTarget: undefined | WebGLRenderTarget
 }

package/dist/postprocessing/SSAARenderPass.js

@@ -3,76 +3,87 @@ Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
 const Pass = require("./Pass.js");
 const CopyShader = require("../shaders/CopyShader.js");
-var SSAARenderPass = function(scene, camera, clearColor, clearAlpha) {
-  this.scene = scene;
-  this.camera = camera;
-  this.sampleLevel = 4;
-  this.unbiased = true;
-  this.clearColor = clearColor !== void 0 ? clearColor : 0;
-  this.clearAlpha = clearAlpha !== void 0 ? clearAlpha : 0;
-  this._oldClearColor = new THREE.Color();
-  if (CopyShader.CopyShader === void 0)
-    console.error("THREE.SSAARenderPass relies on CopyShader");
-  var copyShader = CopyShader.CopyShader;
-  this.copyUniforms = THREE.UniformsUtils.clone(copyShader.uniforms);
-  this.copyMaterial = new THREE.ShaderMaterial({
-    uniforms: this.copyUniforms,
-    vertexShader: copyShader.vertexShader,
-    fragmentShader: copyShader.fragmentShader,
-    premultipliedAlpha: true,
-    transparent: true,
-    blending: THREE.AdditiveBlending,
-    depthTest: false,
-    depthWrite: false
-  });
-  this.fsQuad = new Pass.FullScreenQuad(this.copyMaterial);
-};
-SSAARenderPass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
-  constructor: SSAARenderPass,
-  dispose: function() {
+class SSAARenderPass extends Pass.Pass {
+  constructor(scene, camera, clearColor, clearAlpha) {
+    super();
+    this.scene = scene;
+    this.camera = camera;
+    this.sampleLevel = 4;
+    this.unbiased = true;
+    this.clearColor = clearColor !== void 0 ? clearColor : 0;
+    this.clearAlpha = clearAlpha !== void 0 ? clearAlpha : 0;
+    this._oldClearColor = new THREE.Color();
+    const copyShader = CopyShader.CopyShader;
+    this.copyUniforms = THREE.UniformsUtils.clone(copyShader.uniforms);
+    this.copyMaterial = new THREE.ShaderMaterial({
+      uniforms: this.copyUniforms,
+      vertexShader: copyShader.vertexShader,
+      fragmentShader: copyShader.fragmentShader,
+      transparent: true,
+      depthTest: false,
+      depthWrite: false,
+      // do not use AdditiveBlending because it mixes the alpha channel instead of adding
+      blending: THREE.CustomBlending,
+      blendEquation: THREE.AddEquation,
+      blendDst: THREE.OneFactor,
+      blendDstAlpha: THREE.OneFactor,
+      blendSrc: THREE.SrcAlphaFactor,
+      blendSrcAlpha: THREE.OneFactor
+    });
+    this.fsQuad = new Pass.FullScreenQuad(this.copyMaterial);
+  }
+  dispose() {
     if (this.sampleRenderTarget) {
       this.sampleRenderTarget.dispose();
       this.sampleRenderTarget = null;
     }
-  },
-  setSize: function(width, height) {
+    this.copyMaterial.dispose();
+    this.fsQuad.dispose();
+  }
+  setSize(width, height) {
     if (this.sampleRenderTarget)
       this.sampleRenderTarget.setSize(width, height);
-  },
-  render: function(renderer, writeBuffer, readBuffer) {
+  }
+  render(renderer, writeBuffer, readBuffer) {
     if (!this.sampleRenderTarget) {
-      this.sampleRenderTarget = new THREE.WebGLRenderTarget(readBuffer.width, readBuffer.height, {
-        minFilter: THREE.LinearFilter,
-        magFilter: THREE.LinearFilter,
-        format: THREE.RGBAFormat
-      });
+      this.sampleRenderTarget = new THREE.WebGLRenderTarget(readBuffer.width, readBuffer.height, { type: THREE.HalfFloatType });
       this.sampleRenderTarget.texture.name = "SSAARenderPass.sample";
     }
-    var jitterOffsets = SSAARenderPass.JitterVectors[Math.max(0, Math.min(this.sampleLevel, 5))];
-    var autoClear = renderer.autoClear;
+    const jitterOffsets = _JitterVectors[Math.max(0, Math.min(this.sampleLevel, 5))];
+    const autoClear = renderer.autoClear;
     renderer.autoClear = false;
     renderer.getClearColor(this._oldClearColor);
-    var oldClearAlpha = renderer.getClearAlpha();
-    var baseSampleWeight = 1 / jitterOffsets.length;
-    var roundingRange = 1 / 32;
+    const oldClearAlpha = renderer.getClearAlpha();
+    const baseSampleWeight = 1 / jitterOffsets.length;
+    const roundingRange = 1 / 32;
     this.copyUniforms["tDiffuse"].value = this.sampleRenderTarget.texture;
-    var width = readBuffer.width, height = readBuffer.height;
+    const viewOffset = {
+      fullWidth: readBuffer.width,
+      fullHeight: readBuffer.height,
+      offsetX: 0,
+      offsetY: 0,
+      width: readBuffer.width,
+      height: readBuffer.height
+    };
+    const originalViewOffset = Object.assign({}, this.camera.view);
+    if (originalViewOffset.enabled)
+      Object.assign(viewOffset, originalViewOffset);
     for (let i = 0; i < jitterOffsets.length; i++) {
-      var jitterOffset = jitterOffsets[i];
+      const jitterOffset = jitterOffsets[i];
       if (this.camera.setViewOffset) {
         this.camera.setViewOffset(
-          width,
-          height,
-          jitterOffset[0] * 0.0625,
-          jitterOffset[1] * 0.0625,
+          viewOffset.fullWidth,
+          viewOffset.fullHeight,
+          viewOffset.offsetX + jitterOffset[0] * 0.0625,
+          viewOffset.offsetY + jitterOffset[1] * 0.0625,
           // 0.0625 = 1 / 16
-          width,
-          height
+          viewOffset.width,
+          viewOffset.height
         );
       }
-      var sampleWeight = baseSampleWeight;
+      let sampleWeight = baseSampleWeight;
       if (this.unbiased) {
-        var uniformCenteredDistribution = -0.5 + (i + 0.5) / jitterOffsets.length;
+        const uniformCenteredDistribution = -0.5 + (i + 0.5) / jitterOffsets.length;
         sampleWeight += roundingRange * uniformCenteredDistribution;
       }
       this.copyUniforms["opacity"].value = sampleWeight;
@@ -87,14 +98,26 @@ SSAARenderPass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
       }
       this.fsQuad.render(renderer);
     }
-    if (this.camera.clearViewOffset)
+    if (this.camera.setViewOffset && originalViewOffset.enabled) {
+      this.camera.setViewOffset(
+        originalViewOffset.fullWidth,
+        originalViewOffset.fullHeight,
+        originalViewOffset.offsetX,
+        originalViewOffset.offsetY,
+        originalViewOffset.width,
+        originalViewOffset.height
+      );
+    } else if (this.camera.clearViewOffset) {
       this.camera.clearViewOffset();
+    }
     renderer.autoClear = autoClear;
     renderer.setClearColor(this._oldClearColor, oldClearAlpha);
   }
-});
-SSAARenderPass.JitterVectors = [
-  [[0, 0]],
+}
+const _JitterVectors = [
+  [
+    [0, 0]
+  ],
   [
     [4, 4],
     [-4, -4]