three-stdlib 2.15.0 → 2.15.2

package/postprocessing/AdaptiveToneMappingPass.js

@@ -1,91 +1,92 @@
-import { UniformsUtils, ShaderMaterial, NoBlending, WebGLRenderTarget, LinearMipmapLinearFilter, MeshBasicMaterial, LinearFilter, RGBAFormat } from 'three';
-import { FullScreenQuad, Pass } from './Pass.js';
-import { CopyShader } from '../shaders/CopyShader.js';
-import { LuminosityShader } from '../shaders/LuminosityShader.js';
-import { ToneMapShader } from '../shaders/ToneMapShader.js';
-
-/**
- * Generate a texture that represents the luminosity of the current scene, adapted over time
- * to simulate the optic nerve responding to the amount of light it is receiving.
- * Based on a GDC2007 presentation by Wolfgang Engel titled "Post-Processing Pipeline"
- *
- * Full-screen tone-mapping shader based on http://www.graphics.cornell.edu/~jaf/publications/sig02_paper.pdf
- */
-
-var AdaptiveToneMappingPass = function (adaptive, resolution) {
-  this.resolution = resolution !== undefined ? resolution : 256;
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+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 !== undefined ? !!adaptive : true;
+  this.adaptive = adaptive !== void 0 ? !!adaptive : true;
   this.luminanceRT = null;
   this.previousLuminanceRT = null;
   this.currentLuminanceRT = null;
-  if (CopyShader === undefined) console.error('THREE.AdaptiveToneMappingPass relies on CopyShader');
-  var copyShader = CopyShader;
-  this.copyUniforms = UniformsUtils.clone(copyShader.uniforms);
-  this.materialCopy = new ShaderMaterial({
+  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: NoBlending,
+    blending: THREE.NoBlending,
     depthTest: false
   });
-  if (LuminosityShader === undefined) console.error('THREE.AdaptiveToneMappingPass relies on LuminosityShader');
-  this.materialLuminance = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(LuminosityShader.uniforms),
-    vertexShader: LuminosityShader.vertexShader,
-    fragmentShader: LuminosityShader.fragmentShader,
-    blending: NoBlending
+  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.0)).toFixed(1)
+      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.0
-      }
+      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')
+    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 );",
+      "	fCurrentLum *= fCurrentLum;",
+      "	float fAdaptedLum = fLastLum + (fCurrentLum - fLastLum) * (1.0 - exp(-delta * tau));",
+      "	gl_FragColor.r = fAdaptedLum;",
+      "}"
+    ].join("\n")
   };
-  this.materialAdaptiveLum = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(this.adaptLuminanceShader.uniforms),
+  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: NoBlending
+    blending: THREE.NoBlending
   });
-  if (ToneMapShader === undefined) console.error('THREE.AdaptiveToneMappingPass relies on ToneMapShader');
-  this.materialToneMap = new ShaderMaterial({
-    uniforms: UniformsUtils.clone(ToneMapShader.uniforms),
-    vertexShader: ToneMapShader.vertexShader,
-    fragmentShader: ToneMapShader.fragmentShader,
-    blending: 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 FullScreenQuad(null);
+  this.fsQuad = new Pass.FullScreenQuad(null);
 };
-
-AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype), {
+AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
   constructor: AdaptiveToneMappingPass,
-  render: function (renderer, writeBuffer, readBuffer, deltaTime
-  /*, maskActive*/
-  ) {
+  render: function(renderer, writeBuffer, readBuffer, deltaTime) {
     if (this.needsInit) {
       this.reset(renderer);
       this.luminanceRT.texture.type = readBuffer.texture.type;
@@ -93,155 +94,128 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype),
       this.currentLuminanceRT.texture.type = readBuffer.texture.type;
       this.needsInit = false;
     }
-
     if (this.adaptive) {
-      //Render the luminance of the current scene into a render target with mipmapping enabled
       this.fsQuad.material = this.materialLuminance;
       this.materialLuminance.uniforms.tDiffuse.value = readBuffer.texture;
       renderer.setRenderTarget(this.currentLuminanceRT);
-      this.fsQuad.render(renderer); //Use the new luminance values, the previous luminance and the frame delta to
-      //adapt the luminance over time.
-
+      this.fsQuad.render(renderer);
       this.fsQuad.material = this.materialAdaptiveLum;
       this.materialAdaptiveLum.uniforms.delta.value = deltaTime;
       this.materialAdaptiveLum.uniforms.lastLum.value = this.previousLuminanceRT.texture;
       this.materialAdaptiveLum.uniforms.currentLum.value = this.currentLuminanceRT.texture;
       renderer.setRenderTarget(this.luminanceRT);
-      this.fsQuad.render(renderer); //Copy the new adapted luminance value so that it can be used by the next frame.
-
+      this.fsQuad.render(renderer);
       this.fsQuad.material = this.materialCopy;
       this.copyUniforms.tDiffuse.value = this.luminanceRT.texture;
       renderer.setRenderTarget(this.previousLuminanceRT);
       this.fsQuad.render(renderer);
     }
-
     this.fsQuad.material = this.materialToneMap;
     this.materialToneMap.uniforms.tDiffuse.value = readBuffer.texture;
-
     if (this.renderToScreen) {
       renderer.setRenderTarget(null);
       this.fsQuad.render(renderer);
     } else {
       renderer.setRenderTarget(writeBuffer);
-      if (this.clear) renderer.clear();
+      if (this.clear)
+        renderer.clear();
       this.fsQuad.render(renderer);
     }
   },
-  reset: function () {
-    // render targets
+  reset: function() {
     if (this.luminanceRT) {
       this.luminanceRT.dispose();
     }
-
     if (this.currentLuminanceRT) {
       this.currentLuminanceRT.dispose();
     }
-
     if (this.previousLuminanceRT) {
       this.previousLuminanceRT.dispose();
     }
-
     var pars = {
-      minFilter: LinearFilter,
-      magFilter: LinearFilter,
-      format: RGBAFormat
-    }; // was RGB format. changed to RGBA format. see discussion in #8415 / #8450
-
-    this.luminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
-    this.luminanceRT.texture.name = 'AdaptiveToneMappingPass.l';
+      minFilter: THREE.LinearFilter,
+      magFilter: THREE.LinearFilter,
+      format: THREE.RGBAFormat
+    };
+    this.luminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.luminanceRT.texture.name = "AdaptiveToneMappingPass.l";
     this.luminanceRT.texture.generateMipmaps = false;
-    this.previousLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
-    this.previousLuminanceRT.texture.name = 'AdaptiveToneMappingPass.pl';
-    this.previousLuminanceRT.texture.generateMipmaps = false; // We only need mipmapping for the current luminosity because we want a down-sampled version to sample in our adaptive shader
-
-    pars.minFilter = LinearMipmapLinearFilter;
+    this.previousLuminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.previousLuminanceRT.texture.name = "AdaptiveToneMappingPass.pl";
+    this.previousLuminanceRT.texture.generateMipmaps = false;
+    pars.minFilter = THREE.LinearMipmapLinearFilter;
     pars.generateMipmaps = true;
-    this.currentLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
-    this.currentLuminanceRT.texture.name = 'AdaptiveToneMappingPass.cl';
-
+    this.currentLuminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.currentLuminanceRT.texture.name = "AdaptiveToneMappingPass.cl";
     if (this.adaptive) {
-      this.materialToneMap.defines['ADAPTED_LUMINANCE'] = '';
+      this.materialToneMap.defines["ADAPTED_LUMINANCE"] = "";
       this.materialToneMap.uniforms.luminanceMap.value = this.luminanceRT.texture;
-    } //Put something in the adaptive luminance texture so that the scene can render initially
-
-
-    this.fsQuad.material = new MeshBasicMaterial({
-      color: 0x777777
-    });
+    }
+    this.fsQuad.material = new THREE.MeshBasicMaterial({ color: 7829367 });
     this.materialLuminance.needsUpdate = true;
     this.materialAdaptiveLum.needsUpdate = true;
-    this.materialToneMap.needsUpdate = true; // renderer.render( this.scene, this.camera, this.luminanceRT );
-    // renderer.render( this.scene, this.camera, this.previousLuminanceRT );
-    // renderer.render( this.scene, this.camera, this.currentLuminanceRT );
+    this.materialToneMap.needsUpdate = true;
   },
-  setAdaptive: function (adaptive) {
+  setAdaptive: function(adaptive) {
     if (adaptive) {
       this.adaptive = true;
-      this.materialToneMap.defines['ADAPTED_LUMINANCE'] = '';
+      this.materialToneMap.defines["ADAPTED_LUMINANCE"] = "";
       this.materialToneMap.uniforms.luminanceMap.value = this.luminanceRT.texture;
     } else {
       this.adaptive = false;
-      delete this.materialToneMap.defines['ADAPTED_LUMINANCE'];
+      delete this.materialToneMap.defines["ADAPTED_LUMINANCE"];
       this.materialToneMap.uniforms.luminanceMap.value = null;
     }
-
     this.materialToneMap.needsUpdate = true;
   },
-  setAdaptionRate: function (rate) {
+  setAdaptionRate: function(rate) {
     if (rate) {
       this.materialAdaptiveLum.uniforms.tau.value = Math.abs(rate);
     }
   },
-  setMinLuminance: function (minLum) {
+  setMinLuminance: function(minLum) {
     if (minLum) {
       this.materialToneMap.uniforms.minLuminance.value = minLum;
       this.materialAdaptiveLum.uniforms.minLuminance.value = minLum;
     }
   },
-  setMaxLuminance: function (maxLum) {
+  setMaxLuminance: function(maxLum) {
     if (maxLum) {
       this.materialToneMap.uniforms.maxLuminance.value = maxLum;
     }
   },
-  setAverageLuminance: function (avgLum) {
+  setAverageLuminance: function(avgLum) {
     if (avgLum) {
       this.materialToneMap.uniforms.averageLuminance.value = avgLum;
     }
   },
-  setMiddleGrey: function (middleGrey) {
+  setMiddleGrey: function(middleGrey) {
     if (middleGrey) {
       this.materialToneMap.uniforms.middleGrey.value = middleGrey;
     }
   },
-  dispose: function () {
+  dispose: function() {
     if (this.luminanceRT) {
       this.luminanceRT.dispose();
     }
-
     if (this.previousLuminanceRT) {
       this.previousLuminanceRT.dispose();
     }
-
     if (this.currentLuminanceRT) {
       this.currentLuminanceRT.dispose();
     }
-
     if (this.materialLuminance) {
       this.materialLuminance.dispose();
     }
-
     if (this.materialAdaptiveLum) {
       this.materialAdaptiveLum.dispose();
     }
-
     if (this.materialCopy) {
       this.materialCopy.dispose();
     }
-
     if (this.materialToneMap) {
       this.materialToneMap.dispose();
     }
   }
 });
-
-export { AdaptiveToneMappingPass };
+exports.AdaptiveToneMappingPass = AdaptiveToneMappingPass;

package/postprocessing/AdaptiveToneMappingPass.mjs

@@ -0,0 +1,221 @@
+import { UniformsUtils, ShaderMaterial, NoBlending, LinearFilter, RGBAFormat, WebGLRenderTarget, LinearMipmapLinearFilter, MeshBasicMaterial } from "three";
+import { FullScreenQuad, Pass } 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 );",
+      "	fCurrentLum *= fCurrentLum;",
+      "	float fAdaptedLum = fLastLum + (fCurrentLum - fLastLum) * (1.0 - exp(-delta * tau));",
+      "	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) {
+    if (this.needsInit) {
+      this.reset(renderer);
+      this.luminanceRT.texture.type = readBuffer.texture.type;
+      this.previousLuminanceRT.texture.type = readBuffer.texture.type;
+      this.currentLuminanceRT.texture.type = readBuffer.texture.type;
+      this.needsInit = false;
+    }
+    if (this.adaptive) {
+      this.fsQuad.material = this.materialLuminance;
+      this.materialLuminance.uniforms.tDiffuse.value = readBuffer.texture;
+      renderer.setRenderTarget(this.currentLuminanceRT);
+      this.fsQuad.render(renderer);
+      this.fsQuad.material = this.materialAdaptiveLum;
+      this.materialAdaptiveLum.uniforms.delta.value = deltaTime;
+      this.materialAdaptiveLum.uniforms.lastLum.value = this.previousLuminanceRT.texture;
+      this.materialAdaptiveLum.uniforms.currentLum.value = this.currentLuminanceRT.texture;
+      renderer.setRenderTarget(this.luminanceRT);
+      this.fsQuad.render(renderer);
+      this.fsQuad.material = this.materialCopy;
+      this.copyUniforms.tDiffuse.value = this.luminanceRT.texture;
+      renderer.setRenderTarget(this.previousLuminanceRT);
+      this.fsQuad.render(renderer);
+    }
+    this.fsQuad.material = this.materialToneMap;
+    this.materialToneMap.uniforms.tDiffuse.value = readBuffer.texture;
+    if (this.renderToScreen) {
+      renderer.setRenderTarget(null);
+      this.fsQuad.render(renderer);
+    } else {
+      renderer.setRenderTarget(writeBuffer);
+      if (this.clear)
+        renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+  },
+  reset: function() {
+    if (this.luminanceRT) {
+      this.luminanceRT.dispose();
+    }
+    if (this.currentLuminanceRT) {
+      this.currentLuminanceRT.dispose();
+    }
+    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.texture.name = "AdaptiveToneMappingPass.l";
+    this.luminanceRT.texture.generateMipmaps = false;
+    this.previousLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.previousLuminanceRT.texture.name = "AdaptiveToneMappingPass.pl";
+    this.previousLuminanceRT.texture.generateMipmaps = false;
+    pars.minFilter = LinearMipmapLinearFilter;
+    pars.generateMipmaps = true;
+    this.currentLuminanceRT = new WebGLRenderTarget(this.resolution, this.resolution, pars);
+    this.currentLuminanceRT.texture.name = "AdaptiveToneMappingPass.cl";
+    if (this.adaptive) {
+      this.materialToneMap.defines["ADAPTED_LUMINANCE"] = "";
+      this.materialToneMap.uniforms.luminanceMap.value = this.luminanceRT.texture;
+    }
+    this.fsQuad.material = new MeshBasicMaterial({ color: 7829367 });
+    this.materialLuminance.needsUpdate = true;
+    this.materialAdaptiveLum.needsUpdate = true;
+    this.materialToneMap.needsUpdate = true;
+  },
+  setAdaptive: function(adaptive) {
+    if (adaptive) {
+      this.adaptive = true;
+      this.materialToneMap.defines["ADAPTED_LUMINANCE"] = "";
+      this.materialToneMap.uniforms.luminanceMap.value = this.luminanceRT.texture;
+    } else {
+      this.adaptive = false;
+      delete this.materialToneMap.defines["ADAPTED_LUMINANCE"];
+      this.materialToneMap.uniforms.luminanceMap.value = null;
+    }
+    this.materialToneMap.needsUpdate = true;
+  },
+  setAdaptionRate: function(rate) {
+    if (rate) {
+      this.materialAdaptiveLum.uniforms.tau.value = Math.abs(rate);
+    }
+  },
+  setMinLuminance: function(minLum) {
+    if (minLum) {
+      this.materialToneMap.uniforms.minLuminance.value = minLum;
+      this.materialAdaptiveLum.uniforms.minLuminance.value = minLum;
+    }
+  },
+  setMaxLuminance: function(maxLum) {
+    if (maxLum) {
+      this.materialToneMap.uniforms.maxLuminance.value = maxLum;
+    }
+  },
+  setAverageLuminance: function(avgLum) {
+    if (avgLum) {
+      this.materialToneMap.uniforms.averageLuminance.value = avgLum;
+    }
+  },
+  setMiddleGrey: function(middleGrey) {
+    if (middleGrey) {
+      this.materialToneMap.uniforms.middleGrey.value = middleGrey;
+    }
+  },
+  dispose: function() {
+    if (this.luminanceRT) {
+      this.luminanceRT.dispose();
+    }
+    if (this.previousLuminanceRT) {
+      this.previousLuminanceRT.dispose();
+    }
+    if (this.currentLuminanceRT) {
+      this.currentLuminanceRT.dispose();
+    }
+    if (this.materialLuminance) {
+      this.materialLuminance.dispose();
+    }
+    if (this.materialAdaptiveLum) {
+      this.materialAdaptiveLum.dispose();
+    }
+    if (this.materialCopy) {
+      this.materialCopy.dispose();
+    }
+    if (this.materialToneMap) {
+      this.materialToneMap.dispose();
+    }
+  }
+});
+export {
+  AdaptiveToneMappingPass
+};

package/postprocessing/AfterimagePass.js

@@ -1,76 +1,55 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import { UniformsUtils, WebGLRenderTarget, LinearFilter, NearestFilter, RGBAFormat, ShaderMaterial, MeshBasicMaterial } from 'three';
-import { Pass, FullScreenQuad } from './Pass.js';
-import { AfterimageShader } from '../shaders/AfterimageShader.js';
-
-class AfterimagePass extends Pass {
-  constructor(damp = 0.96, shader = AfterimageShader) {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const Pass = require("./Pass.js");
+const AfterimageShader = require("../shaders/AfterimageShader.js");
+class AfterimagePass extends Pass.Pass {
+  constructor(damp = 0.96, shader = AfterimageShader.AfterimageShader) {
     super();
-
-    _defineProperty(this, "shader", void 0);
-
-    _defineProperty(this, "uniforms", void 0);
-
-    _defineProperty(this, "textureComp", void 0);
-
-    _defineProperty(this, "textureOld", void 0);
-
-    _defineProperty(this, "shaderMaterial", void 0);
-
-    _defineProperty(this, "compFsQuad", void 0);
-
-    _defineProperty(this, "copyFsQuad", void 0);
-
     this.shader = shader;
-    this.uniforms = UniformsUtils.clone(shader.uniforms);
-    this.uniforms['damp'].value = damp;
-    this.textureComp = new WebGLRenderTarget(window.innerWidth, window.innerHeight, {
-      minFilter: LinearFilter,
-      magFilter: NearestFilter,
-      format: RGBAFormat
+    this.uniforms = THREE.UniformsUtils.clone(shader.uniforms);
+    this.uniforms["damp"].value = damp;
+    this.textureComp = new THREE.WebGLRenderTarget(window.innerWidth, window.innerHeight, {
+      minFilter: THREE.LinearFilter,
+      magFilter: THREE.NearestFilter,
+      format: THREE.RGBAFormat
     });
-    this.textureOld = new WebGLRenderTarget(window.innerWidth, window.innerHeight, {
-      minFilter: LinearFilter,
-      magFilter: NearestFilter,
-      format: RGBAFormat
+    this.textureOld = new THREE.WebGLRenderTarget(window.innerWidth, window.innerHeight, {
+      minFilter: THREE.LinearFilter,
+      magFilter: THREE.NearestFilter,
+      format: THREE.RGBAFormat
     });
-    this.shaderMaterial = new ShaderMaterial({
+    this.shaderMaterial = new THREE.ShaderMaterial({
       uniforms: this.uniforms,
       vertexShader: this.shader.vertexShader,
       fragmentShader: this.shader.fragmentShader
     });
-    this.compFsQuad = new FullScreenQuad(this.shaderMaterial);
-    let material = new MeshBasicMaterial();
-    this.copyFsQuad = new FullScreenQuad(material);
+    this.compFsQuad = new Pass.FullScreenQuad(this.shaderMaterial);
+    let material = new THREE.MeshBasicMaterial();
+    this.copyFsQuad = new Pass.FullScreenQuad(material);
   }
-
   render(renderer, writeBuffer, readBuffer) {
-    this.uniforms['tOld'].value = this.textureOld.texture;
-    this.uniforms['tNew'].value = readBuffer.texture;
+    this.uniforms["tOld"].value = this.textureOld.texture;
+    this.uniforms["tNew"].value = readBuffer.texture;
     renderer.setRenderTarget(this.textureComp);
     this.compFsQuad.render(renderer);
     this.copyFsQuad.material.map = this.textureComp.texture;
-
     if (this.renderToScreen) {
       renderer.setRenderTarget(null);
       this.copyFsQuad.render(renderer);
     } else {
       renderer.setRenderTarget(writeBuffer);
-      if (this.clear) renderer.clear();
+      if (this.clear)
+        renderer.clear();
       this.copyFsQuad.render(renderer);
-    } // Swap buffers.
-
-
+    }
     let temp = this.textureOld;
     this.textureOld = this.textureComp;
-    this.textureComp = temp; // Now textureOld contains the latest image, ready for the next frame.
+    this.textureComp = temp;
   }
-
   setSize(width, height) {
     this.textureComp.setSize(width, height);
     this.textureOld.setSize(width, height);
   }
-
 }
-
-export { AfterimagePass };
+exports.AfterimagePass = AfterimagePass;