three-stdlib 2.16.0 → 2.16.1

package/postprocessing/CubeTexturePass.mjs

@@ -1,49 +0,0 @@
-import { ShaderLib, Mesh, BoxGeometry, ShaderMaterial, UniformsUtils, BackSide, Scene, PerspectiveCamera } from "three";
-import { Pass } from "./Pass.mjs";
-var CubeTexturePass = function(camera, envMap, opacity) {
-  this.camera = camera;
-  this.needsSwap = false;
-  this.cubeShader = ShaderLib["cube"];
-  this.cubeMesh = new Mesh(
-    new BoxGeometry(10, 10, 10),
-    new ShaderMaterial({
-      uniforms: UniformsUtils.clone(this.cubeShader.uniforms),
-      vertexShader: this.cubeShader.vertexShader,
-      fragmentShader: this.cubeShader.fragmentShader,
-      depthTest: false,
-      depthWrite: false,
-      side: BackSide
-    })
-  );
-  Object.defineProperty(this.cubeMesh.material, "envMap", {
-    get: function() {
-      return this.uniforms.envMap.value;
-    }
-  });
-  this.envMap = envMap;
-  this.opacity = opacity !== void 0 ? opacity : 1;
-  this.cubeScene = new Scene();
-  this.cubeCamera = new PerspectiveCamera();
-  this.cubeScene.add(this.cubeMesh);
-};
-CubeTexturePass.prototype = Object.assign(Object.create(Pass.prototype), {
-  constructor: CubeTexturePass,
-  render: function(renderer, writeBuffer, readBuffer) {
-    var oldAutoClear = renderer.autoClear;
-    renderer.autoClear = false;
-    this.cubeCamera.projectionMatrix.copy(this.camera.projectionMatrix);
-    this.cubeCamera.quaternion.setFromRotationMatrix(this.camera.matrixWorld);
-    this.cubeMesh.material.uniforms.envMap.value = this.envMap;
-    this.cubeMesh.material.uniforms.flipEnvMap.value = this.envMap.isCubeTexture && this.envMap._needsFlipEnvMap ? -1 : 1;
-    this.cubeMesh.material.uniforms.opacity.value = this.opacity;
-    this.cubeMesh.material.transparent = this.opacity < 1;
-    renderer.setRenderTarget(this.renderToScreen ? null : readBuffer);
-    if (this.clear)
-      renderer.clear();
-    renderer.render(this.cubeScene, this.cubeCamera);
-    renderer.autoClear = oldAutoClear;
-  }
-});
-export {
-  CubeTexturePass
-};

package/postprocessing/DotScreenPass.mjs

@@ -1,40 +0,0 @@
-import { Pass, FullScreenQuad } from "./Pass.mjs";
-import { UniformsUtils, ShaderMaterial } from "three";
-import { DotScreenShader } from "../shaders/DotScreenShader.mjs";
-class DotScreenPass extends Pass {
-  constructor(center, angle, scale) {
-    super();
-    if (DotScreenShader === void 0)
-      console.error("THREE.DotScreenPass relies on THREE.DotScreenShader");
-    const shader = DotScreenShader;
-    this.uniforms = UniformsUtils.clone(shader.uniforms);
-    if (center !== void 0)
-      this.uniforms["center"].value.copy(center);
-    if (angle !== void 0)
-      this.uniforms["angle"].value = angle;
-    if (scale !== void 0)
-      this.uniforms["scale"].value = scale;
-    this.material = new ShaderMaterial({
-      uniforms: this.uniforms,
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader
-    });
-    this.fsQuad = new FullScreenQuad(this.material);
-  }
-  render(renderer, writeBuffer, readBuffer) {
-    this.uniforms["tDiffuse"].value = readBuffer.texture;
-    this.uniforms["tSize"].value.set(readBuffer.width, readBuffer.height);
-    if (this.renderToScreen) {
-      renderer.setRenderTarget(null);
-      this.fsQuad.render(renderer);
-    } else {
-      renderer.setRenderTarget(writeBuffer);
-      if (this.clear)
-        renderer.clear();
-      this.fsQuad.render(renderer);
-    }
-  }
-}
-export {
-  DotScreenPass
-};

package/postprocessing/EffectComposer.mjs

@@ -1,139 +0,0 @@
-import { LinearFilter, RGBAFormat, Vector2, WebGLRenderTarget, Clock } from "three";
-import { CopyShader } from "../shaders/CopyShader.mjs";
-import { ShaderPass } from "./ShaderPass.mjs";
-import { MaskPass, ClearMaskPass } from "./MaskPass.mjs";
-class EffectComposer {
-  constructor(renderer, renderTarget) {
-    this.passes = [];
-    this.renderer = renderer;
-    if (renderTarget === void 0) {
-      const parameters = {
-        minFilter: LinearFilter,
-        magFilter: LinearFilter,
-        format: RGBAFormat
-      };
-      const size = renderer.getSize(new Vector2());
-      this._pixelRatio = renderer.getPixelRatio();
-      this._width = size.width;
-      this._height = size.height;
-      renderTarget = new WebGLRenderTarget(
-        this._width * this._pixelRatio,
-        this._height * this._pixelRatio,
-        parameters
-      );
-      renderTarget.texture.name = "EffectComposer.rt1";
-    } else {
-      this._pixelRatio = 1;
-      this._width = renderTarget.width;
-      this._height = renderTarget.height;
-    }
-    this.renderTarget1 = renderTarget;
-    this.renderTarget2 = renderTarget.clone();
-    this.renderTarget2.texture.name = "EffectComposer.rt2";
-    this.writeBuffer = this.renderTarget1;
-    this.readBuffer = this.renderTarget2;
-    this.renderToScreen = true;
-    if (CopyShader === void 0) {
-      console.error("THREE.EffectComposer relies on CopyShader");
-    }
-    if (ShaderPass === void 0) {
-      console.error("THREE.EffectComposer relies on ShaderPass");
-    }
-    this.copyPass = new ShaderPass(CopyShader);
-    this.clock = new Clock();
-  }
-  swapBuffers() {
-    const tmp = this.readBuffer;
-    this.readBuffer = this.writeBuffer;
-    this.writeBuffer = tmp;
-  }
-  addPass(pass) {
-    this.passes.push(pass);
-    pass.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
-  }
-  insertPass(pass, index) {
-    this.passes.splice(index, 0, pass);
-    pass.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
-  }
-  removePass(pass) {
-    const index = this.passes.indexOf(pass);
-    if (index !== -1) {
-      this.passes.splice(index, 1);
-    }
-  }
-  isLastEnabledPass(passIndex) {
-    for (let i = passIndex + 1; i < this.passes.length; i++) {
-      if (this.passes[i].enabled) {
-        return false;
-      }
-    }
-    return true;
-  }
-  render(deltaTime) {
-    if (deltaTime === void 0) {
-      deltaTime = this.clock.getDelta();
-    }
-    const currentRenderTarget = this.renderer.getRenderTarget();
-    let maskActive = false;
-    const il = this.passes.length;
-    for (let i = 0; i < il; i++) {
-      const pass = this.passes[i];
-      if (pass.enabled === false)
-        continue;
-      pass.renderToScreen = this.renderToScreen && this.isLastEnabledPass(i);
-      pass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime, maskActive);
-      if (pass.needsSwap) {
-        if (maskActive) {
-          const context = this.renderer.getContext();
-          const stencil = this.renderer.state.buffers.stencil;
-          stencil.setFunc(context.NOTEQUAL, 1, 4294967295);
-          this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime);
-          stencil.setFunc(context.EQUAL, 1, 4294967295);
-        }
-        this.swapBuffers();
-      }
-      if (MaskPass !== void 0) {
-        if (pass instanceof MaskPass) {
-          maskActive = true;
-        } else if (pass instanceof ClearMaskPass) {
-          maskActive = false;
-        }
-      }
-    }
-    this.renderer.setRenderTarget(currentRenderTarget);
-  }
-  reset(renderTarget) {
-    if (renderTarget === void 0) {
-      const size = this.renderer.getSize(new Vector2());
-      this._pixelRatio = this.renderer.getPixelRatio();
-      this._width = size.width;
-      this._height = size.height;
-      renderTarget = this.renderTarget1.clone();
-      renderTarget.setSize(this._width * this._pixelRatio, this._height * this._pixelRatio);
-    }
-    this.renderTarget1.dispose();
-    this.renderTarget2.dispose();
-    this.renderTarget1 = renderTarget;
-    this.renderTarget2 = renderTarget.clone();
-    this.writeBuffer = this.renderTarget1;
-    this.readBuffer = this.renderTarget2;
-  }
-  setSize(width, height) {
-    this._width = width;
-    this._height = height;
-    const effectiveWidth = this._width * this._pixelRatio;
-    const effectiveHeight = this._height * this._pixelRatio;
-    this.renderTarget1.setSize(effectiveWidth, effectiveHeight);
-    this.renderTarget2.setSize(effectiveWidth, effectiveHeight);
-    for (let i = 0; i < this.passes.length; i++) {
-      this.passes[i].setSize(effectiveWidth, effectiveHeight);
-    }
-  }
-  setPixelRatio(pixelRatio) {
-    this._pixelRatio = pixelRatio;
-    this.setSize(this._width, this._height);
-  }
-}
-export {
-  EffectComposer
-};

package/postprocessing/FilmPass.mjs

@@ -1,42 +0,0 @@
-import { Pass, FullScreenQuad } from "./Pass.mjs";
-import { UniformsUtils, ShaderMaterial } from "three";
-import { FilmShader } from "../shaders/FilmShader.mjs";
-class FilmPass extends Pass {
-  constructor(noiseIntensity, scanlinesIntensity, scanlinesCount, grayscale) {
-    super();
-    if (FilmShader === void 0)
-      console.error("THREE.FilmPass relies on FilmShader");
-    const shader = FilmShader;
-    this.uniforms = UniformsUtils.clone(shader.uniforms);
-    this.material = new ShaderMaterial({
-      uniforms: this.uniforms,
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader
-    });
-    if (grayscale !== void 0)
-      this.uniforms.grayscale.value = grayscale;
-    if (noiseIntensity !== void 0)
-      this.uniforms.nIntensity.value = noiseIntensity;
-    if (scanlinesIntensity !== void 0)
-      this.uniforms.sIntensity.value = scanlinesIntensity;
-    if (scanlinesCount !== void 0)
-      this.uniforms.sCount.value = scanlinesCount;
-    this.fsQuad = new FullScreenQuad(this.material);
-  }
-  render(renderer, writeBuffer, readBuffer, deltaTime, maskActive) {
-    this.uniforms["tDiffuse"].value = readBuffer.texture;
-    this.uniforms["time"].value += deltaTime;
-    if (this.renderToScreen) {
-      renderer.setRenderTarget(null);
-      this.fsQuad.render(renderer);
-    } else {
-      renderer.setRenderTarget(writeBuffer);
-      if (this.clear)
-        renderer.clear();
-      this.fsQuad.render(renderer);
-    }
-  }
-}
-export {
-  FilmPass
-};

package/postprocessing/GlitchPass.mjs

@@ -1,75 +0,0 @@
-import { Pass, FullScreenQuad } from "./Pass.mjs";
-import { UniformsUtils, ShaderMaterial, LuminanceFormat, MathUtils, DataTexture, RedFormat, FloatType } from "three";
-import { DigitalGlitch } from "../shaders/DigitalGlitch.mjs";
-class GlitchPass extends Pass {
-  constructor(dt_size = 64) {
-    super();
-    if (DigitalGlitch === void 0)
-      console.error("THREE.GlitchPass relies on DigitalGlitch");
-    const shader = DigitalGlitch;
-    this.uniforms = UniformsUtils.clone(shader.uniforms);
-    this.uniforms["tDisp"].value = this.generateHeightmap(dt_size);
-    this.material = new ShaderMaterial({
-      uniforms: this.uniforms,
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader
-    });
-    this.fsQuad = new FullScreenQuad(this.material);
-    this.goWild = false;
-    this.curF = 0;
-    this.generateTrigger();
-  }
-  render(renderer, writeBuffer, readBuffer) {
-    if (renderer.capabilities.isWebGL2 === false)
-      this.uniforms["tDisp"].value.format = LuminanceFormat;
-    this.uniforms["tDiffuse"].value = readBuffer.texture;
-    this.uniforms["seed"].value = Math.random();
-    this.uniforms["byp"].value = 0;
-    if (this.curF % this.randX == 0 || this.goWild == true) {
-      this.uniforms["amount"].value = Math.random() / 30;
-      this.uniforms["angle"].value = MathUtils.randFloat(-Math.PI, Math.PI);
-      this.uniforms["seed_x"].value = MathUtils.randFloat(-1, 1);
-      this.uniforms["seed_y"].value = MathUtils.randFloat(-1, 1);
-      this.uniforms["distortion_x"].value = MathUtils.randFloat(0, 1);
-      this.uniforms["distortion_y"].value = MathUtils.randFloat(0, 1);
-      this.curF = 0;
-      this.generateTrigger();
-    } else if (this.curF % this.randX < this.randX / 5) {
-      this.uniforms["amount"].value = Math.random() / 90;
-      this.uniforms["angle"].value = MathUtils.randFloat(-Math.PI, Math.PI);
-      this.uniforms["distortion_x"].value = MathUtils.randFloat(0, 1);
-      this.uniforms["distortion_y"].value = MathUtils.randFloat(0, 1);
-      this.uniforms["seed_x"].value = MathUtils.randFloat(-0.3, 0.3);
-      this.uniforms["seed_y"].value = MathUtils.randFloat(-0.3, 0.3);
-    } else if (this.goWild == false) {
-      this.uniforms["byp"].value = 1;
-    }
-    this.curF++;
-    if (this.renderToScreen) {
-      renderer.setRenderTarget(null);
-      this.fsQuad.render(renderer);
-    } else {
-      renderer.setRenderTarget(writeBuffer);
-      if (this.clear)
-        renderer.clear();
-      this.fsQuad.render(renderer);
-    }
-  }
-  generateTrigger() {
-    this.randX = MathUtils.randInt(120, 240);
-  }
-  generateHeightmap(dt_size) {
-    const data_arr = new Float32Array(dt_size * dt_size);
-    const length = dt_size * dt_size;
-    for (let i = 0; i < length; i++) {
-      const val = MathUtils.randFloat(0, 1);
-      data_arr[i] = val;
-    }
-    const texture = new DataTexture(data_arr, dt_size, dt_size, RedFormat, FloatType);
-    texture.needsUpdate = true;
-    return texture;
-  }
-}
-export {
-  GlitchPass
-};

package/postprocessing/HalftonePass.mjs

@@ -1,44 +0,0 @@
-import { Pass, FullScreenQuad } from "./Pass.mjs";
-import { UniformsUtils, ShaderMaterial } from "three";
-import { HalftoneShader } from "../shaders/HalftoneShader.mjs";
-class HalftonePass extends Pass {
-  constructor(width, height, params) {
-    super();
-    if (HalftoneShader === void 0) {
-      console.error("THREE.HalftonePass requires HalftoneShader");
-    }
-    this.uniforms = UniformsUtils.clone(HalftoneShader.uniforms);
-    this.material = new ShaderMaterial({
-      uniforms: this.uniforms,
-      fragmentShader: HalftoneShader.fragmentShader,
-      vertexShader: HalftoneShader.vertexShader
-    });
-    this.uniforms.width.value = width;
-    this.uniforms.height.value = height;
-    for (const key in params) {
-      if (params.hasOwnProperty(key) && this.uniforms.hasOwnProperty(key)) {
-        this.uniforms[key].value = params[key];
-      }
-    }
-    this.fsQuad = new FullScreenQuad(this.material);
-  }
-  render(renderer, writeBuffer, readBuffer) {
-    this.material.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);
-    }
-  }
-  setSize(width, height) {
-    this.uniforms.width.value = width;
-    this.uniforms.height.value = height;
-  }
-}
-export {
-  HalftonePass
-};

package/postprocessing/LUTPass.mjs

@@ -1,136 +0,0 @@
-import { ShaderPass } from "./ShaderPass.mjs";
-const LUTShader = {
-  defines: {
-    USE_3DTEXTURE: 1
-  },
-  uniforms: {
-    lut3d: { value: null },
-    lut: { value: null },
-    lutSize: { value: 0 },
-    tDiffuse: { value: null },
-    intensity: { value: 1 }
-  },
-  vertexShader: `
-
-		varying vec2 vUv;
-
-		void main() {
-
-			vUv = uv;
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}
-
-	`,
-  fragmentShader: `
-		precision highp sampler3D;
-
-		uniform float lutSize;
-		#if USE_3DTEXTURE
-		uniform sampler3D lut3d;
-		#else
-		uniform sampler2D lut;
-
-		vec3 lutLookup( sampler2D tex, float size, vec3 rgb ) {
-
-			float sliceHeight = 1.0 / size;
-			float yPixelHeight = 1.0 / ( size * size );
-
-			// Get the slices on either side of the sample
-			float slice = rgb.b * size;
-			float interp = fract( slice );
-			float slice0 = slice - interp;
-			float centeredInterp = interp - 0.5;
-
-			float slice1 = slice0 + sign( centeredInterp );
-
-			// Pull y sample in by half a pixel in each direction to avoid color
-			// bleeding from adjacent slices.
-			float greenOffset = clamp( rgb.g * sliceHeight, yPixelHeight * 0.5, sliceHeight - yPixelHeight * 0.5 );
-
-			vec2 uv0 = vec2(
-				rgb.r,
-				slice0 * sliceHeight + greenOffset
-			);
-			vec2 uv1 = vec2(
-				rgb.r,
-				slice1 * sliceHeight + greenOffset
-			);
-
-			vec3 sample0 = texture2D( tex, uv0 ).rgb;
-			vec3 sample1 = texture2D( tex, uv1 ).rgb;
-
-			return mix( sample0, sample1, abs( centeredInterp ) );
-
-		}
-		#endif
-
-		varying vec2 vUv;
-		uniform float intensity;
-		uniform sampler2D tDiffuse;
-		void main() {
-
-			vec4 val = texture2D( tDiffuse, vUv );
-			vec4 lutVal;
-
-			// pull the sample in by half a pixel so the sample begins
-			// at the center of the edge pixels.
-			float pixelWidth = 1.0 / lutSize;
-			float halfPixelWidth = 0.5 / lutSize;
-			vec3 uvw = vec3( halfPixelWidth ) + val.rgb * ( 1.0 - pixelWidth );
-
-			#if USE_3DTEXTURE
-
-			lutVal = vec4( texture( lut3d, uvw ).rgb, val.a );
-
-			#else
-
-			lutVal = vec4( lutLookup( lut, lutSize, uvw ), val.a );
-
-			#endif
-
-			gl_FragColor = vec4( mix( val, lutVal, intensity ) );
-
-		}
-
-	`
-};
-class LUTPass extends ShaderPass {
-  set lut(v) {
-    const material = this.material;
-    if (v !== this.lut) {
-      material.uniforms.lut3d.value = null;
-      material.uniforms.lut.value = null;
-      if (v) {
-        const is3dTextureDefine = v.isDataTexture3D ? 1 : 0;
-        if (is3dTextureDefine !== material.defines.USE_3DTEXTURE) {
-          material.defines.USE_3DTEXTURE = is3dTextureDefine;
-          material.needsUpdate = true;
-        }
-        material.uniforms.lutSize.value = v.image.width;
-        if (v.isDataTexture3D) {
-          material.uniforms.lut3d.value = v;
-        } else {
-          material.uniforms.lut.value = v;
-        }
-      }
-    }
-  }
-  get lut() {
-    return this.material.uniforms.lut.value || this.material.uniforms.lut3d.value;
-  }
-  set intensity(v) {
-    this.material.uniforms.intensity.value = v;
-  }
-  get intensity() {
-    return this.material.uniforms.intensity.value;
-  }
-  constructor(options = {}) {
-    super(LUTShader);
-    this.lut = options.lut || null;
-    this.intensity = "intensity" in options ? options.intensity : 1;
-  }
-}
-export {
-  LUTPass
-};

package/postprocessing/MaskPass.mjs

@@ -1,60 +0,0 @@
-import { Pass } from "./Pass.mjs";
-class MaskPass extends Pass {
-  constructor(scene, camera) {
-    super();
-    this.scene = scene;
-    this.camera = camera;
-    this.clear = true;
-    this.needsSwap = false;
-    this.inverse = false;
-  }
-  render(renderer, writeBuffer, readBuffer) {
-    const context = renderer.getContext();
-    const state = renderer.state;
-    state.buffers.color.setMask(false);
-    state.buffers.depth.setMask(false);
-    state.buffers.color.setLocked(true);
-    state.buffers.depth.setLocked(true);
-    let writeValue, clearValue;
-    if (this.inverse) {
-      writeValue = 0;
-      clearValue = 1;
-    } else {
-      writeValue = 1;
-      clearValue = 0;
-    }
-    state.buffers.stencil.setTest(true);
-    state.buffers.stencil.setOp(context.REPLACE, context.REPLACE, context.REPLACE);
-    state.buffers.stencil.setFunc(context.ALWAYS, writeValue, 4294967295);
-    state.buffers.stencil.setClear(clearValue);
-    state.buffers.stencil.setLocked(true);
-    renderer.setRenderTarget(readBuffer);
-    if (this.clear)
-      renderer.clear();
-    renderer.render(this.scene, this.camera);
-    renderer.setRenderTarget(writeBuffer);
-    if (this.clear)
-      renderer.clear();
-    renderer.render(this.scene, this.camera);
-    state.buffers.color.setLocked(false);
-    state.buffers.depth.setLocked(false);
-    state.buffers.stencil.setLocked(false);
-    state.buffers.stencil.setFunc(context.EQUAL, 1, 4294967295);
-    state.buffers.stencil.setOp(context.KEEP, context.KEEP, context.KEEP);
-    state.buffers.stencil.setLocked(true);
-  }
-}
-class ClearMaskPass extends Pass {
-  constructor() {
-    super();
-    this.needsSwap = false;
-  }
-  render(renderer) {
-    renderer.state.buffers.stencil.setLocked(false);
-    renderer.state.buffers.stencil.setTest(false);
-  }
-}
-export {
-  ClearMaskPass,
-  MaskPass
-};