three-stdlib 2.16.0 → 2.16.2

package/postprocessing/AdaptiveToneMappingPass.js

@@ -1,92 +1,91 @@
-"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;
+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;
   this.needsInit = true;
-  this.adaptive = adaptive !== void 0 ? !!adaptive : true;
+  this.adaptive = adaptive !== undefined ? !!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({
+  if (CopyShader === undefined) 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: THREE.NoBlending,
+    blending: 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
+  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
   });
   this.adaptLuminanceShader = {
     defines: {
-      MIP_LEVEL_1X1: (Math.log(this.resolution) / Math.log(2)).toFixed(1)
+      MIP_LEVEL_1X1: (Math.log(this.resolution) / Math.log(2.0)).toFixed(1)
     },
     uniforms: {
-      lastLum: { value: null },
-      currentLum: { value: null },
-      minLuminance: { value: 0.01 },
-      delta: { value: 0.016 },
-      tau: { value: 1 }
+      lastLum: {
+        value: null
+      },
+      currentLum: {
+        value: null
+      },
+      minLuminance: {
+        value: 0.01
+      },
+      delta: {
+        value: 0.016
+      },
+      tau: {
+        value: 1.0
+      }
     },
-    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")
+    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),
+  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: THREE.NoBlending
+    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
+  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
   });
-  this.fsQuad = new Pass.FullScreenQuad(null);
+  this.fsQuad = new FullScreenQuad(null);
 };
-AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
+
+AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.prototype), {
   constructor: AdaptiveToneMappingPass,
-  render: function(renderer, writeBuffer, readBuffer, deltaTime) {
+  render: function (renderer, writeBuffer, readBuffer, deltaTime
+  /*, maskActive*/
+  ) {
     if (this.needsInit) {
       this.reset(renderer);
       this.luminanceRT.texture.type = readBuffer.texture.type;
@@ -94,128 +93,155 @@ AdaptiveToneMappingPass.prototype = Object.assign(Object.create(Pass.Pass.protot
       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);
+      this.fsQuad.render(renderer); //Use the new luminance values, the previous luminance and the frame delta to
+      //adapt the luminance over time.
+
       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.render(renderer); //Copy the new adapted luminance value so that it can be used by the next frame.
+
       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() {
+  reset: function () {
+    // render targets
     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";
+      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';
     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;
+    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;
     pars.generateMipmaps = true;
-    this.currentLuminanceRT = new THREE.WebGLRenderTarget(this.resolution, this.resolution, pars);
-    this.currentLuminanceRT.texture.name = "AdaptiveToneMappingPass.cl";
+    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.defines['ADAPTED_LUMINANCE'] = '';
       this.materialToneMap.uniforms.luminanceMap.value = this.luminanceRT.texture;
-    }
-    this.fsQuad.material = new THREE.MeshBasicMaterial({ color: 7829367 });
+    } //Put something in the adaptive luminance texture so that the scene can render initially
+
+
+    this.fsQuad.material = new MeshBasicMaterial({
+      color: 0x777777
+    });
     this.materialLuminance.needsUpdate = true;
     this.materialAdaptiveLum.needsUpdate = true;
-    this.materialToneMap.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 );
   },
-  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();
     }
   }
 });
-exports.AdaptiveToneMappingPass = AdaptiveToneMappingPass;
+
+export { AdaptiveToneMappingPass };

package/postprocessing/AfterimagePass.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/defineProperty"),t=require("three"),r=require("./Pass.cjs.js"),i=require("../shaders/AfterimageShader.cjs.js");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var a=s(e);class d extends r.Pass{constructor(e=.96,s=i.AfterimageShader){super(),a.default(this,"shader",void 0),a.default(this,"uniforms",void 0),a.default(this,"textureComp",void 0),a.default(this,"textureOld",void 0),a.default(this,"shaderMaterial",void 0),a.default(this,"compFsQuad",void 0),a.default(this,"copyFsQuad",void 0),this.shader=s,this.uniforms=t.UniformsUtils.clone(s.uniforms),this.uniforms.damp.value=e,this.textureComp=new t.WebGLRenderTarget(window.innerWidth,window.innerHeight,{minFilter:t.LinearFilter,magFilter:t.NearestFilter,format:t.RGBAFormat}),this.textureOld=new t.WebGLRenderTarget(window.innerWidth,window.innerHeight,{minFilter:t.LinearFilter,magFilter:t.NearestFilter,format:t.RGBAFormat}),this.shaderMaterial=new t.ShaderMaterial({uniforms:this.uniforms,vertexShader:this.shader.vertexShader,fragmentShader:this.shader.fragmentShader}),this.compFsQuad=new r.FullScreenQuad(this.shaderMaterial);let d=new t.MeshBasicMaterial;this.copyFsQuad=new r.FullScreenQuad(d)}render(e,t,r){this.uniforms.tOld.value=this.textureOld.texture,this.uniforms.tNew.value=r.texture,e.setRenderTarget(this.textureComp),this.compFsQuad.render(e),this.copyFsQuad.material.map=this.textureComp.texture,this.renderToScreen?(e.setRenderTarget(null),this.copyFsQuad.render(e)):(e.setRenderTarget(t),this.clear&&e.clear(),this.copyFsQuad.render(e));let i=this.textureOld;this.textureOld=this.textureComp,this.textureComp=i}setSize(e,t){this.textureComp.setSize(e,t),this.textureOld.setSize(e,t)}}exports.AfterimagePass=d;

package/postprocessing/AfterimagePass.js

@@ -1,55 +1,76 @@
-"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) {
+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) {
     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 = 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.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 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.shaderMaterial = new THREE.ShaderMaterial({
+    this.shaderMaterial = new 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);
+    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;
+    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;
+    this.textureComp = temp; // Now textureOld contains the latest image, ready for the next frame.
   }
+
   setSize(width, height) {
     this.textureComp.setSize(width, height);
     this.textureOld.setSize(width, height);
   }
+
 }
-exports.AfterimagePass = AfterimagePass;
+
+export { AfterimagePass };

package/postprocessing/BloomPass.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/defineProperty"),t=require("./Pass.cjs.js"),r=require("three"),n=require("../shaders/ConvolutionShader.cjs.js");function i(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var s=i(e);class o extends t.Pass{constructor(e=1,i=25,o=4,l=256){super(),s.default(this,"renderTargetX",void 0),s.default(this,"renderTargetY",void 0),s.default(this,"materialCombine",void 0),s.default(this,"materialConvolution",void 0),s.default(this,"fsQuad",void 0),s.default(this,"combineUniforms",void 0),s.default(this,"convolutionUniforms",void 0),s.default(this,"blurX",new r.Vector2(.001953125,0)),s.default(this,"blurY",new r.Vector2(0,.001953125)),this.renderTargetX=new r.WebGLRenderTarget(l,l),this.renderTargetX.texture.name="BloomPass.x",this.renderTargetY=new r.WebGLRenderTarget(l,l),this.renderTargetY.texture.name="BloomPass.y",this.combineUniforms=r.UniformsUtils.clone(a.uniforms),this.combineUniforms.strength.value=e,this.materialCombine=new r.ShaderMaterial({uniforms:this.combineUniforms,vertexShader:a.vertexShader,fragmentShader:a.fragmentShader,blending:r.AdditiveBlending,transparent:!0}),void 0===n.ConvolutionShader&&console.error("BloomPass relies on ConvolutionShader");const u=n.ConvolutionShader;this.convolutionUniforms=r.UniformsUtils.clone(u.uniforms),this.convolutionUniforms.uImageIncrement.value=this.blurX,this.convolutionUniforms.cKernel.value=n.ConvolutionShader.buildKernel(o),this.materialConvolution=new r.ShaderMaterial({uniforms:this.convolutionUniforms,vertexShader:u.vertexShader,fragmentShader:u.fragmentShader,defines:{KERNEL_SIZE_FLOAT:i.toFixed(1),KERNEL_SIZE_INT:i.toFixed(0)}}),this.needsSwap=!1,this.fsQuad=new t.FullScreenQuad(this.materialConvolution)}render(e,t,r,n,i){i&&e.state.buffers.stencil.setTest(!1),this.fsQuad.material=this.materialConvolution,this.convolutionUniforms.tDiffuse.value=r.texture,this.convolutionUniforms.uImageIncrement.value=this.blurX,e.setRenderTarget(this.renderTargetX),e.clear(),this.fsQuad.render(e),this.convolutionUniforms.tDiffuse.value=this.renderTargetX.texture,this.convolutionUniforms.uImageIncrement.value=this.blurY,e.setRenderTarget(this.renderTargetY),e.clear(),this.fsQuad.render(e),this.fsQuad.material=this.materialCombine,this.combineUniforms.tDiffuse.value=this.renderTargetY.texture,i&&e.state.buffers.stencil.setTest(!0),e.setRenderTarget(r),this.clear&&e.clear(),this.fsQuad.render(e)}}const a={uniforms:{tDiffuse:{value:null},strength:{value:1}},vertexShader:"\n  varying vec2 vUv;\n  void main() {\n    vUv = uv;\n    gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n  }",fragmentShader:"\n  uniform float strength;\n  uniform sampler2D tDiffuse;\n  varying vec2 vUv;\n  void main() {\n    vec4 texel = texture2D( tDiffuse, vUv );\n    gl_FragColor = strength * texel;\n  }"};exports.BloomPass=o;

package/postprocessing/BloomPass.js

@@ -1,33 +1,51 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const Pass = require("./Pass.js");
-const THREE = require("three");
-const ConvolutionShader = require("../shaders/ConvolutionShader.js");
-class BloomPass extends Pass.Pass {
+import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
+import { Pass, FullScreenQuad } from './Pass.js';
+import { Vector2, WebGLRenderTarget, UniformsUtils, ShaderMaterial, AdditiveBlending } from 'three';
+import { ConvolutionShader } from '../shaders/ConvolutionShader.js';
+
+class BloomPass extends Pass {
   constructor(strength = 1, kernelSize = 25, sigma = 4, resolution = 256) {
-    super();
-    this.blurX = new THREE.Vector2(1953125e-9, 0);
-    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({
+    super(); // render targets
+
+    _defineProperty(this, "renderTargetX", void 0);
+
+    _defineProperty(this, "renderTargetY", void 0);
+
+    _defineProperty(this, "materialCombine", void 0);
+
+    _defineProperty(this, "materialConvolution", void 0);
+
+    _defineProperty(this, "fsQuad", void 0);
+
+    _defineProperty(this, "combineUniforms", void 0);
+
+    _defineProperty(this, "convolutionUniforms", void 0);
+
+    _defineProperty(this, "blurX", new Vector2(0.001953125, 0.0));
+
+    _defineProperty(this, "blurY", new Vector2(0.0, 0.001953125));
+
+    this.renderTargetX = new WebGLRenderTarget(resolution, resolution);
+    this.renderTargetX.texture.name = 'BloomPass.x';
+    this.renderTargetY = new WebGLRenderTarget(resolution, resolution);
+    this.renderTargetY.texture.name = 'BloomPass.y'; // combine material
+
+    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: THREE.AdditiveBlending,
+      blending: 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({
+    }); // convolution material
+
+    if (ConvolutionShader === undefined) 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,
@@ -37,48 +55,55 @@ class BloomPass extends Pass.Pass {
       }
     });
     this.needsSwap = false;
-    this.fsQuad = new Pass.FullScreenQuad(this.materialConvolution);
+    this.fsQuad = new FullScreenQuad(this.materialConvolution);
   }
+
   render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
-    if (maskActive)
-      renderer.state.buffers.stencil.setTest(false);
+    if (maskActive) renderer.state.buffers.stencil.setTest(false); // Render quad with blured scene into texture (convolution pass 1)
+
     this.fsQuad.material = this.materialConvolution;
-    this.convolutionUniforms["tDiffuse"].value = readBuffer.texture;
-    this.convolutionUniforms["uImageIncrement"].value = this.blurX;
+    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;
+    this.fsQuad.render(renderer); // Render quad with blured scene into texture (convolution pass 2)
+
+    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.render(renderer); // Render original scene with superimposed blur to texture
+
     this.fsQuad.material = this.materialCombine;
-    this.combineUniforms["tDiffuse"].value = this.renderTargetY.texture;
-    if (maskActive)
-      renderer.state.buffers.stencil.setTest(true);
+    this.combineUniforms['tDiffuse'].value = this.renderTargetY.texture;
+    if (maskActive) renderer.state.buffers.stencil.setTest(true);
     renderer.setRenderTarget(readBuffer);
-    if (this.clear)
-      renderer.clear();
+    if (this.clear) renderer.clear();
     this.fsQuad.render(renderer);
   }
+
 }
+
 const CombineShader = {
   uniforms: {
     tDiffuse: {
       value: null
     },
     strength: {
-      value: 1
+      value: 1.0
     }
   },
-  vertexShader: `
+  vertexShader:
+  /* glsl */
+  `
   varying vec2 vUv;
   void main() {
     vUv = uv;
     gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
   }`,
-  fragmentShader: `
+  fragmentShader:
+  /* glsl */
+  `
   uniform float strength;
   uniform sampler2D tDiffuse;
   varying vec2 vUv;
@@ -87,4 +112,5 @@ const CombineShader = {
     gl_FragColor = strength * texel;
   }`
 };
-exports.BloomPass = BloomPass;
+
+export { BloomPass };

package/postprocessing/BokehPass.cjs.js

@@ -0,0 +1 @@
+"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("@babel/runtime/helpers/defineProperty"),r=require("./Pass.cjs.js"),t=require("three"),a=require("../shaders/BokehShader.cjs.js");function s(e){return e&&"object"==typeof e&&"default"in e?e:{default:e}}var i=s(e);class l extends r.Pass{constructor(e,s,l){super(),i.default(this,"scene",void 0),i.default(this,"camera",void 0),i.default(this,"renderTargetDepth",void 0),i.default(this,"materialDepth",void 0),i.default(this,"materialBokeh",void 0),i.default(this,"fsQuad",void 0),i.default(this,"_oldClearColor",void 0),i.default(this,"uniforms",void 0),this.scene=e,this.camera=s;const h=void 0!==l.focus?l.focus:1,o=void 0!==l.aspect?l.aspect:s.aspect,n=void 0!==l.aperture?l.aperture:.025,d=void 0!==l.maxblur?l.maxblur:1,u=l.width||window.innerWidth||1,c=l.height||window.innerHeight||1;this.renderTargetDepth=new t.WebGLRenderTarget(u,c,{minFilter:t.NearestFilter,magFilter:t.NearestFilter}),this.renderTargetDepth.texture.name="BokehPass.depth",this.materialDepth=new t.MeshDepthMaterial,this.materialDepth.depthPacking=t.RGBADepthPacking,this.materialDepth.blending=t.NoBlending,void 0===a.BokehShader&&console.error("BokehPass relies on BokehShader");const f=a.BokehShader,p=t.UniformsUtils.clone(f.uniforms);p.tDepth.value=this.renderTargetDepth.texture,p.focus.value=h,p.aspect.value=o,p.aperture.value=n,p.maxblur.value=d,p.nearClip.value=s.near,p.farClip.value=s.far,this.materialBokeh=new t.ShaderMaterial({defines:Object.assign({},f.defines),uniforms:p,vertexShader:f.vertexShader,fragmentShader:f.fragmentShader}),this.uniforms=p,this.needsSwap=!1,this.fsQuad=new r.FullScreenQuad(this.materialBokeh),this._oldClearColor=new t.Color}render(e,r,t){this.scene.overrideMaterial=this.materialDepth,e.getClearColor(this._oldClearColor);const a=e.getClearAlpha(),s=e.autoClear;e.autoClear=!1,e.setClearColor(16777215),e.setClearAlpha(1),e.setRenderTarget(this.renderTargetDepth),e.clear(),e.render(this.scene,this.camera),this.uniforms.tColor.value=t.texture,this.uniforms.nearClip.value=this.camera.near,this.uniforms.farClip.value=this.camera.far,this.renderToScreen?(e.setRenderTarget(null),this.fsQuad.render(e)):(e.setRenderTarget(r),e.clear(),this.fsQuad.render(e)),this.scene.overrideMaterial=null,e.setClearColor(this._oldClearColor),e.setClearAlpha(a),e.autoClear=s}}exports.BokehPass=l;