three-stdlib 2.15.1 → 2.15.2

package/postprocessing/CubeTexturePass.js

@@ -1,35 +1,36 @@
-import { ShaderLib, Mesh, BoxGeometry, ShaderMaterial, UniformsUtils, BackSide, Scene, PerspectiveCamera } from 'three';
-import { Pass } from './Pass.js';
-
-var CubeTexturePass = function (camera, envMap, opacity) {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const Pass = require("./Pass.js");
+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 () {
+  this.cubeShader = THREE.ShaderLib["cube"];
+  this.cubeMesh = new THREE.Mesh(
+    new THREE.BoxGeometry(10, 10, 10),
+    new THREE.ShaderMaterial({
+      uniforms: THREE.UniformsUtils.clone(this.cubeShader.uniforms),
+      vertexShader: this.cubeShader.vertexShader,
+      fragmentShader: this.cubeShader.fragmentShader,
+      depthTest: false,
+      depthWrite: false,
+      side: THREE.BackSide
+    })
+  );
+  Object.defineProperty(this.cubeMesh.material, "envMap", {
+    get: function() {
       return this.uniforms.envMap.value;
     }
   });
   this.envMap = envMap;
-  this.opacity = opacity !== undefined ? opacity : 1.0;
-  this.cubeScene = new Scene();
-  this.cubeCamera = new PerspectiveCamera();
+  this.opacity = opacity !== void 0 ? opacity : 1;
+  this.cubeScene = new THREE.Scene();
+  this.cubeCamera = new THREE.PerspectiveCamera();
   this.cubeScene.add(this.cubeMesh);
 };
-
-CubeTexturePass.prototype = Object.assign(Object.create(Pass.prototype), {
+CubeTexturePass.prototype = Object.assign(Object.create(Pass.Pass.prototype), {
   constructor: CubeTexturePass,
-  render: function (renderer, writeBuffer, readBuffer
-  /*, deltaTime, maskActive*/
-  ) {
+  render: function(renderer, writeBuffer, readBuffer) {
     var oldAutoClear = renderer.autoClear;
     renderer.autoClear = false;
     this.cubeCamera.projectionMatrix.copy(this.camera.projectionMatrix);
@@ -37,12 +38,12 @@ CubeTexturePass.prototype = Object.assign(Object.create(Pass.prototype), {
     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.0;
+    this.cubeMesh.material.transparent = this.opacity < 1;
     renderer.setRenderTarget(this.renderToScreen ? null : readBuffer);
-    if (this.clear) renderer.clear();
+    if (this.clear)
+      renderer.clear();
     renderer.render(this.cubeScene, this.cubeCamera);
     renderer.autoClear = oldAutoClear;
   }
 });
-
-export { CubeTexturePass };
+exports.CubeTexturePass = CubeTexturePass;

package/postprocessing/CubeTexturePass.mjs

@@ -0,0 +1,49 @@
+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.js

@@ -1,48 +1,40 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import { Pass, FullScreenQuad } from './Pass.js';
-import { UniformsUtils, ShaderMaterial } from 'three';
-import { DotScreenShader } from '../shaders/DotScreenShader.js';
-
-class DotScreenPass extends Pass {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const Pass = require("./Pass.js");
+const THREE = require("three");
+const DotScreenShader = require("../shaders/DotScreenShader.js");
+class DotScreenPass extends Pass.Pass {
   constructor(center, angle, scale) {
     super();
-
-    _defineProperty(this, "material", void 0);
-
-    _defineProperty(this, "fsQuad", void 0);
-
-    _defineProperty(this, "uniforms", void 0);
-
-    if (DotScreenShader === undefined) console.error('THREE.DotScreenPass relies on THREE.DotScreenShader');
-    const shader = DotScreenShader;
-    this.uniforms = UniformsUtils.clone(shader.uniforms);
-    if (center !== undefined) this.uniforms['center'].value.copy(center);
-    if (angle !== undefined) this.uniforms['angle'].value = angle;
-    if (scale !== undefined) this.uniforms['scale'].value = scale;
-    this.material = new ShaderMaterial({
+    if (DotScreenShader.DotScreenShader === void 0)
+      console.error("THREE.DotScreenPass relies on THREE.DotScreenShader");
+    const shader = DotScreenShader.DotScreenShader;
+    this.uniforms = THREE.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 THREE.ShaderMaterial({
       uniforms: this.uniforms,
       vertexShader: shader.vertexShader,
       fragmentShader: shader.fragmentShader
     });
-    this.fsQuad = new FullScreenQuad(this.material);
+    this.fsQuad = new Pass.FullScreenQuad(this.material);
   }
-
-  render(renderer, writeBuffer, readBuffer
-  /*, deltaTime, maskActive */
-  ) {
-    this.uniforms['tDiffuse'].value = readBuffer.texture;
-    this.uniforms['tSize'].value.set(readBuffer.width, readBuffer.height);
-
+  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();
+      if (this.clear)
+        renderer.clear();
       this.fsQuad.render(renderer);
     }
   }
-
 }
-
-export { DotScreenPass };
+exports.DotScreenPass = DotScreenPass;

package/postprocessing/DotScreenPass.mjs

@@ -0,0 +1,40 @@
+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.js

@@ -1,160 +1,118 @@
-import _defineProperty from '@babel/runtime/helpers/esm/defineProperty';
-import { Vector2, WebGLRenderTarget, Clock, LinearFilter, RGBAFormat } from 'three';
-import { CopyShader } from '../shaders/CopyShader.js';
-import { ShaderPass } from './ShaderPass.js';
-import { MaskPass, ClearMaskPass } from './MaskPass.js';
-
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const CopyShader = require("../shaders/CopyShader.js");
+const ShaderPass = require("./ShaderPass.js");
+const MaskPass = require("./MaskPass.js");
 class EffectComposer {
   constructor(renderer, renderTarget) {
-    _defineProperty(this, "renderer", void 0);
-
-    _defineProperty(this, "_pixelRatio", void 0);
-
-    _defineProperty(this, "_width", void 0);
-
-    _defineProperty(this, "_height", void 0);
-
-    _defineProperty(this, "renderTarget1", void 0);
-
-    _defineProperty(this, "renderTarget2", void 0);
-
-    _defineProperty(this, "writeBuffer", void 0);
-
-    _defineProperty(this, "readBuffer", void 0);
-
-    _defineProperty(this, "renderToScreen", void 0);
-
-    _defineProperty(this, "passes", []);
-
-    _defineProperty(this, "copyPass", void 0);
-
-    _defineProperty(this, "clock", void 0);
-
+    this.passes = [];
     this.renderer = renderer;
-
-    if (renderTarget === undefined) {
+    if (renderTarget === void 0) {
       const parameters = {
-        minFilter: LinearFilter,
-        magFilter: LinearFilter,
-        format: RGBAFormat
+        minFilter: THREE.LinearFilter,
+        magFilter: THREE.LinearFilter,
+        format: THREE.RGBAFormat
       };
-      const size = renderer.getSize(new Vector2());
+      const size = renderer.getSize(new THREE.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';
+      renderTarget = new THREE.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.renderTarget2.texture.name = "EffectComposer.rt2";
     this.writeBuffer = this.renderTarget1;
     this.readBuffer = this.renderTarget2;
-    this.renderToScreen = true; // dependencies
-
-    if (CopyShader === undefined) {
-      console.error('THREE.EffectComposer relies on CopyShader');
+    this.renderToScreen = true;
+    if (CopyShader.CopyShader === void 0) {
+      console.error("THREE.EffectComposer relies on CopyShader");
     }
-
-    if (ShaderPass === undefined) {
-      console.error('THREE.EffectComposer relies on ShaderPass');
+    if (ShaderPass.ShaderPass === void 0) {
+      console.error("THREE.EffectComposer relies on ShaderPass");
     }
-
-    this.copyPass = new ShaderPass(CopyShader);
-    this.clock = new Clock();
+    this.copyPass = new ShaderPass.ShaderPass(CopyShader.CopyShader);
+    this.clock = new THREE.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) {
-    // deltaTime value is in seconds
-    if (deltaTime === undefined) {
+    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;
+      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; //context.stencilFunc( context.NOTEQUAL, 1, 0xffffffff );
-
-          stencil.setFunc(context.NOTEQUAL, 1, 0xffffffff);
-          this.copyPass.render(this.renderer, this.writeBuffer, this.readBuffer, deltaTime); //context.stencilFunc( context.EQUAL, 1, 0xffffffff );
-
-          stencil.setFunc(context.EQUAL, 1, 0xffffffff);
+          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 !== undefined) {
-        if (pass instanceof MaskPass) {
+      if (MaskPass.MaskPass !== void 0) {
+        if (pass instanceof MaskPass.MaskPass) {
           maskActive = true;
-        } else if (pass instanceof ClearMaskPass) {
+        } else if (pass instanceof MaskPass.ClearMaskPass) {
           maskActive = false;
         }
       }
     }
-
     this.renderer.setRenderTarget(currentRenderTarget);
   }
-
   reset(renderTarget) {
-    if (renderTarget === undefined) {
-      const size = this.renderer.getSize(new Vector2());
+    if (renderTarget === void 0) {
+      const size = this.renderer.getSize(new THREE.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;
@@ -162,7 +120,6 @@ class EffectComposer {
     this.writeBuffer = this.renderTarget1;
     this.readBuffer = this.renderTarget2;
   }
-
   setSize(width, height) {
     this._width = width;
     this._height = height;
@@ -170,17 +127,13 @@ class EffectComposer {
     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 };
+exports.EffectComposer = EffectComposer;

package/postprocessing/EffectComposer.mjs

@@ -0,0 +1,139 @@
+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
+};