three-stdlib 2.22.9 → 2.23.0

package/dist/postprocessing/AdaptiveToneMappingPass.js

@@ -5,92 +5,91 @@ const Pass = require("./Pass.js");
 const CopyShader = require("../shaders/CopyShader.js");
 const LuminosityShader = require("../shaders/LuminosityShader.js");
 const ToneMapShader = require("../shaders/ToneMapShader.js");
-var AdaptiveToneMappingPass = function(adaptive, resolution) {
-  this.resolution = resolution !== void 0 ? resolution : 256;
-  this.needsInit = true;
-  this.adaptive = adaptive !== void 0 ? !!adaptive : true;
-  this.luminanceRT = null;
-  this.previousLuminanceRT = null;
-  this.currentLuminanceRT = null;
-  if (CopyShader.CopyShader === void 0)
-    console.error("THREE.AdaptiveToneMappingPass relies on CopyShader");
-  var copyShader = CopyShader.CopyShader;
-  this.copyUniforms = THREE.UniformsUtils.clone(copyShader.uniforms);
-  this.materialCopy = new THREE.ShaderMaterial({
-    uniforms: this.copyUniforms,
-    vertexShader: copyShader.vertexShader,
-    fragmentShader: copyShader.fragmentShader,
-    blending: THREE.NoBlending,
-    depthTest: false
-  });
-  if (LuminosityShader.LuminosityShader === void 0)
-    console.error("THREE.AdaptiveToneMappingPass relies on LuminosityShader");
-  this.materialLuminance = new THREE.ShaderMaterial({
-    uniforms: THREE.UniformsUtils.clone(LuminosityShader.LuminosityShader.uniforms),
-    vertexShader: LuminosityShader.LuminosityShader.vertexShader,
-    fragmentShader: LuminosityShader.LuminosityShader.fragmentShader,
-    blending: THREE.NoBlending
-  });
-  this.adaptLuminanceShader = {
-    defines: {
-      MIP_LEVEL_1X1: (Math.log(this.resolution) / Math.log(2)).toFixed(1)
-    },
-    uniforms: {
-      lastLum: { value: null },
-      currentLum: { value: null },
-      minLuminance: { value: 0.01 },
-      delta: { value: 0.016 },
-      tau: { value: 1 }
-    },
-    vertexShader: [
-      "varying vec2 vUv;",
-      "void main() {",
-      "	vUv = uv;",
-      "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-      "}"
-    ].join("\n"),
-    fragmentShader: [
-      "varying vec2 vUv;",
-      "uniform sampler2D lastLum;",
-      "uniform sampler2D currentLum;",
-      "uniform float minLuminance;",
-      "uniform float delta;",
-      "uniform float tau;",
-      "void main() {",
-      "	vec4 lastLum = texture2D( lastLum, vUv, MIP_LEVEL_1X1 );",
-      "	vec4 currentLum = texture2D( currentLum, vUv, MIP_LEVEL_1X1 );",
-      "	float fLastLum = max( minLuminance, lastLum.r );",
-      "	float fCurrentLum = max( minLuminance, currentLum.r );",
-      //The adaption seems to work better in extreme lighting differences
-      //if the input luminance is squared.
-      "	fCurrentLum *= fCurrentLum;",
-      // Adapt the luminance using Pattanaik's technique
-      "	float fAdaptedLum = fLastLum + (fCurrentLum - fLastLum) * (1.0 - exp(-delta * tau));",
-      // "fAdaptedLum = sqrt(fAdaptedLum);",
-      "	gl_FragColor.r = fAdaptedLum;",
-      "}"
-    ].join("\n")
-  };
-  this.materialAdaptiveLum = new THREE.ShaderMaterial({
-    uniforms: THREE.UniformsUtils.clone(this.adaptLuminanceShader.uniforms),
-    vertexShader: this.adaptLuminanceShader.vertexShader,
-    fragmentShader: this.adaptLuminanceShader.fragmentShader,
-    defines: Object.assign({}, this.adaptLuminanceShader.defines),
-    blending: THREE.NoBlending
-  });
-  if (ToneMapShader.ToneMapShader === void 0)
-    console.error("THREE.AdaptiveToneMappingPass relies on ToneMapShader");
-  this.materialToneMap = new THREE.ShaderMaterial({
-    uniforms: THREE.UniformsUtils.clone(ToneMapShader.ToneMapShader.uniforms),
-    vertexShader: ToneMapShader.ToneMapShader.vertexShader,
-    fragmentShader: ToneMapShader.ToneMapShader.fragmentShader,
-    blending: THREE.NoBlending
-  });
-  this.fsQuad = new Pass.FullScreenQuad(null);
-};
-AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
-  constructor: AdaptiveToneMappingPass,
-  render: function(renderer, writeBuffer, readBuffer, deltaTime) {
+class AdaptiveToneMappingPass extends Pass.Pass {
+  constructor(adaptive, resolution) {
+    super();
+    this.resolution = resolution !== void 0 ? resolution : 256;
+    this.needsInit = true;
+    this.adaptive = adaptive !== void 0 ? !!adaptive : true;
+    this.luminanceRT = null;
+    this.previousLuminanceRT = null;
+    this.currentLuminanceRT = null;
+    const copyShader = CopyShader.CopyShader;
+    this.copyUniforms = THREE.UniformsUtils.clone(copyShader.uniforms);
+    this.materialCopy = new THREE.ShaderMaterial({
+      uniforms: this.copyUniforms,
+      vertexShader: copyShader.vertexShader,
+      fragmentShader: copyShader.fragmentShader,
+      blending: THREE.NoBlending,
+      depthTest: false
+    });
+    this.materialLuminance = new THREE.ShaderMaterial({
+      uniforms: THREE.UniformsUtils.clone(LuminosityShader.LuminosityShader.uniforms),
+      vertexShader: LuminosityShader.LuminosityShader.vertexShader,
+      fragmentShader: LuminosityShader.LuminosityShader.fragmentShader,
+      blending: THREE.NoBlending
+    });
+    this.adaptLuminanceShader = {
+      defines: {
+        MIP_LEVEL_1X1: (Math.log(this.resolution) / Math.log(2)).toFixed(1)
+      },
+      uniforms: {
+        lastLum: { value: null },
+        currentLum: { value: null },
+        minLuminance: { value: 0.01 },
+        delta: { value: 0.016 },
+        tau: { value: 1 }
+      },
+      vertexShader: `varying vec2 vUv;
+
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}`,
+      fragmentShader: `varying vec2 vUv;
+
+				uniform sampler2D lastLum;
+				uniform sampler2D currentLum;
+				uniform float minLuminance;
+				uniform float delta;
+				uniform float tau;
+
+				void main() {
+
+					vec4 lastLum = texture2D( lastLum, vUv, MIP_LEVEL_1X1 );
+					vec4 currentLum = texture2D( currentLum, vUv, MIP_LEVEL_1X1 );
+
+					float fLastLum = max( minLuminance, lastLum.r );
+					float fCurrentLum = max( minLuminance, currentLum.r );
+
+					//The adaption seems to work better in extreme lighting differences
+					//if the input luminance is squared.
+					fCurrentLum *= fCurrentLum;
+
+					// Adapt the luminance using Pattanaik's technique
+					float fAdaptedLum = fLastLum + (fCurrentLum - fLastLum) * (1.0 - exp(-delta * tau));
+					// "fAdaptedLum = sqrt(fAdaptedLum);
+					gl_FragColor.r = fAdaptedLum;
+				}`
+    };
+    this.materialAdaptiveLum = new THREE.ShaderMaterial({
+      uniforms: THREE.UniformsUtils.clone(this.adaptLuminanceShader.uniforms),
+      vertexShader: this.adaptLuminanceShader.vertexShader,
+      fragmentShader: this.adaptLuminanceShader.fragmentShader,
+      defines: Object.assign({}, this.adaptLuminanceShader.defines),
+      blending: THREE.NoBlending
+    });
+    this.materialToneMap = new THREE.ShaderMaterial({
+      uniforms: THREE.UniformsUtils.clone(ToneMapShader.ToneMapShader.uniforms),
+      vertexShader: ToneMapShader.ToneMapShader.vertexShader,
+      fragmentShader: ToneMapShader.ToneMapShader.fragmentShader,
+      blending: THREE.NoBlending
+    });
+    this.fsQuad = new Pass.FullScreenQuad(null);
+  }
+  render(renderer, writeBuffer, readBuffer, deltaTime) {
     if (this.needsInit) {
       this.reset(renderer);
       this.luminanceRT.texture.type = readBuffer.texture.type;
@@ -125,8 +124,8 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.protot
         renderer.clear();
       this.fsQuad.render(renderer);
     }
-  },
-  reset: function() {
+  }
+  reset() {
     if (this.luminanceRT) {
       this.luminanceRT.dispose();
     }
@@ -136,19 +135,13 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.protot
     if (this.previousLuminanceRT) {
       this.previousLuminanceRT.dispose();
     }
-    var pars = {
-      minFilter: THREE.LinearFilter,
-      magFilter: THREE.LinearFilter,
-      format: THREE.RGBAFormat
-    };
-    this.luminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.luminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution);
     this.luminanceRT.texture.name = "AdaptiveToneMappingPass.l";
     this.luminanceRT.texture.generateMipmaps = false;
-    this.previousLuminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.previousLuminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution);
     this.previousLuminanceRT.texture.name = "AdaptiveToneMappingPass.pl";
     this.previousLuminanceRT.texture.generateMipmaps = false;
-    pars.minFilter = THREE.LinearMipmapLinearFilter;
-    pars.generateMipmaps = true;
+    const pars = { minFilter: THREE.LinearMipmapLinearFilter, generateMipmaps: true };
     this.currentLuminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution, pars);
     this.currentLuminanceRT.texture.name = "AdaptiveToneMappingPass.cl";
     if (this.adaptive) {
@@ -159,8 +152,8 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.protot
     this.materialLuminance.needsUpdate = true;
     this.materialAdaptiveLum.needsUpdate = true;
     this.materialToneMap.needsUpdate = true;
-  },
-  setAdaptive: function(adaptive) {
+  }
+  setAdaptive(adaptive) {
     if (adaptive) {
       this.adaptive = true;
       this.materialToneMap.defines["ADAPTED_LUMINANCE"] = "";
@@ -171,34 +164,34 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.protot
       this.materialToneMap.uniforms.luminanceMap.value = null;
     }
     this.materialToneMap.needsUpdate = true;
-  },
-  setAdaptionRate: function(rate) {
+  }
+  setAdaptionRate(rate) {
     if (rate) {
       this.materialAdaptiveLum.uniforms.tau.value = Math.abs(rate);
     }
-  },
-  setMinLuminance: function(minLum) {
+  }
+  setMinLuminance(minLum) {
     if (minLum) {
       this.materialToneMap.uniforms.minLuminance.value = minLum;
       this.materialAdaptiveLum.uniforms.minLuminance.value = minLum;
     }
-  },
-  setMaxLuminance: function(maxLum) {
+  }
+  setMaxLuminance(maxLum) {
     if (maxLum) {
       this.materialToneMap.uniforms.maxLuminance.value = maxLum;
     }
-  },
-  setAverageLuminance: function(avgLum) {
+  }
+  setAverageLuminance(avgLum) {
     if (avgLum) {
       this.materialToneMap.uniforms.averageLuminance.value = avgLum;
     }
-  },
-  setMiddleGrey: function(middleGrey) {
+  }
+  setMiddleGrey(middleGrey) {
     if (middleGrey) {
       this.materialToneMap.uniforms.middleGrey.value = middleGrey;
     }
-  },
-  dispose: function() {
+  }
+  dispose() {
     if (this.luminanceRT) {
       this.luminanceRT.dispose();
     }
@@ -221,5 +214,5 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.protot
       this.materialToneMap.dispose();
     }
   }
-});
+}
 exports.AdaptiveToneMappingPass = AdaptiveToneMappingPass;

package/dist/postprocessing/AdaptiveToneMappingPass.mjs

@@ -1,94 +1,93 @@
-import { UniformsUtils, ShaderMaterial, NoBlending, LinearFilter, RGBAFormat, WebGLRenderTarget, LinearMipmapLinearFilter, MeshBasicMaterial } from "three";
-import { FullScreenQuad, Pass } from "./Pass.mjs";
+import { UniformsUtils, ShaderMaterial, NoBlending, WebGLRenderTarget, LinearMipmapLinearFilter, MeshBasicMaterial } from "three";
+import { Pass, FullScreenQuad } from "./Pass.mjs";
 import { CopyShader } from "../shaders/CopyShader.mjs";
 import { LuminosityShader } from "../shaders/LuminosityShader.mjs";
 import { ToneMapShader } from "../shaders/ToneMapShader.mjs";
-var AdaptiveToneMappingPass = function(adaptive, resolution) {
-  this.resolution = resolution !== void 0 ? resolution : 256;
-  this.needsInit = true;
-  this.adaptive = adaptive !== void 0 ? !!adaptive : true;
-  this.luminanceRT = null;
-  this.previousLuminanceRT = null;
-  this.currentLuminanceRT = null;
-  if (CopyShader === void 0)
-    console.error("THREE.AdaptiveToneMappingPass relies on CopyShader");
-  var copyShader = CopyShader;
-  this.copyUniforms = UniformsUtils.clone(copyShader.uniforms);
-  this.materialCopy = new ShaderMaterial({
-    uniforms: this.copyUniforms,
-    vertexShader: copyShader.vertexShader,
-    fragmentShader: copyShader.fragmentShader,
-    blending: NoBlending,
-    depthTest: false
-  });
-  if (LuminosityShader === void 0)
-    console.error("THREE.AdaptiveToneMappingPass relies on LuminosityShader");
-  this.materialLuminance = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(LuminosityShader.uniforms),
-    vertexShader: LuminosityShader.vertexShader,
-    fragmentShader: LuminosityShader.fragmentShader,
-    blending: NoBlending
-  });
-  this.adaptLuminanceShader = {
-    defines: {
-      MIP_LEVEL_1X1: (Math.log(this.resolution) / Math.log(2)).toFixed(1)
-    },
-    uniforms: {
-      lastLum: { value: null },
-      currentLum: { value: null },
-      minLuminance: { value: 0.01 },
-      delta: { value: 0.016 },
-      tau: { value: 1 }
-    },
-    vertexShader: [
-      "varying vec2 vUv;",
-      "void main() {",
-      "	vUv = uv;",
-      "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-      "}"
-    ].join("\n"),
-    fragmentShader: [
-      "varying vec2 vUv;",
-      "uniform sampler2D lastLum;",
-      "uniform sampler2D currentLum;",
-      "uniform float minLuminance;",
-      "uniform float delta;",
-      "uniform float tau;",
-      "void main() {",
-      "	vec4 lastLum = texture2D( lastLum, vUv, MIP_LEVEL_1X1 );",
-      "	vec4 currentLum = texture2D( currentLum, vUv, MIP_LEVEL_1X1 );",
-      "	float fLastLum = max( minLuminance, lastLum.r );",
-      "	float fCurrentLum = max( minLuminance, currentLum.r );",
-      //The adaption seems to work better in extreme lighting differences
-      //if the input luminance is squared.
-      "	fCurrentLum *= fCurrentLum;",
-      // Adapt the luminance using Pattanaik's technique
-      "	float fAdaptedLum = fLastLum + (fCurrentLum - fLastLum) * (1.0 - exp(-delta * tau));",
-      // "fAdaptedLum = sqrt(fAdaptedLum);",
-      "	gl_FragColor.r = fAdaptedLum;",
-      "}"
-    ].join("\n")
-  };
-  this.materialAdaptiveLum = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(this.adaptLuminanceShader.uniforms),
-    vertexShader: this.adaptLuminanceShader.vertexShader,
-    fragmentShader: this.adaptLuminanceShader.fragmentShader,
-    defines: Object.assign({}, this.adaptLuminanceShader.defines),
-    blending: NoBlending
-  });
-  if (ToneMapShader === void 0)
-    console.error("THREE.AdaptiveToneMappingPass relies on ToneMapShader");
-  this.materialToneMap = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(ToneMapShader.uniforms),
-    vertexShader: ToneMapShader.vertexShader,
-    fragmentShader: ToneMapShader.fragmentShader,
-    blending: NoBlending
-  });
-  this.fsQuad = new FullScreenQuad(null);
-};
-AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype), {
-  constructor: AdaptiveToneMappingPass,
-  render: function(renderer, writeBuffer, readBuffer, deltaTime) {
+class AdaptiveToneMappingPass extends Pass {
+  constructor(adaptive, resolution) {
+    super();
+    this.resolution = resolution !== void 0 ? resolution : 256;
+    this.needsInit = true;
+    this.adaptive = adaptive !== void 0 ? !!adaptive : true;
+    this.luminanceRT = null;
+    this.previousLuminanceRT = null;
+    this.currentLuminanceRT = null;
+    const copyShader = CopyShader;
+    this.copyUniforms = UniformsUtils.clone(copyShader.uniforms);
+    this.materialCopy = new ShaderMaterial({
+      uniforms: this.copyUniforms,
+      vertexShader: copyShader.vertexShader,
+      fragmentShader: copyShader.fragmentShader,
+      blending: NoBlending,
+      depthTest: false
+    });
+    this.materialLuminance = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(LuminosityShader.uniforms),
+      vertexShader: LuminosityShader.vertexShader,
+      fragmentShader: LuminosityShader.fragmentShader,
+      blending: NoBlending
+    });
+    this.adaptLuminanceShader = {
+      defines: {
+        MIP_LEVEL_1X1: (Math.log(this.resolution) / Math.log(2)).toFixed(1)
+      },
+      uniforms: {
+        lastLum: { value: null },
+        currentLum: { value: null },
+        minLuminance: { value: 0.01 },
+        delta: { value: 0.016 },
+        tau: { value: 1 }
+      },
+      vertexShader: `varying vec2 vUv;
+
+				void main() {
+
+					vUv = uv;
+					gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+
+				}`,
+      fragmentShader: `varying vec2 vUv;
+
+				uniform sampler2D lastLum;
+				uniform sampler2D currentLum;
+				uniform float minLuminance;
+				uniform float delta;
+				uniform float tau;
+
+				void main() {
+
+					vec4 lastLum = texture2D( lastLum, vUv, MIP_LEVEL_1X1 );
+					vec4 currentLum = texture2D( currentLum, vUv, MIP_LEVEL_1X1 );
+
+					float fLastLum = max( minLuminance, lastLum.r );
+					float fCurrentLum = max( minLuminance, currentLum.r );
+
+					//The adaption seems to work better in extreme lighting differences
+					//if the input luminance is squared.
+					fCurrentLum *= fCurrentLum;
+
+					// Adapt the luminance using Pattanaik's technique
+					float fAdaptedLum = fLastLum + (fCurrentLum - fLastLum) * (1.0 - exp(-delta * tau));
+					// "fAdaptedLum = sqrt(fAdaptedLum);
+					gl_FragColor.r = fAdaptedLum;
+				}`
+    };
+    this.materialAdaptiveLum = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(this.adaptLuminanceShader.uniforms),
+      vertexShader: this.adaptLuminanceShader.vertexShader,
+      fragmentShader: this.adaptLuminanceShader.fragmentShader,
+      defines: Object.assign({}, this.adaptLuminanceShader.defines),
+      blending: NoBlending
+    });
+    this.materialToneMap = new ShaderMaterial({
+      uniforms: UniformsUtils.clone(ToneMapShader.uniforms),
+      vertexShader: ToneMapShader.vertexShader,
+      fragmentShader: ToneMapShader.fragmentShader,
+      blending: NoBlending
+    });
+    this.fsQuad = new FullScreenQuad(null);
+  }
+  render(renderer, writeBuffer, readBuffer, deltaTime) {
     if (this.needsInit) {
       this.reset(renderer);
       this.luminanceRT.texture.type = readBuffer.texture.type;
@@ -123,8 +122,8 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype),
         renderer.clear();
       this.fsQuad.render(renderer);
     }
-  },
-  reset: function() {
+  }
+  reset() {
     if (this.luminanceRT) {
       this.luminanceRT.dispose();
     }
@@ -134,19 +133,13 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype),
     if (this.previousLuminanceRT) {
       this.previousLuminanceRT.dispose();
     }
-    var pars = {
-      minFilter: LinearFilter,
-      magFilter: LinearFilter,
-      format: RGBAFormat
-    };
-    this.luminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.luminanceRT = new WebGLRenderTarget(this.resolution, this.resolution);
     this.luminanceRT.texture.name = "AdaptiveToneMappingPass.l";
     this.luminanceRT.texture.generateMipmaps = false;
-    this.previousLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.previousLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution);
     this.previousLuminanceRT.texture.name = "AdaptiveToneMappingPass.pl";
     this.previousLuminanceRT.texture.generateMipmaps = false;
-    pars.minFilter = LinearMipmapLinearFilter;
-    pars.generateMipmaps = true;
+    const pars = { minFilter: LinearMipmapLinearFilter, generateMipmaps: true };
     this.currentLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
     this.currentLuminanceRT.texture.name = "AdaptiveToneMappingPass.cl";
     if (this.adaptive) {
@@ -157,8 +150,8 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype),
     this.materialLuminance.needsUpdate = true;
     this.materialAdaptiveLum.needsUpdate = true;
     this.materialToneMap.needsUpdate = true;
-  },
-  setAdaptive: function(adaptive) {
+  }
+  setAdaptive(adaptive) {
     if (adaptive) {
       this.adaptive = true;
       this.materialToneMap.defines["ADAPTED_LUMINANCE"] = "";
@@ -169,34 +162,34 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype),
       this.materialToneMap.uniforms.luminanceMap.value = null;
     }
     this.materialToneMap.needsUpdate = true;
-  },
-  setAdaptionRate: function(rate) {
+  }
+  setAdaptionRate(rate) {
     if (rate) {
       this.materialAdaptiveLum.uniforms.tau.value = Math.abs(rate);
     }
-  },
-  setMinLuminance: function(minLum) {
+  }
+  setMinLuminance(minLum) {
     if (minLum) {
       this.materialToneMap.uniforms.minLuminance.value = minLum;
       this.materialAdaptiveLum.uniforms.minLuminance.value = minLum;
     }
-  },
-  setMaxLuminance: function(maxLum) {
+  }
+  setMaxLuminance(maxLum) {
     if (maxLum) {
       this.materialToneMap.uniforms.maxLuminance.value = maxLum;
     }
-  },
-  setAverageLuminance: function(avgLum) {
+  }
+  setAverageLuminance(avgLum) {
     if (avgLum) {
       this.materialToneMap.uniforms.averageLuminance.value = avgLum;
     }
-  },
-  setMiddleGrey: function(middleGrey) {
+  }
+  setMiddleGrey(middleGrey) {
     if (middleGrey) {
       this.materialToneMap.uniforms.middleGrey.value = middleGrey;
     }
-  },
-  dispose: function() {
+  }
+  dispose() {
     if (this.luminanceRT) {
       this.luminanceRT.dispose();
     }
@@ -219,7 +212,7 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype),
       this.materialToneMap.dispose();
     }
   }
-});
+}
 export {
   AdaptiveToneMappingPass
 };

package/dist/postprocessing/BokehPass.d.ts

@@ -3,7 +3,7 @@
  */
 import { Pass, FullScreenQuad } from './Pass';
 import { MeshDepthMaterial, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
-declare type BokehPassParams = {
+type BokehPassParams = {
     focus?: number;
     aspect?: number;
     aperture?: number;

package/dist/postprocessing/ClearPass.d.ts

@@ -1,10 +1,10 @@
 import { Pass } from './Pass';
-import { ColorRepresentation, WebGLRenderer, WebGLRenderTarget } from 'three';
+import { Color, WebGLRenderer, WebGLRenderTarget } from 'three';
 declare class ClearPass extends Pass {
-    clearColor: ColorRepresentation;
+    clearColor: Color | string | number;
     clearAlpha: number;
     private _oldClearColor;
-    constructor(clearColor?: ColorRepresentation, clearAlpha?: number);
+    constructor(clearColor?: Color | string | number, clearAlpha?: number);
     render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
 }
 export { ClearPass };