three-stdlib 2.22.7 → 2.22.8

package/dist/offscreen/scene.mjs

@@ -0,0 +1,52 @@
+import * as THREE from "three";
+var camera, scene, renderer, group;
+function init(canvas, width, height, pixelRatio, path) {
+  camera = new THREE.PerspectiveCamera(40, width / height, 1, 1e3);
+  camera.position.z = 200;
+  scene = new THREE.Scene();
+  scene.fog = new THREE.Fog(4473958, 100, 400);
+  scene.background = new THREE.Color(4473958);
+  group = new THREE.Group();
+  scene.add(group);
+  var loader = new THREE.ImageBitmapLoader().setPath(path);
+  loader.setOptions({ imageOrientation: "flipY" });
+  loader.load("textures/matcaps/matcap-porcelain-white.jpg", function(imageBitmap) {
+    var texture = new THREE.CanvasTexture(imageBitmap);
+    var geometry = new THREE.IcosahedronGeometry(5, 8);
+    var materials = [
+      new THREE.MeshMatcapMaterial({ color: 11150559, matcap: texture }),
+      new THREE.MeshMatcapMaterial({ color: 6315408, matcap: texture }),
+      new THREE.MeshMatcapMaterial({ color: 14699071, matcap: texture }),
+      new THREE.MeshMatcapMaterial({ color: 14877782, matcap: texture })
+    ];
+    for (let i = 0; i < 100; i++) {
+      var material = materials[i % materials.length];
+      var mesh = new THREE.Mesh(geometry, material);
+      mesh.position.x = random() * 200 - 100;
+      mesh.position.y = random() * 200 - 100;
+      mesh.position.z = random() * 200 - 100;
+      mesh.scale.setScalar(random() + 1);
+      group.add(mesh);
+    }
+    renderer = new THREE.WebGLRenderer({ antialias: true, canvas });
+    renderer.setPixelRatio(pixelRatio);
+    renderer.setSize(width, height, false);
+    animate();
+  });
+}
+function animate() {
+  group.rotation.y = -Date.now() / 4e3;
+  renderer.render(scene, camera);
+  if (self.requestAnimationFrame) {
+    self.requestAnimationFrame(animate);
+  } else {
+  }
+}
+var seed = 1;
+function random() {
+  var x = Math.sin(seed++) * 1e4;
+  return x - Math.floor(x);
+}
+export {
+  init as default
+};

package/dist/physics/AmmoPhysics.d.ts

@@ -0,0 +1,7 @@
+import { Mesh, Vector3 } from 'three'
+
+export class AmmoPhysics {
+  constructor()
+  addMesh(mesh: Mesh, mass: number): void
+  setMeshPosition(mesh: Mesh, position: Vector3, index: number): void
+}

package/dist/physics/AmmoPhysics.js

@@ -0,0 +1,166 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+async function AmmoPhysics() {
+  if ("Ammo" in window === false) {
+    console.error("AmmoPhysics: Couldn't find Ammo.js");
+    return;
+  }
+  const AmmoLib = await Ammo();
+  const frameRate = 60;
+  const collisionConfiguration = new AmmoLib.btDefaultCollisionConfiguration();
+  const dispatcher = new AmmoLib.btCollisionDispatcher(collisionConfiguration);
+  const broadphase = new AmmoLib.btDbvtBroadphase();
+  const solver = new AmmoLib.btSequentialImpulseConstraintSolver();
+  const world = new AmmoLib.btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
+  world.setGravity(new AmmoLib.btVector3(0, -9.8, 0));
+  const worldTransform = new AmmoLib.btTransform();
+  function getShape(geometry) {
+    const parameters = geometry.parameters;
+    if (geometry.type === "BoxGeometry") {
+      const sx = parameters.width !== void 0 ? parameters.width / 2 : 0.5;
+      const sy = parameters.height !== void 0 ? parameters.height / 2 : 0.5;
+      const sz = parameters.depth !== void 0 ? parameters.depth / 2 : 0.5;
+      const shape = new AmmoLib.btBoxShape(new AmmoLib.btVector3(sx, sy, sz));
+      shape.setMargin(0.05);
+      return shape;
+    } else if (geometry.type === "SphereGeometry" || geometry.type === "IcosahedronGeometry") {
+      const radius = parameters.radius !== void 0 ? parameters.radius : 1;
+      const shape = new AmmoLib.btSphereShape(radius);
+      shape.setMargin(0.05);
+      return shape;
+    }
+    return null;
+  }
+  const meshes = [];
+  const meshMap = /* @__PURE__ */ new WeakMap();
+  function addMesh(mesh, mass = 0) {
+    const shape = getShape(mesh.geometry);
+    if (shape !== null) {
+      if (mesh.isInstancedMesh) {
+        handleInstancedMesh(mesh, mass, shape);
+      } else if (mesh.isMesh) {
+        handleMesh(mesh, mass, shape);
+      }
+    }
+  }
+  function handleMesh(mesh, mass, shape) {
+    const position = mesh.position;
+    const quaternion = mesh.quaternion;
+    const transform = new AmmoLib.btTransform();
+    transform.setIdentity();
+    transform.setOrigin(new AmmoLib.btVector3(position.x, position.y, position.z));
+    transform.setRotation(new AmmoLib.btQuaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w));
+    const motionState = new AmmoLib.btDefaultMotionState(transform);
+    const localInertia = new AmmoLib.btVector3(0, 0, 0);
+    shape.calculateLocalInertia(mass, localInertia);
+    const rbInfo = new AmmoLib.btRigidBodyConstructionInfo(mass, motionState, shape, localInertia);
+    const body = new AmmoLib.btRigidBody(rbInfo);
+    world.addRigidBody(body);
+    if (mass > 0) {
+      meshes.push(mesh);
+      meshMap.set(mesh, body);
+    }
+  }
+  function handleInstancedMesh(mesh, mass, shape) {
+    const array = mesh.instanceMatrix.array;
+    const bodies = [];
+    for (let i = 0; i < mesh.count; i++) {
+      const index = i * 16;
+      const transform = new AmmoLib.btTransform();
+      transform.setFromOpenGLMatrix(array.slice(index, index + 16));
+      const motionState = new AmmoLib.btDefaultMotionState(transform);
+      const localInertia = new AmmoLib.btVector3(0, 0, 0);
+      shape.calculateLocalInertia(mass, localInertia);
+      const rbInfo = new AmmoLib.btRigidBodyConstructionInfo(mass, motionState, shape, localInertia);
+      const body = new AmmoLib.btRigidBody(rbInfo);
+      world.addRigidBody(body);
+      bodies.push(body);
+    }
+    if (mass > 0) {
+      mesh.instanceMatrix.setUsage(35048);
+      meshes.push(mesh);
+      meshMap.set(mesh, bodies);
+    }
+  }
+  function setMeshPosition(mesh, position, index = 0) {
+    if (mesh.isInstancedMesh) {
+      const bodies = meshMap.get(mesh);
+      const body = bodies[index];
+      body.setAngularVelocity(new AmmoLib.btVector3(0, 0, 0));
+      body.setLinearVelocity(new AmmoLib.btVector3(0, 0, 0));
+      worldTransform.setIdentity();
+      worldTransform.setOrigin(new AmmoLib.btVector3(position.x, position.y, position.z));
+      body.setWorldTransform(worldTransform);
+    } else if (mesh.isMesh) {
+      const body = meshMap.get(mesh);
+      body.setAngularVelocity(new AmmoLib.btVector3(0, 0, 0));
+      body.setLinearVelocity(new AmmoLib.btVector3(0, 0, 0));
+      worldTransform.setIdentity();
+      worldTransform.setOrigin(new AmmoLib.btVector3(position.x, position.y, position.z));
+      body.setWorldTransform(worldTransform);
+    }
+  }
+  let lastTime = 0;
+  function step() {
+    const time = performance.now();
+    if (lastTime > 0) {
+      const delta = (time - lastTime) / 1e3;
+      world.stepSimulation(delta, 10);
+    }
+    lastTime = time;
+    for (let i = 0, l = meshes.length; i < l; i++) {
+      const mesh = meshes[i];
+      if (mesh.isInstancedMesh) {
+        const array = mesh.instanceMatrix.array;
+        const bodies = meshMap.get(mesh);
+        for (let j = 0; j < bodies.length; j++) {
+          const body = bodies[j];
+          const motionState = body.getMotionState();
+          motionState.getWorldTransform(worldTransform);
+          const position = worldTransform.getOrigin();
+          const quaternion = worldTransform.getRotation();
+          compose(position, quaternion, array, j * 16);
+        }
+        mesh.instanceMatrix.needsUpdate = true;
+      } else if (mesh.isMesh) {
+        const body = meshMap.get(mesh);
+        const motionState = body.getMotionState();
+        motionState.getWorldTransform(worldTransform);
+        const position = worldTransform.getOrigin();
+        const quaternion = worldTransform.getRotation();
+        mesh.position.set(position.x(), position.y(), position.z());
+        mesh.quaternion.set(quaternion.x(), quaternion.y(), quaternion.z(), quaternion.w());
+      }
+    }
+  }
+  setInterval(step, 1e3 / frameRate);
+  return {
+    addMesh,
+    setMeshPosition
+    // addCompoundMesh
+  };
+}
+function compose(position, quaternion, array, index) {
+  const x = quaternion.x(), y = quaternion.y(), z = quaternion.z(), w = quaternion.w();
+  const x2 = x + x, y2 = y + y, z2 = z + z;
+  const xx = x * x2, xy = x * y2, xz = x * z2;
+  const yy = y * y2, yz = y * z2, zz = z * z2;
+  const wx = w * x2, wy = w * y2, wz = w * z2;
+  array[index + 0] = 1 - (yy + zz);
+  array[index + 1] = xy + wz;
+  array[index + 2] = xz - wy;
+  array[index + 3] = 0;
+  array[index + 4] = xy - wz;
+  array[index + 5] = 1 - (xx + zz);
+  array[index + 6] = yz + wx;
+  array[index + 7] = 0;
+  array[index + 8] = xz + wy;
+  array[index + 9] = yz - wx;
+  array[index + 10] = 1 - (xx + yy);
+  array[index + 11] = 0;
+  array[index + 12] = position.x();
+  array[index + 13] = position.y();
+  array[index + 14] = position.z();
+  array[index + 15] = 1;
+}
+exports.AmmoPhysics = AmmoPhysics;

package/dist/physics/AmmoPhysics.mjs

@@ -0,0 +1,166 @@
+async function AmmoPhysics() {
+  if ("Ammo" in window === false) {
+    console.error("AmmoPhysics: Couldn't find Ammo.js");
+    return;
+  }
+  const AmmoLib = await Ammo();
+  const frameRate = 60;
+  const collisionConfiguration = new AmmoLib.btDefaultCollisionConfiguration();
+  const dispatcher = new AmmoLib.btCollisionDispatcher(collisionConfiguration);
+  const broadphase = new AmmoLib.btDbvtBroadphase();
+  const solver = new AmmoLib.btSequentialImpulseConstraintSolver();
+  const world = new AmmoLib.btDiscreteDynamicsWorld(dispatcher, broadphase, solver, collisionConfiguration);
+  world.setGravity(new AmmoLib.btVector3(0, -9.8, 0));
+  const worldTransform = new AmmoLib.btTransform();
+  function getShape(geometry) {
+    const parameters = geometry.parameters;
+    if (geometry.type === "BoxGeometry") {
+      const sx = parameters.width !== void 0 ? parameters.width / 2 : 0.5;
+      const sy = parameters.height !== void 0 ? parameters.height / 2 : 0.5;
+      const sz = parameters.depth !== void 0 ? parameters.depth / 2 : 0.5;
+      const shape = new AmmoLib.btBoxShape(new AmmoLib.btVector3(sx, sy, sz));
+      shape.setMargin(0.05);
+      return shape;
+    } else if (geometry.type === "SphereGeometry" || geometry.type === "IcosahedronGeometry") {
+      const radius = parameters.radius !== void 0 ? parameters.radius : 1;
+      const shape = new AmmoLib.btSphereShape(radius);
+      shape.setMargin(0.05);
+      return shape;
+    }
+    return null;
+  }
+  const meshes = [];
+  const meshMap = /* @__PURE__ */ new WeakMap();
+  function addMesh(mesh, mass = 0) {
+    const shape = getShape(mesh.geometry);
+    if (shape !== null) {
+      if (mesh.isInstancedMesh) {
+        handleInstancedMesh(mesh, mass, shape);
+      } else if (mesh.isMesh) {
+        handleMesh(mesh, mass, shape);
+      }
+    }
+  }
+  function handleMesh(mesh, mass, shape) {
+    const position = mesh.position;
+    const quaternion = mesh.quaternion;
+    const transform = new AmmoLib.btTransform();
+    transform.setIdentity();
+    transform.setOrigin(new AmmoLib.btVector3(position.x, position.y, position.z));
+    transform.setRotation(new AmmoLib.btQuaternion(quaternion.x, quaternion.y, quaternion.z, quaternion.w));
+    const motionState = new AmmoLib.btDefaultMotionState(transform);
+    const localInertia = new AmmoLib.btVector3(0, 0, 0);
+    shape.calculateLocalInertia(mass, localInertia);
+    const rbInfo = new AmmoLib.btRigidBodyConstructionInfo(mass, motionState, shape, localInertia);
+    const body = new AmmoLib.btRigidBody(rbInfo);
+    world.addRigidBody(body);
+    if (mass > 0) {
+      meshes.push(mesh);
+      meshMap.set(mesh, body);
+    }
+  }
+  function handleInstancedMesh(mesh, mass, shape) {
+    const array = mesh.instanceMatrix.array;
+    const bodies = [];
+    for (let i = 0; i < mesh.count; i++) {
+      const index = i * 16;
+      const transform = new AmmoLib.btTransform();
+      transform.setFromOpenGLMatrix(array.slice(index, index + 16));
+      const motionState = new AmmoLib.btDefaultMotionState(transform);
+      const localInertia = new AmmoLib.btVector3(0, 0, 0);
+      shape.calculateLocalInertia(mass, localInertia);
+      const rbInfo = new AmmoLib.btRigidBodyConstructionInfo(mass, motionState, shape, localInertia);
+      const body = new AmmoLib.btRigidBody(rbInfo);
+      world.addRigidBody(body);
+      bodies.push(body);
+    }
+    if (mass > 0) {
+      mesh.instanceMatrix.setUsage(35048);
+      meshes.push(mesh);
+      meshMap.set(mesh, bodies);
+    }
+  }
+  function setMeshPosition(mesh, position, index = 0) {
+    if (mesh.isInstancedMesh) {
+      const bodies = meshMap.get(mesh);
+      const body = bodies[index];
+      body.setAngularVelocity(new AmmoLib.btVector3(0, 0, 0));
+      body.setLinearVelocity(new AmmoLib.btVector3(0, 0, 0));
+      worldTransform.setIdentity();
+      worldTransform.setOrigin(new AmmoLib.btVector3(position.x, position.y, position.z));
+      body.setWorldTransform(worldTransform);
+    } else if (mesh.isMesh) {
+      const body = meshMap.get(mesh);
+      body.setAngularVelocity(new AmmoLib.btVector3(0, 0, 0));
+      body.setLinearVelocity(new AmmoLib.btVector3(0, 0, 0));
+      worldTransform.setIdentity();
+      worldTransform.setOrigin(new AmmoLib.btVector3(position.x, position.y, position.z));
+      body.setWorldTransform(worldTransform);
+    }
+  }
+  let lastTime = 0;
+  function step() {
+    const time = performance.now();
+    if (lastTime > 0) {
+      const delta = (time - lastTime) / 1e3;
+      world.stepSimulation(delta, 10);
+    }
+    lastTime = time;
+    for (let i = 0, l = meshes.length; i < l; i++) {
+      const mesh = meshes[i];
+      if (mesh.isInstancedMesh) {
+        const array = mesh.instanceMatrix.array;
+        const bodies = meshMap.get(mesh);
+        for (let j = 0; j < bodies.length; j++) {
+          const body = bodies[j];
+          const motionState = body.getMotionState();
+          motionState.getWorldTransform(worldTransform);
+          const position = worldTransform.getOrigin();
+          const quaternion = worldTransform.getRotation();
+          compose(position, quaternion, array, j * 16);
+        }
+        mesh.instanceMatrix.needsUpdate = true;
+      } else if (mesh.isMesh) {
+        const body = meshMap.get(mesh);
+        const motionState = body.getMotionState();
+        motionState.getWorldTransform(worldTransform);
+        const position = worldTransform.getOrigin();
+        const quaternion = worldTransform.getRotation();
+        mesh.position.set(position.x(), position.y(), position.z());
+        mesh.quaternion.set(quaternion.x(), quaternion.y(), quaternion.z(), quaternion.w());
+      }
+    }
+  }
+  setInterval(step, 1e3 / frameRate);
+  return {
+    addMesh,
+    setMeshPosition
+    // addCompoundMesh
+  };
+}
+function compose(position, quaternion, array, index) {
+  const x = quaternion.x(), y = quaternion.y(), z = quaternion.z(), w = quaternion.w();
+  const x2 = x + x, y2 = y + y, z2 = z + z;
+  const xx = x * x2, xy = x * y2, xz = x * z2;
+  const yy = y * y2, yz = y * z2, zz = z * z2;
+  const wx = w * x2, wy = w * y2, wz = w * z2;
+  array[index + 0] = 1 - (yy + zz);
+  array[index + 1] = xy + wz;
+  array[index + 2] = xz - wy;
+  array[index + 3] = 0;
+  array[index + 4] = xy - wz;
+  array[index + 5] = 1 - (xx + zz);
+  array[index + 6] = yz + wx;
+  array[index + 7] = 0;
+  array[index + 8] = xz + wy;
+  array[index + 9] = yz - wx;
+  array[index + 10] = 1 - (xx + yy);
+  array[index + 11] = 0;
+  array[index + 12] = position.x();
+  array[index + 13] = position.y();
+  array[index + 14] = position.z();
+  array[index + 15] = 1;
+}
+export {
+  AmmoPhysics
+};

package/dist/postprocessing/AdaptiveToneMappingPass.d.ts

@@ -0,0 +1,29 @@
+import { WebGLRenderTarget, ShaderMaterial } from 'three'
+
+import { Pass } from './Pass'
+
+export class AdaptiveToneMappingPass extends Pass {
+  constructor(adaptive?: boolean, resolution?: number)
+  adaptive: boolean
+  resolution: number
+  needsInit: number
+  luminanceRT: WebGLRenderTarget
+  previousLuminanceRT: WebGLRenderTarget
+  currentLuminanceRT: WebGLRenderTarget
+  copyUniforms: object
+  materialCopy: ShaderMaterial
+  materialLuminance: ShaderMaterial
+  adaptLuminanceShader: object
+  materialAdaptiveLum: ShaderMaterial
+  materialToneMap: ShaderMaterial
+  fsQuad: object
+
+  reset(): void
+  setAdaptive(adaptive: boolean): void
+  setAdaptionRate(rate: number): void
+  setMinLuminance(minLum: number): void
+  setMaxLuminance(maxLum: number): void
+  setAverageLuminance(avgLum: number): void
+  setMiddleGrey(middleGrey: number): void
+  dispose(): void
+}

package/dist/postprocessing/AdaptiveToneMappingPass.js

@@ -0,0 +1,225 @@
+"use strict";
+Object.defineProperty(exports, 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 !== 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) {
+    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: 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 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 THREE.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 THREE.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();
+    }
+  }
+});
+exports.AdaptiveToneMappingPass = AdaptiveToneMappingPass;