three-stdlib 2.22.7 → 2.22.9

package/dist/postprocessing/AdaptiveToneMappingPass.mjs

@@ -0,0 +1,225 @@
+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 );",
+      //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) {
+    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/dist/postprocessing/AfterimagePass.d.ts

@@ -0,0 +1,15 @@
+import { MeshBasicMaterial, WebGLRenderer, ShaderMaterial, WebGLRenderTarget } from 'three';
+import { Pass, FullScreenQuad } from './Pass';
+declare class AfterimagePass extends Pass {
+    shader: import("../shaders/AfterimageShader").IAfterimageShader;
+    uniforms: any;
+    textureComp: WebGLRenderTarget;
+    textureOld: WebGLRenderTarget;
+    shaderMaterial: ShaderMaterial;
+    compFsQuad: FullScreenQuad<ShaderMaterial>;
+    copyFsQuad: FullScreenQuad<MeshBasicMaterial>;
+    constructor(damp?: number, shader?: import("../shaders/AfterimageShader").IAfterimageShader);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+    setSize(width: number, height: number): void;
+}
+export { AfterimagePass };

package/dist/postprocessing/AfterimagePass.js

@@ -0,0 +1,68 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, 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();
+    __publicField(this, "shader");
+    __publicField(this, "uniforms");
+    __publicField(this, "textureComp");
+    __publicField(this, "textureOld");
+    __publicField(this, "shaderMaterial");
+    __publicField(this, "compFsQuad");
+    __publicField(this, "copyFsQuad");
+    this.shader = shader;
+    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 THREE.WebGLRenderTarget(window.innerWidth, window.innerHeight, {
+      minFilter: THREE.LinearFilter,
+      magFilter: THREE.NearestFilter,
+      format: THREE.RGBAFormat
+    });
+    this.shaderMaterial = new THREE.ShaderMaterial({
+      uniforms: this.uniforms,
+      vertexShader: this.shader.vertexShader,
+      fragmentShader: this.shader.fragmentShader
+    });
+    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;
+    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);
+  }
+}
+exports.AfterimagePass = AfterimagePass;

package/dist/postprocessing/AfterimagePass.mjs

@@ -0,0 +1,68 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { 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();
+    __publicField(this, "shader");
+    __publicField(this, "uniforms");
+    __publicField(this, "textureComp");
+    __publicField(this, "textureOld");
+    __publicField(this, "shaderMaterial");
+    __publicField(this, "compFsQuad");
+    __publicField(this, "copyFsQuad");
+    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/dist/postprocessing/BloomPass.d.ts

@@ -0,0 +1,16 @@
+import { Pass, FullScreenQuad } from './Pass';
+import { ShaderMaterial, Vector2, WebGLRenderer, WebGLRenderTarget } from 'three';
+declare class BloomPass extends Pass {
+    renderTargetX: WebGLRenderTarget;
+    renderTargetY: WebGLRenderTarget;
+    materialCombine: ShaderMaterial;
+    materialConvolution: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    combineUniforms: any;
+    convolutionUniforms: any;
+    blurX: Vector2;
+    blurY: Vector2;
+    constructor(strength?: number, kernelSize?: number, sigma?: number, resolution?: number);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget, deltaTime: number, maskActive: boolean): void;
+}
+export { BloomPass };

package/dist/postprocessing/BloomPass.js

@@ -0,0 +1,109 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const Pass = require("./Pass.js");
+const THREE = require("three");
+const ConvolutionShader = require("../shaders/ConvolutionShader.js");
+class BloomPass extends Pass.Pass {
+  constructor(strength = 1, kernelSize = 25, sigma = 4, resolution = 256) {
+    super();
+    __publicField(this, "renderTargetX");
+    __publicField(this, "renderTargetY");
+    __publicField(this, "materialCombine");
+    __publicField(this, "materialConvolution");
+    __publicField(this, "fsQuad");
+    __publicField(this, "combineUniforms");
+    __publicField(this, "convolutionUniforms");
+    __publicField(this, "blurX", new THREE.Vector2(1953125e-9, 0));
+    __publicField(this, "blurY", new THREE.Vector2(0, 1953125e-9));
+    this.renderTargetX = new THREE.WebGLRenderTarget(resolution, resolution);
+    this.renderTargetX.texture.name = "BloomPass.x";
+    this.renderTargetY = new THREE.WebGLRenderTarget(resolution, resolution);
+    this.renderTargetY.texture.name = "BloomPass.y";
+    this.combineUniforms = THREE.UniformsUtils.clone(CombineShader.uniforms);
+    this.combineUniforms["strength"].value = strength;
+    this.materialCombine = new THREE.ShaderMaterial({
+      uniforms: this.combineUniforms,
+      vertexShader: CombineShader.vertexShader,
+      fragmentShader: CombineShader.fragmentShader,
+      blending: THREE.AdditiveBlending,
+      transparent: true
+    });
+    if (ConvolutionShader.ConvolutionShader === void 0)
+      console.error("BloomPass relies on ConvolutionShader");
+    const convolutionShader = ConvolutionShader.ConvolutionShader;
+    this.convolutionUniforms = THREE.UniformsUtils.clone(convolutionShader.uniforms);
+    this.convolutionUniforms["uImageIncrement"].value = this.blurX;
+    this.convolutionUniforms["cKernel"].value = ConvolutionShader.ConvolutionShader.buildKernel(sigma);
+    this.materialConvolution = new THREE.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 Pass.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: (
+    /* glsl */
+    `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+  }`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+  uniform float strength;
+  uniform sampler2D tDiffuse;
+  varying vec2 vUv;
+  void main() {
+    vec4 texel = texture2D( tDiffuse, vUv );
+    gl_FragColor = strength * texel;
+  }`
+  )
+};
+exports.BloomPass = BloomPass;

package/dist/postprocessing/BloomPass.mjs

@@ -0,0 +1,109 @@
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => {
+  __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+  return value;
+};
+import { 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();
+    __publicField(this, "renderTargetX");
+    __publicField(this, "renderTargetY");
+    __publicField(this, "materialCombine");
+    __publicField(this, "materialConvolution");
+    __publicField(this, "fsQuad");
+    __publicField(this, "combineUniforms");
+    __publicField(this, "convolutionUniforms");
+    __publicField(this, "blurX", new Vector2(1953125e-9, 0));
+    __publicField(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: (
+    /* glsl */
+    `
+  varying vec2 vUv;
+  void main() {
+    vUv = uv;
+    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
+  }`
+  ),
+  fragmentShader: (
+    /* glsl */
+    `
+  uniform float strength;
+  uniform sampler2D tDiffuse;
+  varying vec2 vUv;
+  void main() {
+    vec4 texel = texture2D( tDiffuse, vUv );
+    gl_FragColor = strength * texel;
+  }`
+  )
+};
+export {
+  BloomPass
+};

package/dist/postprocessing/BokehPass.d.ts

@@ -0,0 +1,26 @@
+/**
+ * Depth-of-field post-process with bokeh shader
+ */
+import { Pass, FullScreenQuad } from './Pass';
+import { MeshDepthMaterial, PerspectiveCamera, Scene, ShaderMaterial, WebGLRenderer, WebGLRenderTarget } from 'three';
+declare type BokehPassParams = {
+    focus?: number;
+    aspect?: number;
+    aperture?: number;
+    maxblur?: number;
+    width?: number;
+    height?: number;
+};
+declare class BokehPass extends Pass {
+    scene: Scene;
+    camera: PerspectiveCamera;
+    renderTargetDepth: WebGLRenderTarget;
+    materialDepth: MeshDepthMaterial;
+    materialBokeh: ShaderMaterial;
+    fsQuad: FullScreenQuad;
+    private _oldClearColor;
+    uniforms: any;
+    constructor(scene: Scene, camera: PerspectiveCamera, params: BokehPassParams);
+    render(renderer: WebGLRenderer, writeBuffer: WebGLRenderTarget, readBuffer: WebGLRenderTarget): void;
+}
+export { BokehPass };