three-stdlib 2.16.0 → 2.16.2

package/offscreen/scene.mjs

@@ -1,52 +0,0 @@
-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/physics/AmmoPhysics.mjs

@@ -1,165 +0,0 @@
-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
-  };
-}
-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/postprocessing/AdaptiveToneMappingPass.mjs

@@ -1,221 +0,0 @@
-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.mjs

@@ -1,55 +0,0 @@
-import { UniformsUtils, WebGLRenderTarget, LinearFilter, NearestFilter, RGBAFormat, ShaderMaterial, MeshBasicMaterial } from "three";
-import { Pass, FullScreenQuad } from "./Pass.mjs";
-import { AfterimageShader } from "../shaders/AfterimageShader.mjs";
-class AfterimagePass extends Pass {
-  constructor(damp = 0.96, shader = AfterimageShader) {
-    super();
-    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.textureOld = new WebGLRenderTarget(window.innerWidth, window.innerHeight, {
-      minFilter: LinearFilter,
-      magFilter: NearestFilter,
-      format: RGBAFormat
-    });
-    this.shaderMaterial = new 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);
-  }
-  render(renderer, writeBuffer, readBuffer) {
-    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();
-      this.copyFsQuad.render(renderer);
-    }
-    let temp = this.textureOld;
-    this.textureOld = this.textureComp;
-    this.textureComp = temp;
-  }
-  setSize(width, height) {
-    this.textureComp.setSize(width, height);
-    this.textureOld.setSize(width, height);
-  }
-}
-export {
-  AfterimagePass
-};

package/postprocessing/BloomPass.mjs

@@ -1,90 +0,0 @@
-import { Pass, FullScreenQuad } from "./Pass.mjs";
-import { Vector2, WebGLRenderTarget, UniformsUtils, ShaderMaterial, AdditiveBlending } from "three";
-import { ConvolutionShader } from "../shaders/ConvolutionShader.mjs";
-class BloomPass extends Pass {
-  constructor(strength = 1, kernelSize = 25, sigma = 4, resolution = 256) {
-    super();
-    this.blurX = new Vector2(1953125e-9, 0);
-    this.blurY = new Vector2(0, 1953125e-9);
-    this.renderTargetX = new WebGLRenderTarget(resolution, resolution);
-    this.renderTargetX.texture.name = "BloomPass.x";
-    this.renderTargetY = new WebGLRenderTarget(resolution, resolution);
-    this.renderTargetY.texture.name = "BloomPass.y";
-    this.combineUniforms = UniformsUtils.clone(CombineShader.uniforms);
-    this.combineUniforms["strength"].value = strength;
-    this.materialCombine = new ShaderMaterial({
-      uniforms: this.combineUniforms,
-      vertexShader: CombineShader.vertexShader,
-      fragmentShader: CombineShader.fragmentShader,
-      blending: AdditiveBlending,
-      transparent: true
-    });
-    if (ConvolutionShader === void 0)
-      console.error("BloomPass relies on ConvolutionShader");
-    const convolutionShader = ConvolutionShader;
-    this.convolutionUniforms = UniformsUtils.clone(convolutionShader.uniforms);
-    this.convolutionUniforms["uImageIncrement"].value = this.blurX;
-    this.convolutionUniforms["cKernel"].value = ConvolutionShader.buildKernel(sigma);
-    this.materialConvolution = new ShaderMaterial({
-      uniforms: this.convolutionUniforms,
-      vertexShader: convolutionShader.vertexShader,
-      fragmentShader: convolutionShader.fragmentShader,
-      defines: {
-        KERNEL_SIZE_FLOAT: kernelSize.toFixed(1),
-        KERNEL_SIZE_INT: kernelSize.toFixed(0)
-      }
-    });
-    this.needsSwap = false;
-    this.fsQuad = new FullScreenQuad(this.materialConvolution);
-  }
-  render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
-    if (maskActive)
-      renderer.state.buffers.stencil.setTest(false);
-    this.fsQuad.material = this.materialConvolution;
-    this.convolutionUniforms["tDiffuse"].value = readBuffer.texture;
-    this.convolutionUniforms["uImageIncrement"].value = this.blurX;
-    renderer.setRenderTarget(this.renderTargetX);
-    renderer.clear();
-    this.fsQuad.render(renderer);
-    this.convolutionUniforms["tDiffuse"].value = this.renderTargetX.texture;
-    this.convolutionUniforms["uImageIncrement"].value = this.blurY;
-    renderer.setRenderTarget(this.renderTargetY);
-    renderer.clear();
-    this.fsQuad.render(renderer);
-    this.fsQuad.material = this.materialCombine;
-    this.combineUniforms["tDiffuse"].value = this.renderTargetY.texture;
-    if (maskActive)
-      renderer.state.buffers.stencil.setTest(true);
-    renderer.setRenderTarget(readBuffer);
-    if (this.clear)
-      renderer.clear();
-    this.fsQuad.render(renderer);
-  }
-}
-const CombineShader = {
-  uniforms: {
-    tDiffuse: {
-      value: null
-    },
-    strength: {
-      value: 1
-    }
-  },
-  vertexShader: `
-  varying vec2 vUv;
-  void main() {
-    vUv = uv;
-    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-  }`,
-  fragmentShader: `
-  uniform float strength;
-  uniform sampler2D tDiffuse;
-  varying vec2 vUv;
-  void main() {
-    vec4 texel = texture2D( tDiffuse, vUv );
-    gl_FragColor = strength * texel;
-  }`
-};
-export {
-  BloomPass
-};

package/postprocessing/BokehPass.mjs

@@ -1,76 +0,0 @@
-import { Pass, FullScreenQuad } from "./Pass.mjs";
-import { WebGLRenderTarget, NearestFilter, MeshDepthMaterial, RGBADepthPacking, NoBlending, UniformsUtils, ShaderMaterial, Color } from "three";
-import { BokehShader } from "../shaders/BokehShader.mjs";
-class BokehPass extends Pass {
-  constructor(scene, camera, params) {
-    super();
-    this.scene = scene;
-    this.camera = camera;
-    const focus = params.focus !== void 0 ? params.focus : 1;
-    const aspect = params.aspect !== void 0 ? params.aspect : camera.aspect;
-    const aperture = params.aperture !== void 0 ? params.aperture : 0.025;
-    const maxblur = params.maxblur !== void 0 ? params.maxblur : 1;
-    const width = params.width || window.innerWidth || 1;
-    const height = params.height || window.innerHeight || 1;
-    this.renderTargetDepth = new WebGLRenderTarget(width, height, {
-      minFilter: NearestFilter,
-      magFilter: NearestFilter
-    });
-    this.renderTargetDepth.texture.name = "BokehPass.depth";
-    this.materialDepth = new MeshDepthMaterial();
-    this.materialDepth.depthPacking = RGBADepthPacking;
-    this.materialDepth.blending = NoBlending;
-    if (BokehShader === void 0) {
-      console.error("BokehPass relies on BokehShader");
-    }
-    const bokehShader = BokehShader;
-    const bokehUniforms = UniformsUtils.clone(bokehShader.uniforms);
-    bokehUniforms["tDepth"].value = this.renderTargetDepth.texture;
-    bokehUniforms["focus"].value = focus;
-    bokehUniforms["aspect"].value = aspect;
-    bokehUniforms["aperture"].value = aperture;
-    bokehUniforms["maxblur"].value = maxblur;
-    bokehUniforms["nearClip"].value = camera.near;
-    bokehUniforms["farClip"].value = camera.far;
-    this.materialBokeh = new ShaderMaterial({
-      defines: Object.assign({}, bokehShader.defines),
-      uniforms: bokehUniforms,
-      vertexShader: bokehShader.vertexShader,
-      fragmentShader: bokehShader.fragmentShader
-    });
-    this.uniforms = bokehUniforms;
-    this.needsSwap = false;
-    this.fsQuad = new FullScreenQuad(this.materialBokeh);
-    this._oldClearColor = new Color();
-  }
-  render(renderer, writeBuffer, readBuffer) {
-    this.scene.overrideMaterial = this.materialDepth;
-    renderer.getClearColor(this._oldClearColor);
-    const oldClearAlpha = renderer.getClearAlpha();
-    const oldAutoClear = renderer.autoClear;
-    renderer.autoClear = false;
-    renderer.setClearColor(16777215);
-    renderer.setClearAlpha(1);
-    renderer.setRenderTarget(this.renderTargetDepth);
-    renderer.clear();
-    renderer.render(this.scene, this.camera);
-    this.uniforms["tColor"].value = readBuffer.texture;
-    this.uniforms["nearClip"].value = this.camera.near;
-    this.uniforms["farClip"].value = this.camera.far;
-    if (this.renderToScreen) {
-      renderer.setRenderTarget(null);
-      this.fsQuad.render(renderer);
-    } else {
-      renderer.setRenderTarget(writeBuffer);
-      renderer.clear();
-      this.fsQuad.render(renderer);
-    }
-    this.scene.overrideMaterial = null;
-    renderer.setClearColor(this._oldClearColor);
-    renderer.setClearAlpha(oldClearAlpha);
-    renderer.autoClear = oldAutoClear;
-  }
-}
-export {
-  BokehPass
-};

package/postprocessing/ClearPass.mjs

@@ -1,27 +0,0 @@
-import { Pass } from "./Pass.mjs";
-import { Color } from "three";
-class ClearPass extends Pass {
-  constructor(clearColor, clearAlpha) {
-    super();
-    this.needsSwap = false;
-    this.clearColor = clearColor !== void 0 ? clearColor : 0;
-    this.clearAlpha = clearAlpha !== void 0 ? clearAlpha : 0;
-    this._oldClearColor = new Color();
-  }
-  render(renderer, writeBuffer, readBuffer) {
-    let oldClearAlpha;
-    if (this.clearColor) {
-      renderer.getClearColor(this._oldClearColor);
-      oldClearAlpha = renderer.getClearAlpha();
-      renderer.setClearColor(this.clearColor, this.clearAlpha);
-    }
-    renderer.setRenderTarget(this.renderToScreen ? null : readBuffer);
-    renderer.clear();
-    if (this.clearColor) {
-      renderer.setClearColor(this._oldClearColor, oldClearAlpha);
-    }
-  }
-}
-export {
-  ClearPass
-};