three-stdlib 2.22.7 → 2.22.8

package/dist/postprocessing/TAARenderPass.js

@@ -0,0 +1,89 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const SSAARenderPass = require("./SSAARenderPass.js");
+var TAARenderPass = function(scene, camera, clearColor, clearAlpha) {
+  if (SSAARenderPass.SSAARenderPass === void 0) {
+    console.error("THREE.TAARenderPass relies on SSAARenderPass");
+  }
+  SSAARenderPass.SSAARenderPass.call(this, scene, camera, clearColor, clearAlpha);
+  this.sampleLevel = 0;
+  this.accumulate = false;
+};
+TAARenderPass.JitterVectors = SSAARenderPass.SSAARenderPass.JitterVectors;
+TAARenderPass.prototype = Object.assign(Object.create(SSAARenderPass.SSAARenderPass.prototype), {
+  constructor: TAARenderPass,
+  render: function(renderer, writeBuffer, readBuffer, deltaTime) {
+    if (!this.accumulate) {
+      SSAARenderPass.SSAARenderPass.prototype.render.call(this, renderer, writeBuffer, readBuffer, deltaTime);
+      this.accumulateIndex = -1;
+      return;
+    }
+    var jitterOffsets = TAARenderPass.JitterVectors[5];
+    if (!this.sampleRenderTarget) {
+      this.sampleRenderTarget = new THREE.WebGLRenderTarget(readBuffer.width, readBuffer.height, this.params);
+      this.sampleRenderTarget.texture.name = "TAARenderPass.sample";
+    }
+    if (!this.holdRenderTarget) {
+      this.holdRenderTarget = new THREE.WebGLRenderTarget(readBuffer.width, readBuffer.height, this.params);
+      this.holdRenderTarget.texture.name = "TAARenderPass.hold";
+    }
+    if (this.accumulate && this.accumulateIndex === -1) {
+      SSAARenderPass.SSAARenderPass.prototype.render.call(this, renderer, this.holdRenderTarget, readBuffer, deltaTime);
+      this.accumulateIndex = 0;
+    }
+    var autoClear = renderer.autoClear;
+    renderer.autoClear = false;
+    var sampleWeight = 1 / jitterOffsets.length;
+    if (this.accumulateIndex >= 0 && this.accumulateIndex < jitterOffsets.length) {
+      this.copyUniforms["opacity"].value = sampleWeight;
+      this.copyUniforms["tDiffuse"].value = writeBuffer.texture;
+      var numSamplesPerFrame = Math.pow(2, this.sampleLevel);
+      for (let i = 0; i < numSamplesPerFrame; i++) {
+        var j = this.accumulateIndex;
+        var jitterOffset = jitterOffsets[j];
+        if (this.camera.setViewOffset) {
+          this.camera.setViewOffset(
+            readBuffer.width,
+            readBuffer.height,
+            jitterOffset[0] * 0.0625,
+            jitterOffset[1] * 0.0625,
+            // 0.0625 = 1 / 16
+            readBuffer.width,
+            readBuffer.height
+          );
+        }
+        renderer.setRenderTarget(writeBuffer);
+        renderer.clear();
+        renderer.render(this.scene, this.camera);
+        renderer.setRenderTarget(this.sampleRenderTarget);
+        if (this.accumulateIndex === 0)
+          renderer.clear();
+        this.fsQuad.render(renderer);
+        this.accumulateIndex++;
+        if (this.accumulateIndex >= jitterOffsets.length)
+          break;
+      }
+      if (this.camera.clearViewOffset)
+        this.camera.clearViewOffset();
+    }
+    var accumulationWeight = this.accumulateIndex * sampleWeight;
+    if (accumulationWeight > 0) {
+      this.copyUniforms["opacity"].value = 1;
+      this.copyUniforms["tDiffuse"].value = this.sampleRenderTarget.texture;
+      renderer.setRenderTarget(writeBuffer);
+      renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+    if (accumulationWeight < 1) {
+      this.copyUniforms["opacity"].value = 1 - accumulationWeight;
+      this.copyUniforms["tDiffuse"].value = this.holdRenderTarget.texture;
+      renderer.setRenderTarget(writeBuffer);
+      if (accumulationWeight === 0)
+        renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+    renderer.autoClear = autoClear;
+  }
+});
+exports.TAARenderPass = TAARenderPass;

package/dist/postprocessing/TAARenderPass.mjs

@@ -0,0 +1,89 @@
+import { WebGLRenderTarget } from "three";
+import { SSAARenderPass } from "./SSAARenderPass.mjs";
+var TAARenderPass = function(scene, camera, clearColor, clearAlpha) {
+  if (SSAARenderPass === void 0) {
+    console.error("THREE.TAARenderPass relies on SSAARenderPass");
+  }
+  SSAARenderPass.call(this, scene, camera, clearColor, clearAlpha);
+  this.sampleLevel = 0;
+  this.accumulate = false;
+};
+TAARenderPass.JitterVectors = SSAARenderPass.JitterVectors;
+TAARenderPass.prototype = Object.assign(Object.create(SSAARenderPass.prototype), {
+  constructor: TAARenderPass,
+  render: function(renderer, writeBuffer, readBuffer, deltaTime) {
+    if (!this.accumulate) {
+      SSAARenderPass.prototype.render.call(this, renderer, writeBuffer, readBuffer, deltaTime);
+      this.accumulateIndex = -1;
+      return;
+    }
+    var jitterOffsets = TAARenderPass.JitterVectors[5];
+    if (!this.sampleRenderTarget) {
+      this.sampleRenderTarget = new WebGLRenderTarget(readBuffer.width, readBuffer.height, this.params);
+      this.sampleRenderTarget.texture.name = "TAARenderPass.sample";
+    }
+    if (!this.holdRenderTarget) {
+      this.holdRenderTarget = new WebGLRenderTarget(readBuffer.width, readBuffer.height, this.params);
+      this.holdRenderTarget.texture.name = "TAARenderPass.hold";
+    }
+    if (this.accumulate && this.accumulateIndex === -1) {
+      SSAARenderPass.prototype.render.call(this, renderer, this.holdRenderTarget, readBuffer, deltaTime);
+      this.accumulateIndex = 0;
+    }
+    var autoClear = renderer.autoClear;
+    renderer.autoClear = false;
+    var sampleWeight = 1 / jitterOffsets.length;
+    if (this.accumulateIndex >= 0 && this.accumulateIndex < jitterOffsets.length) {
+      this.copyUniforms["opacity"].value = sampleWeight;
+      this.copyUniforms["tDiffuse"].value = writeBuffer.texture;
+      var numSamplesPerFrame = Math.pow(2, this.sampleLevel);
+      for (let i = 0; i < numSamplesPerFrame; i++) {
+        var j = this.accumulateIndex;
+        var jitterOffset = jitterOffsets[j];
+        if (this.camera.setViewOffset) {
+          this.camera.setViewOffset(
+            readBuffer.width,
+            readBuffer.height,
+            jitterOffset[0] * 0.0625,
+            jitterOffset[1] * 0.0625,
+            // 0.0625 = 1 / 16
+            readBuffer.width,
+            readBuffer.height
+          );
+        }
+        renderer.setRenderTarget(writeBuffer);
+        renderer.clear();
+        renderer.render(this.scene, this.camera);
+        renderer.setRenderTarget(this.sampleRenderTarget);
+        if (this.accumulateIndex === 0)
+          renderer.clear();
+        this.fsQuad.render(renderer);
+        this.accumulateIndex++;
+        if (this.accumulateIndex >= jitterOffsets.length)
+          break;
+      }
+      if (this.camera.clearViewOffset)
+        this.camera.clearViewOffset();
+    }
+    var accumulationWeight = this.accumulateIndex * sampleWeight;
+    if (accumulationWeight > 0) {
+      this.copyUniforms["opacity"].value = 1;
+      this.copyUniforms["tDiffuse"].value = this.sampleRenderTarget.texture;
+      renderer.setRenderTarget(writeBuffer);
+      renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+    if (accumulationWeight < 1) {
+      this.copyUniforms["opacity"].value = 1 - accumulationWeight;
+      this.copyUniforms["tDiffuse"].value = this.holdRenderTarget.texture;
+      renderer.setRenderTarget(writeBuffer);
+      if (accumulationWeight === 0)
+        renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+    renderer.autoClear = autoClear;
+  }
+});
+export {
+  TAARenderPass
+};

package/dist/postprocessing/TexturePass.d.ts

@@ -0,0 +1,12 @@
+import { Texture, ShaderMaterial } from 'three'
+
+import { Pass } from './Pass'
+
+export class TexturePass extends Pass {
+  constructor(map: Texture, opacity?: number)
+  map: Texture
+  opacity: number
+  uniforms: object
+  material: ShaderMaterial
+  fsQuad: object
+}

package/dist/postprocessing/TexturePass.js

@@ -0,0 +1,39 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const Pass = require("./Pass.js");
+const CopyShader = require("../shaders/CopyShader.js");
+var TexturePass = function(map, opacity) {
+  if (CopyShader.CopyShader === void 0)
+    console.error("THREE.TexturePass relies on CopyShader");
+  var shader = CopyShader.CopyShader;
+  this.map = map;
+  this.opacity = opacity !== void 0 ? opacity : 1;
+  this.uniforms = THREE.UniformsUtils.clone(shader.uniforms);
+  this.material = new THREE.ShaderMaterial({
+    uniforms: this.uniforms,
+    vertexShader: shader.vertexShader,
+    fragmentShader: shader.fragmentShader,
+    depthTest: false,
+    depthWrite: false
+  });
+  this.needsSwap = false;
+  this.fsQuad = new Pass.FullScreenQuad(null);
+};
+TexturePass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
+  constructor: TexturePass,
+  render: function(renderer, writeBuffer, readBuffer) {
+    var oldAutoClear = renderer.autoClear;
+    renderer.autoClear = false;
+    this.fsQuad.material = this.material;
+    this.uniforms["opacity"].value = this.opacity;
+    this.uniforms["tDiffuse"].value = this.map;
+    this.material.transparent = this.opacity < 1;
+    renderer.setRenderTarget(this.renderToScreen ? null : readBuffer);
+    if (this.clear)
+      renderer.clear();
+    this.fsQuad.render(renderer);
+    renderer.autoClear = oldAutoClear;
+  }
+});
+exports.TexturePass = TexturePass;

package/dist/postprocessing/TexturePass.mjs

@@ -0,0 +1,39 @@
+import { UniformsUtils, ShaderMaterial } from "three";
+import { FullScreenQuad, Pass } from "./Pass.mjs";
+import { CopyShader } from "../shaders/CopyShader.mjs";
+var TexturePass = function(map, opacity) {
+  if (CopyShader === void 0)
+    console.error("THREE.TexturePass relies on CopyShader");
+  var shader = CopyShader;
+  this.map = map;
+  this.opacity = opacity !== void 0 ? opacity : 1;
+  this.uniforms = UniformsUtils.clone(shader.uniforms);
+  this.material = new ShaderMaterial({
+    uniforms: this.uniforms,
+    vertexShader: shader.vertexShader,
+    fragmentShader: shader.fragmentShader,
+    depthTest: false,
+    depthWrite: false
+  });
+  this.needsSwap = false;
+  this.fsQuad = new FullScreenQuad(null);
+};
+TexturePass.prototype = Object.assign(Object.create(Pass.prototype), {
+  constructor: TexturePass,
+  render: function(renderer, writeBuffer, readBuffer) {
+    var oldAutoClear = renderer.autoClear;
+    renderer.autoClear = false;
+    this.fsQuad.material = this.material;
+    this.uniforms["opacity"].value = this.opacity;
+    this.uniforms["tDiffuse"].value = this.map;
+    this.material.transparent = this.opacity < 1;
+    renderer.setRenderTarget(this.renderToScreen ? null : readBuffer);
+    if (this.clear)
+      renderer.clear();
+    this.fsQuad.render(renderer);
+    renderer.autoClear = oldAutoClear;
+  }
+});
+export {
+  TexturePass
+};

package/dist/postprocessing/UnrealBloomPass.d.ts

@@ -0,0 +1,31 @@
+import { Color, MeshBasicMaterial, ShaderMaterial, Vector2, Vector3, WebGLRenderTarget } from 'three'
+
+import { Pass } from './Pass'
+
+export class UnrealBloomPass extends Pass {
+  constructor(resolution: Vector2, strength: number, radius: number, threshold: number)
+  resolution: Vector2
+  strength: number
+  radius: number
+  threshold: number
+  clearColor: Color
+  renderTargetsHorizontal: WebGLRenderTarget[]
+  renderTargetsVertical: WebGLRenderTarget[]
+  nMips: number
+  renderTargetBright: WebGLRenderTarget
+  highPassUniforms: object
+  materialHighPassFilter: ShaderMaterial
+  separableBlurMaterials: ShaderMaterial[]
+  compositeMaterial: ShaderMaterial
+  bloomTintColors: Vector3[]
+  copyUniforms: object
+  materialCopy: ShaderMaterial
+  oldClearColor: Color
+  oldClearAlpha: number
+  basic: MeshBasicMaterial
+  fsQuad: object
+
+  dispose(): void
+  getSeperableBlurMaterial(): ShaderMaterial
+  getCompositeMaterial(): ShaderMaterial
+}

package/dist/postprocessing/UnrealBloomPass.js

@@ -0,0 +1,220 @@
+"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 LuminosityHighPassShader = require("../shaders/LuminosityHighPassShader.js");
+var UnrealBloomPass = function(resolution, strength, radius, threshold) {
+  this.strength = strength !== void 0 ? strength : 1;
+  this.radius = radius;
+  this.threshold = threshold;
+  this.resolution = resolution !== void 0 ? new THREE.Vector2(resolution.x, resolution.y) : new THREE.Vector2(256, 256);
+  this.clearColor = new THREE.Color(0, 0, 0);
+  var pars = {
+    minFilter: THREE.LinearFilter,
+    magFilter: THREE.LinearFilter,
+    format: THREE.RGBAFormat
+  };
+  this.renderTargetsHorizontal = [];
+  this.renderTargetsVertical = [];
+  this.nMips = 5;
+  var resx = Math.round(this.resolution.x / 2);
+  var resy = Math.round(this.resolution.y / 2);
+  this.renderTargetBright = new THREE.WebGLRenderTarget(resx, resy, pars);
+  this.renderTargetBright.texture.name = "UnrealBloomPass.bright";
+  this.renderTargetBright.texture.generateMipmaps = false;
+  for (let i = 0; i < this.nMips; i++) {
+    var renderTargetHorizonal = new THREE.WebGLRenderTarget(resx, resy, pars);
+    renderTargetHorizonal.texture.name = "UnrealBloomPass.h" + i;
+    renderTargetHorizonal.texture.generateMipmaps = false;
+    this.renderTargetsHorizontal.push(renderTargetHorizonal);
+    var renderTargetVertical = new THREE.WebGLRenderTarget(resx, resy, pars);
+    renderTargetVertical.texture.name = "UnrealBloomPass.v" + i;
+    renderTargetVertical.texture.generateMipmaps = false;
+    this.renderTargetsVertical.push(renderTargetVertical);
+    resx = Math.round(resx / 2);
+    resy = Math.round(resy / 2);
+  }
+  if (LuminosityHighPassShader.LuminosityHighPassShader === void 0)
+    console.error("THREE.UnrealBloomPass relies on LuminosityHighPassShader");
+  var highPassShader = LuminosityHighPassShader.LuminosityHighPassShader;
+  this.highPassUniforms = THREE.UniformsUtils.clone(highPassShader.uniforms);
+  this.highPassUniforms["luminosityThreshold"].value = threshold;
+  this.highPassUniforms["smoothWidth"].value = 0.01;
+  this.materialHighPassFilter = new THREE.ShaderMaterial({
+    uniforms: this.highPassUniforms,
+    vertexShader: highPassShader.vertexShader,
+    fragmentShader: highPassShader.fragmentShader,
+    defines: {}
+  });
+  this.separableBlurMaterials = [];
+  var kernelSizeArray = [3, 5, 7, 9, 11];
+  var resx = Math.round(this.resolution.x / 2);
+  var resy = Math.round(this.resolution.y / 2);
+  for (let i = 0; i < this.nMips; i++) {
+    this.separableBlurMaterials.push(this.getSeperableBlurMaterial(kernelSizeArray[i]));
+    this.separableBlurMaterials[i].uniforms["texSize"].value = new THREE.Vector2(resx, resy);
+    resx = Math.round(resx / 2);
+    resy = Math.round(resy / 2);
+  }
+  this.compositeMaterial = this.getCompositeMaterial(this.nMips);
+  this.compositeMaterial.uniforms["blurTexture1"].value = this.renderTargetsVertical[0].texture;
+  this.compositeMaterial.uniforms["blurTexture2"].value = this.renderTargetsVertical[1].texture;
+  this.compositeMaterial.uniforms["blurTexture3"].value = this.renderTargetsVertical[2].texture;
+  this.compositeMaterial.uniforms["blurTexture4"].value = this.renderTargetsVertical[3].texture;
+  this.compositeMaterial.uniforms["blurTexture5"].value = this.renderTargetsVertical[4].texture;
+  this.compositeMaterial.uniforms["bloomStrength"].value = strength;
+  this.compositeMaterial.uniforms["bloomRadius"].value = 0.1;
+  this.compositeMaterial.needsUpdate = true;
+  var bloomFactors = [1, 0.8, 0.6, 0.4, 0.2];
+  this.compositeMaterial.uniforms["bloomFactors"].value = bloomFactors;
+  this.bloomTintColors = [
+    new THREE.Vector3(1, 1, 1),
+    new THREE.Vector3(1, 1, 1),
+    new THREE.Vector3(1, 1, 1),
+    new THREE.Vector3(1, 1, 1),
+    new THREE.Vector3(1, 1, 1)
+  ];
+  this.compositeMaterial.uniforms["bloomTintColors"].value = this.bloomTintColors;
+  if (CopyShader.CopyShader === void 0) {
+    console.error("THREE.UnrealBloomPass relies on CopyShader");
+  }
+  var copyShader = CopyShader.CopyShader;
+  this.copyUniforms = THREE.UniformsUtils.clone(copyShader.uniforms);
+  this.copyUniforms["opacity"].value = 1;
+  this.materialCopy = new THREE.ShaderMaterial({
+    uniforms: this.copyUniforms,
+    vertexShader: copyShader.vertexShader,
+    fragmentShader: copyShader.fragmentShader,
+    blending: THREE.AdditiveBlending,
+    depthTest: false,
+    depthWrite: false,
+    transparent: true
+  });
+  this.enabled = true;
+  this.needsSwap = false;
+  this._oldClearColor = new THREE.Color();
+  this.oldClearAlpha = 1;
+  this.basic = new THREE.MeshBasicMaterial();
+  this.fsQuad = new Pass.FullScreenQuad(null);
+};
+UnrealBloomPass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
+  constructor: UnrealBloomPass,
+  dispose: function() {
+    for (let i = 0; i < this.renderTargetsHorizontal.length; i++) {
+      this.renderTargetsHorizontal[i].dispose();
+    }
+    for (let i = 0; i < this.renderTargetsVertical.length; i++) {
+      this.renderTargetsVertical[i].dispose();
+    }
+    this.renderTargetBright.dispose();
+  },
+  setSize: function(width, height) {
+    var resx = Math.round(width / 2);
+    var resy = Math.round(height / 2);
+    this.renderTargetBright.setSize(resx, resy);
+    for (let i = 0; i < this.nMips; i++) {
+      this.renderTargetsHorizontal[i].setSize(resx, resy);
+      this.renderTargetsVertical[i].setSize(resx, resy);
+      this.separableBlurMaterials[i].uniforms["texSize"].value = new THREE.Vector2(resx, resy);
+      resx = Math.round(resx / 2);
+      resy = Math.round(resy / 2);
+    }
+  },
+  render: function(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
+    renderer.getClearColor(this._oldClearColor);
+    this.oldClearAlpha = renderer.getClearAlpha();
+    var oldAutoClear = renderer.autoClear;
+    renderer.autoClear = false;
+    renderer.setClearColor(this.clearColor, 0);
+    if (maskActive)
+      renderer.state.buffers.stencil.setTest(false);
+    if (this.renderToScreen) {
+      this.fsQuad.material = this.basic;
+      this.basic.map = readBuffer.texture;
+      renderer.setRenderTarget(null);
+      renderer.clear();
+      this.fsQuad.render(renderer);
+    }
+    this.highPassUniforms["tDiffuse"].value = readBuffer.texture;
+    this.highPassUniforms["luminosityThreshold"].value = this.threshold;
+    this.fsQuad.material = this.materialHighPassFilter;
+    renderer.setRenderTarget(this.renderTargetBright);
+    renderer.clear();
+    this.fsQuad.render(renderer);
+    var inputRenderTarget = this.renderTargetBright;
+    for (let i = 0; i < this.nMips; i++) {
+      this.fsQuad.material = this.separableBlurMaterials[i];
+      this.separableBlurMaterials[i].uniforms["colorTexture"].value = inputRenderTarget.texture;
+      this.separableBlurMaterials[i].uniforms["direction"].value = UnrealBloomPass.BlurDirectionX;
+      renderer.setRenderTarget(this.renderTargetsHorizontal[i]);
+      renderer.clear();
+      this.fsQuad.render(renderer);
+      this.separableBlurMaterials[i].uniforms["colorTexture"].value = this.renderTargetsHorizontal[i].texture;
+      this.separableBlurMaterials[i].uniforms["direction"].value = UnrealBloomPass.BlurDirectionY;
+      renderer.setRenderTarget(this.renderTargetsVertical[i]);
+      renderer.clear();
+      this.fsQuad.render(renderer);
+      inputRenderTarget = this.renderTargetsVertical[i];
+    }
+    this.fsQuad.material = this.compositeMaterial;
+    this.compositeMaterial.uniforms["bloomStrength"].value = this.strength;
+    this.compositeMaterial.uniforms["bloomRadius"].value = this.radius;
+    this.compositeMaterial.uniforms["bloomTintColors"].value = this.bloomTintColors;
+    renderer.setRenderTarget(this.renderTargetsHorizontal[0]);
+    renderer.clear();
+    this.fsQuad.render(renderer);
+    this.fsQuad.material = this.materialCopy;
+    this.copyUniforms["tDiffuse"].value = this.renderTargetsHorizontal[0].texture;
+    if (maskActive)
+      renderer.state.buffers.stencil.setTest(true);
+    if (this.renderToScreen) {
+      renderer.setRenderTarget(null);
+      this.fsQuad.render(renderer);
+    } else {
+      renderer.setRenderTarget(readBuffer);
+      this.fsQuad.render(renderer);
+    }
+    renderer.setClearColor(this._oldClearColor, this.oldClearAlpha);
+    renderer.autoClear = oldAutoClear;
+  },
+  getSeperableBlurMaterial: function(kernelRadius) {
+    return new THREE.ShaderMaterial({
+      defines: {
+        KERNEL_RADIUS: kernelRadius,
+        SIGMA: kernelRadius
+      },
+      uniforms: {
+        colorTexture: { value: null },
+        texSize: { value: new THREE.Vector2(0.5, 0.5) },
+        direction: { value: new THREE.Vector2(0.5, 0.5) }
+      },
+      vertexShader: "varying vec2 vUv;\nvoid main() {\n	vUv = uv;\n	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",
+      fragmentShader: "#include <common>varying vec2 vUv;\nuniform sampler2D colorTexture;\nuniform vec2 texSize;uniform vec2 direction;\nfloat gaussianPdf(in float x, in float sigma) {	return 0.39894 * exp( -0.5 * x * x/( sigma * sigma))/sigma;}void main() {\n	vec2 invSize = 1.0 / texSize;	float fSigma = float(SIGMA);	float weightSum = gaussianPdf(0.0, fSigma);	vec3 diffuseSum = texture2D( colorTexture, vUv).rgb * weightSum;	for( int i = 1; i < KERNEL_RADIUS; i ++ ) {		float x = float(i);		float w = gaussianPdf(x, fSigma);		vec2 uvOffset = direction * invSize * x;		vec3 sample1 = texture2D( colorTexture, vUv + uvOffset).rgb;		vec3 sample2 = texture2D( colorTexture, vUv - uvOffset).rgb;		diffuseSum += (sample1 + sample2) * w;		weightSum += 2.0 * w;	}	gl_FragColor = vec4(diffuseSum/weightSum, 1.0);\n}"
+    });
+  },
+  getCompositeMaterial: function(nMips) {
+    return new THREE.ShaderMaterial({
+      defines: {
+        NUM_MIPS: nMips
+      },
+      uniforms: {
+        blurTexture1: { value: null },
+        blurTexture2: { value: null },
+        blurTexture3: { value: null },
+        blurTexture4: { value: null },
+        blurTexture5: { value: null },
+        dirtTexture: { value: null },
+        bloomStrength: { value: 1 },
+        bloomFactors: { value: null },
+        bloomTintColors: { value: null },
+        bloomRadius: { value: 0 }
+      },
+      vertexShader: "varying vec2 vUv;\nvoid main() {\n	vUv = uv;\n	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );\n}",
+      fragmentShader: "varying vec2 vUv;uniform sampler2D blurTexture1;uniform sampler2D blurTexture2;uniform sampler2D blurTexture3;uniform sampler2D blurTexture4;uniform sampler2D blurTexture5;uniform sampler2D dirtTexture;uniform float bloomStrength;uniform float bloomRadius;uniform float bloomFactors[NUM_MIPS];uniform vec3 bloomTintColors[NUM_MIPS];float lerpBloomFactor(const in float factor) { 	float mirrorFactor = 1.2 - factor;	return mix(factor, mirrorFactor, bloomRadius);}void main() {	gl_FragColor = bloomStrength * ( lerpBloomFactor(bloomFactors[0]) * vec4(bloomTintColors[0], 1.0) * texture2D(blurTexture1, vUv) + 									 lerpBloomFactor(bloomFactors[1]) * vec4(bloomTintColors[1], 1.0) * texture2D(blurTexture2, vUv) + 									 lerpBloomFactor(bloomFactors[2]) * vec4(bloomTintColors[2], 1.0) * texture2D(blurTexture3, vUv) + 									 lerpBloomFactor(bloomFactors[3]) * vec4(bloomTintColors[3], 1.0) * texture2D(blurTexture4, vUv) + 									 lerpBloomFactor(bloomFactors[4]) * vec4(bloomTintColors[4], 1.0) * texture2D(blurTexture5, vUv) );}"
+    });
+  }
+});
+UnrealBloomPass.BlurDirectionX = new THREE.Vector2(1, 0);
+UnrealBloomPass.BlurDirectionY = new THREE.Vector2(0, 1);
+exports.UnrealBloomPass = UnrealBloomPass;