three-stdlib 2.22.7 → 2.22.9

package/dist/effects/ParallaxBarrierEffect.mjs

@@ -0,0 +1,64 @@
+import { OrthographicCamera, Scene, StereoCamera, LinearFilter, NearestFilter, RGBAFormat, WebGLRenderTarget, ShaderMaterial, Mesh, PlaneGeometry } from "three";
+const ParallaxBarrierEffect = function(renderer) {
+  const _camera = new OrthographicCamera(-1, 1, 1, -1, 0, 1);
+  const _scene = new Scene();
+  const _stereo = new StereoCamera();
+  const _params = {
+    minFilter: LinearFilter,
+    magFilter: NearestFilter,
+    format: RGBAFormat
+  };
+  const _renderTargetL = new WebGLRenderTarget(512, 512, _params);
+  const _renderTargetR = new WebGLRenderTarget(512, 512, _params);
+  const _material = new ShaderMaterial({
+    uniforms: {
+      mapLeft: { value: _renderTargetL.texture },
+      mapRight: { value: _renderTargetR.texture }
+    },
+    vertexShader: [
+      "varying vec2 vUv;",
+      "void main() {",
+      "	vUv = vec2( uv.x, uv.y );",
+      "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
+      "}"
+    ].join("\n"),
+    fragmentShader: [
+      "uniform sampler2D mapLeft;",
+      "uniform sampler2D mapRight;",
+      "varying vec2 vUv;",
+      "void main() {",
+      "	vec2 uv = vUv;",
+      "	if ( ( mod( gl_FragCoord.y, 2.0 ) ) > 1.00 ) {",
+      "		gl_FragColor = texture2D( mapLeft, uv );",
+      "	} else {",
+      "		gl_FragColor = texture2D( mapRight, uv );",
+      "	}",
+      "}"
+    ].join("\n")
+  });
+  const mesh = new Mesh(new PlaneGeometry(2, 2), _material);
+  _scene.add(mesh);
+  this.setSize = (width, height) => {
+    renderer.setSize(width, height);
+    const pixelRatio = renderer.getPixelRatio();
+    _renderTargetL.setSize(width * pixelRatio, height * pixelRatio);
+    _renderTargetR.setSize(width * pixelRatio, height * pixelRatio);
+  };
+  this.render = (scene, camera) => {
+    scene.updateMatrixWorld();
+    if (camera.parent === null)
+      camera.updateMatrixWorld();
+    _stereo.update(camera);
+    renderer.setRenderTarget(_renderTargetL);
+    renderer.clear();
+    renderer.render(scene, _stereo.cameraL);
+    renderer.setRenderTarget(_renderTargetR);
+    renderer.clear();
+    renderer.render(scene, _stereo.cameraR);
+    renderer.setRenderTarget(null);
+    renderer.render(_scene, _camera);
+  };
+};
+export {
+  ParallaxBarrierEffect
+};

package/dist/effects/PeppersGhostEffect.d.ts

@@ -0,0 +1,10 @@
+import { Camera, Scene, WebGLRenderer } from 'three'
+
+export class PeppersGhostEffect {
+  constructor(renderer: WebGLRenderer)
+  cameraDistance: number
+  reflectFromAbove: boolean
+
+  render(scene: Scene, camera: Camera): void
+  setSize(width: number, height: number): void
+}

package/dist/effects/PeppersGhostEffect.js

@@ -0,0 +1,85 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const PeppersGhostEffect = function(renderer) {
+  const scope = this;
+  scope.cameraDistance = 15;
+  scope.reflectFromAbove = false;
+  let _halfWidth, _width, _height;
+  const _cameraF = new THREE.PerspectiveCamera();
+  const _cameraB = new THREE.PerspectiveCamera();
+  const _cameraL = new THREE.PerspectiveCamera();
+  const _cameraR = new THREE.PerspectiveCamera();
+  const _position = new THREE.Vector3();
+  const _quaternion = new THREE.Quaternion();
+  const _scale = new THREE.Vector3();
+  renderer.autoClear = false;
+  this.setSize = (width, height) => {
+    _halfWidth = width / 2;
+    if (width < height) {
+      _width = width / 3;
+      _height = width / 3;
+    } else {
+      _width = height / 3;
+      _height = height / 3;
+    }
+    renderer.setSize(width, height);
+  };
+  this.render = (scene, camera) => {
+    scene.updateMatrixWorld();
+    if (camera.parent === null)
+      camera.updateMatrixWorld();
+    camera.matrixWorld.decompose(_position, _quaternion, _scale);
+    _cameraF.position.copy(_position);
+    _cameraF.quaternion.copy(_quaternion);
+    _cameraF.translateZ(scope.cameraDistance);
+    _cameraF.lookAt(scene.position);
+    _cameraB.position.copy(_position);
+    _cameraB.quaternion.copy(_quaternion);
+    _cameraB.translateZ(-scope.cameraDistance);
+    _cameraB.lookAt(scene.position);
+    _cameraB.rotation.z += 180 * (Math.PI / 180);
+    _cameraL.position.copy(_position);
+    _cameraL.quaternion.copy(_quaternion);
+    _cameraL.translateX(-scope.cameraDistance);
+    _cameraL.lookAt(scene.position);
+    _cameraL.rotation.x += 90 * (Math.PI / 180);
+    _cameraR.position.copy(_position);
+    _cameraR.quaternion.copy(_quaternion);
+    _cameraR.translateX(scope.cameraDistance);
+    _cameraR.lookAt(scene.position);
+    _cameraR.rotation.x += 90 * (Math.PI / 180);
+    renderer.clear();
+    renderer.setScissorTest(true);
+    renderer.setScissor(_halfWidth - _width / 2, _height * 2, _width, _height);
+    renderer.setViewport(_halfWidth - _width / 2, _height * 2, _width, _height);
+    if (scope.reflectFromAbove) {
+      renderer.render(scene, _cameraB);
+    } else {
+      renderer.render(scene, _cameraF);
+    }
+    renderer.setScissor(_halfWidth - _width / 2, 0, _width, _height);
+    renderer.setViewport(_halfWidth - _width / 2, 0, _width, _height);
+    if (scope.reflectFromAbove) {
+      renderer.render(scene, _cameraF);
+    } else {
+      renderer.render(scene, _cameraB);
+    }
+    renderer.setScissor(_halfWidth - _width / 2 - _width, _height, _width, _height);
+    renderer.setViewport(_halfWidth - _width / 2 - _width, _height, _width, _height);
+    if (scope.reflectFromAbove) {
+      renderer.render(scene, _cameraR);
+    } else {
+      renderer.render(scene, _cameraL);
+    }
+    renderer.setScissor(_halfWidth + _width / 2, _height, _width, _height);
+    renderer.setViewport(_halfWidth + _width / 2, _height, _width, _height);
+    if (scope.reflectFromAbove) {
+      renderer.render(scene, _cameraL);
+    } else {
+      renderer.render(scene, _cameraR);
+    }
+    renderer.setScissorTest(false);
+  };
+};
+exports.PeppersGhostEffect = PeppersGhostEffect;

package/dist/effects/PeppersGhostEffect.mjs

@@ -0,0 +1,85 @@
+import { PerspectiveCamera, Vector3, Quaternion } from "three";
+const PeppersGhostEffect = function(renderer) {
+  const scope = this;
+  scope.cameraDistance = 15;
+  scope.reflectFromAbove = false;
+  let _halfWidth, _width, _height;
+  const _cameraF = new PerspectiveCamera();
+  const _cameraB = new PerspectiveCamera();
+  const _cameraL = new PerspectiveCamera();
+  const _cameraR = new PerspectiveCamera();
+  const _position = new Vector3();
+  const _quaternion = new Quaternion();
+  const _scale = new Vector3();
+  renderer.autoClear = false;
+  this.setSize = (width, height) => {
+    _halfWidth = width / 2;
+    if (width < height) {
+      _width = width / 3;
+      _height = width / 3;
+    } else {
+      _width = height / 3;
+      _height = height / 3;
+    }
+    renderer.setSize(width, height);
+  };
+  this.render = (scene, camera) => {
+    scene.updateMatrixWorld();
+    if (camera.parent === null)
+      camera.updateMatrixWorld();
+    camera.matrixWorld.decompose(_position, _quaternion, _scale);
+    _cameraF.position.copy(_position);
+    _cameraF.quaternion.copy(_quaternion);
+    _cameraF.translateZ(scope.cameraDistance);
+    _cameraF.lookAt(scene.position);
+    _cameraB.position.copy(_position);
+    _cameraB.quaternion.copy(_quaternion);
+    _cameraB.translateZ(-scope.cameraDistance);
+    _cameraB.lookAt(scene.position);
+    _cameraB.rotation.z += 180 * (Math.PI / 180);
+    _cameraL.position.copy(_position);
+    _cameraL.quaternion.copy(_quaternion);
+    _cameraL.translateX(-scope.cameraDistance);
+    _cameraL.lookAt(scene.position);
+    _cameraL.rotation.x += 90 * (Math.PI / 180);
+    _cameraR.position.copy(_position);
+    _cameraR.quaternion.copy(_quaternion);
+    _cameraR.translateX(scope.cameraDistance);
+    _cameraR.lookAt(scene.position);
+    _cameraR.rotation.x += 90 * (Math.PI / 180);
+    renderer.clear();
+    renderer.setScissorTest(true);
+    renderer.setScissor(_halfWidth - _width / 2, _height * 2, _width, _height);
+    renderer.setViewport(_halfWidth - _width / 2, _height * 2, _width, _height);
+    if (scope.reflectFromAbove) {
+      renderer.render(scene, _cameraB);
+    } else {
+      renderer.render(scene, _cameraF);
+    }
+    renderer.setScissor(_halfWidth - _width / 2, 0, _width, _height);
+    renderer.setViewport(_halfWidth - _width / 2, 0, _width, _height);
+    if (scope.reflectFromAbove) {
+      renderer.render(scene, _cameraF);
+    } else {
+      renderer.render(scene, _cameraB);
+    }
+    renderer.setScissor(_halfWidth - _width / 2 - _width, _height, _width, _height);
+    renderer.setViewport(_halfWidth - _width / 2 - _width, _height, _width, _height);
+    if (scope.reflectFromAbove) {
+      renderer.render(scene, _cameraR);
+    } else {
+      renderer.render(scene, _cameraL);
+    }
+    renderer.setScissor(_halfWidth + _width / 2, _height, _width, _height);
+    renderer.setViewport(_halfWidth + _width / 2, _height, _width, _height);
+    if (scope.reflectFromAbove) {
+      renderer.render(scene, _cameraL);
+    } else {
+      renderer.render(scene, _cameraR);
+    }
+    renderer.setScissorTest(false);
+  };
+};
+export {
+  PeppersGhostEffect
+};

package/dist/effects/StereoEffect.d.ts

@@ -0,0 +1,9 @@
+import { Camera, Scene, WebGLRenderer } from 'three'
+
+export class StereoEffect {
+  constructor(renderer: WebGLRenderer)
+
+  setEyeSeparation(eyeSep: number): void
+  render(scene: Scene, camera: Camera): void
+  setSize(width: number, height: number): void
+}

package/dist/effects/StereoEffect.js

@@ -0,0 +1,32 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const StereoEffect = function(renderer) {
+  const _stereo = new THREE.StereoCamera();
+  _stereo.aspect = 0.5;
+  const size = new THREE.Vector2();
+  this.setEyeSeparation = (eyeSep) => {
+    _stereo.eyeSep = eyeSep;
+  };
+  this.setSize = (width, height) => {
+    renderer.setSize(width, height);
+  };
+  this.render = (scene, camera) => {
+    scene.updateMatrixWorld();
+    if (camera.parent === null)
+      camera.updateMatrixWorld();
+    _stereo.update(camera);
+    renderer.getSize(size);
+    if (renderer.autoClear)
+      renderer.clear();
+    renderer.setScissorTest(true);
+    renderer.setScissor(0, 0, size.width / 2, size.height);
+    renderer.setViewport(0, 0, size.width / 2, size.height);
+    renderer.render(scene, _stereo.cameraL);
+    renderer.setScissor(size.width / 2, 0, size.width / 2, size.height);
+    renderer.setViewport(size.width / 2, 0, size.width / 2, size.height);
+    renderer.render(scene, _stereo.cameraR);
+    renderer.setScissorTest(false);
+  };
+};
+exports.StereoEffect = StereoEffect;

package/dist/effects/StereoEffect.mjs

@@ -0,0 +1,32 @@
+import { StereoCamera, Vector2 } from "three";
+const StereoEffect = function(renderer) {
+  const _stereo = new StereoCamera();
+  _stereo.aspect = 0.5;
+  const size = new Vector2();
+  this.setEyeSeparation = (eyeSep) => {
+    _stereo.eyeSep = eyeSep;
+  };
+  this.setSize = (width, height) => {
+    renderer.setSize(width, height);
+  };
+  this.render = (scene, camera) => {
+    scene.updateMatrixWorld();
+    if (camera.parent === null)
+      camera.updateMatrixWorld();
+    _stereo.update(camera);
+    renderer.getSize(size);
+    if (renderer.autoClear)
+      renderer.clear();
+    renderer.setScissorTest(true);
+    renderer.setScissor(0, 0, size.width / 2, size.height);
+    renderer.setViewport(0, 0, size.width / 2, size.height);
+    renderer.render(scene, _stereo.cameraL);
+    renderer.setScissor(size.width / 2, 0, size.width / 2, size.height);
+    renderer.setViewport(size.width / 2, 0, size.width / 2, size.height);
+    renderer.render(scene, _stereo.cameraR);
+    renderer.setScissorTest(false);
+  };
+};
+export {
+  StereoEffect
+};

package/dist/environments/RoomEnvironment.d.ts

@@ -0,0 +1,5 @@
+import { Scene } from 'three'
+
+export class RoomEnvironment extends Scene {
+  constructor()
+}

package/dist/environments/RoomEnvironment.js

@@ -0,0 +1,95 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const THREE__namespace = /* @__PURE__ */ _interopNamespaceDefault(THREE);
+function RoomEnvironment() {
+  const scene = new THREE__namespace.Scene();
+  const geometry = new THREE__namespace.BoxGeometry();
+  geometry.deleteAttribute("uv");
+  const roomMaterial = new THREE__namespace.MeshStandardMaterial({ side: THREE__namespace.BackSide });
+  const boxMaterial = new THREE__namespace.MeshStandardMaterial();
+  const mainLight = new THREE__namespace.PointLight(16777215, 5, 28, 2);
+  mainLight.position.set(0.418, 16.199, 0.3);
+  scene.add(mainLight);
+  const room = new THREE__namespace.Mesh(geometry, roomMaterial);
+  room.position.set(-0.757, 13.219, 0.717);
+  room.scale.set(31.713, 28.305, 28.591);
+  scene.add(room);
+  const box1 = new THREE__namespace.Mesh(geometry, boxMaterial);
+  box1.position.set(-10.906, 2.009, 1.846);
+  box1.rotation.set(0, -0.195, 0);
+  box1.scale.set(2.328, 7.905, 4.651);
+  scene.add(box1);
+  const box2 = new THREE__namespace.Mesh(geometry, boxMaterial);
+  box2.position.set(-5.607, -0.754, -0.758);
+  box2.rotation.set(0, 0.994, 0);
+  box2.scale.set(1.97, 1.534, 3.955);
+  scene.add(box2);
+  const box3 = new THREE__namespace.Mesh(geometry, boxMaterial);
+  box3.position.set(6.167, 0.857, 7.803);
+  box3.rotation.set(0, 0.561, 0);
+  box3.scale.set(3.927, 6.285, 3.687);
+  scene.add(box3);
+  const box4 = new THREE__namespace.Mesh(geometry, boxMaterial);
+  box4.position.set(-2.017, 0.018, 6.124);
+  box4.rotation.set(0, 0.333, 0);
+  box4.scale.set(2.002, 4.566, 2.064);
+  scene.add(box4);
+  const box5 = new THREE__namespace.Mesh(geometry, boxMaterial);
+  box5.position.set(2.291, -0.756, -2.621);
+  box5.rotation.set(0, -0.286, 0);
+  box5.scale.set(1.546, 1.552, 1.496);
+  scene.add(box5);
+  const box6 = new THREE__namespace.Mesh(geometry, boxMaterial);
+  box6.position.set(-2.193, -0.369, -5.547);
+  box6.rotation.set(0, 0.516, 0);
+  box6.scale.set(3.875, 3.487, 2.986);
+  scene.add(box6);
+  const light1 = new THREE__namespace.Mesh(geometry, createAreaLightMaterial(50));
+  light1.position.set(-16.116, 14.37, 8.208);
+  light1.scale.set(0.1, 2.428, 2.739);
+  scene.add(light1);
+  const light2 = new THREE__namespace.Mesh(geometry, createAreaLightMaterial(50));
+  light2.position.set(-16.109, 18.021, -8.207);
+  light2.scale.set(0.1, 2.425, 2.751);
+  scene.add(light2);
+  const light3 = new THREE__namespace.Mesh(geometry, createAreaLightMaterial(17));
+  light3.position.set(14.904, 12.198, -1.832);
+  light3.scale.set(0.15, 4.265, 6.331);
+  scene.add(light3);
+  const light4 = new THREE__namespace.Mesh(geometry, createAreaLightMaterial(43));
+  light4.position.set(-0.462, 8.89, 14.52);
+  light4.scale.set(4.38, 5.441, 0.088);
+  scene.add(light4);
+  const light5 = new THREE__namespace.Mesh(geometry, createAreaLightMaterial(20));
+  light5.position.set(3.235, 11.486, -12.541);
+  light5.scale.set(2.5, 2, 0.1);
+  scene.add(light5);
+  const light6 = new THREE__namespace.Mesh(geometry, createAreaLightMaterial(100));
+  light6.position.set(0, 20, 0);
+  light6.scale.set(1, 0.1, 1);
+  scene.add(light6);
+  function createAreaLightMaterial(intensity) {
+    const material = new THREE__namespace.MeshBasicMaterial();
+    material.color.setScalar(intensity);
+    return material;
+  }
+  return scene;
+}
+exports.RoomEnvironment = RoomEnvironment;

package/dist/environments/RoomEnvironment.mjs

@@ -0,0 +1,78 @@
+import * as THREE from "three";
+function RoomEnvironment() {
+  const scene = new THREE.Scene();
+  const geometry = new THREE.BoxGeometry();
+  geometry.deleteAttribute("uv");
+  const roomMaterial = new THREE.MeshStandardMaterial({ side: THREE.BackSide });
+  const boxMaterial = new THREE.MeshStandardMaterial();
+  const mainLight = new THREE.PointLight(16777215, 5, 28, 2);
+  mainLight.position.set(0.418, 16.199, 0.3);
+  scene.add(mainLight);
+  const room = new THREE.Mesh(geometry, roomMaterial);
+  room.position.set(-0.757, 13.219, 0.717);
+  room.scale.set(31.713, 28.305, 28.591);
+  scene.add(room);
+  const box1 = new THREE.Mesh(geometry, boxMaterial);
+  box1.position.set(-10.906, 2.009, 1.846);
+  box1.rotation.set(0, -0.195, 0);
+  box1.scale.set(2.328, 7.905, 4.651);
+  scene.add(box1);
+  const box2 = new THREE.Mesh(geometry, boxMaterial);
+  box2.position.set(-5.607, -0.754, -0.758);
+  box2.rotation.set(0, 0.994, 0);
+  box2.scale.set(1.97, 1.534, 3.955);
+  scene.add(box2);
+  const box3 = new THREE.Mesh(geometry, boxMaterial);
+  box3.position.set(6.167, 0.857, 7.803);
+  box3.rotation.set(0, 0.561, 0);
+  box3.scale.set(3.927, 6.285, 3.687);
+  scene.add(box3);
+  const box4 = new THREE.Mesh(geometry, boxMaterial);
+  box4.position.set(-2.017, 0.018, 6.124);
+  box4.rotation.set(0, 0.333, 0);
+  box4.scale.set(2.002, 4.566, 2.064);
+  scene.add(box4);
+  const box5 = new THREE.Mesh(geometry, boxMaterial);
+  box5.position.set(2.291, -0.756, -2.621);
+  box5.rotation.set(0, -0.286, 0);
+  box5.scale.set(1.546, 1.552, 1.496);
+  scene.add(box5);
+  const box6 = new THREE.Mesh(geometry, boxMaterial);
+  box6.position.set(-2.193, -0.369, -5.547);
+  box6.rotation.set(0, 0.516, 0);
+  box6.scale.set(3.875, 3.487, 2.986);
+  scene.add(box6);
+  const light1 = new THREE.Mesh(geometry, createAreaLightMaterial(50));
+  light1.position.set(-16.116, 14.37, 8.208);
+  light1.scale.set(0.1, 2.428, 2.739);
+  scene.add(light1);
+  const light2 = new THREE.Mesh(geometry, createAreaLightMaterial(50));
+  light2.position.set(-16.109, 18.021, -8.207);
+  light2.scale.set(0.1, 2.425, 2.751);
+  scene.add(light2);
+  const light3 = new THREE.Mesh(geometry, createAreaLightMaterial(17));
+  light3.position.set(14.904, 12.198, -1.832);
+  light3.scale.set(0.15, 4.265, 6.331);
+  scene.add(light3);
+  const light4 = new THREE.Mesh(geometry, createAreaLightMaterial(43));
+  light4.position.set(-0.462, 8.89, 14.52);
+  light4.scale.set(4.38, 5.441, 0.088);
+  scene.add(light4);
+  const light5 = new THREE.Mesh(geometry, createAreaLightMaterial(20));
+  light5.position.set(3.235, 11.486, -12.541);
+  light5.scale.set(2.5, 2, 0.1);
+  scene.add(light5);
+  const light6 = new THREE.Mesh(geometry, createAreaLightMaterial(100));
+  light6.position.set(0, 20, 0);
+  light6.scale.set(1, 0.1, 1);
+  scene.add(light6);
+  function createAreaLightMaterial(intensity) {
+    const material = new THREE.MeshBasicMaterial();
+    material.color.setScalar(intensity);
+    return material;
+  }
+  return scene;
+}
+export {
+  RoomEnvironment
+};

package/dist/exporters/ColladaExporter.d.ts

@@ -0,0 +1,50 @@
+import { Object3D } from 'three';
+/**
+ * https://github.com/gkjohnson/collada-exporter-js
+ *
+ * Usage:
+ *  const exporter = new ColladaExporter();
+ *
+ *  const data = exporter.parse(mesh);
+ *
+ * Format Definition:
+ *  https://www.khronos.org/collada/
+ */
+export interface ColladaExporterOptions {
+    author?: string;
+    textureDirectory?: string;
+    version?: string;
+}
+export interface ColladaExporterResult {
+    data: string;
+    textures: object[];
+}
+declare class ColladaExporter {
+    private options;
+    private geometryInfo;
+    private materialMap;
+    private imageMap;
+    private textures;
+    private libraryImages;
+    private libraryGeometries;
+    private libraryEffects;
+    private libraryMaterials;
+    private canvas;
+    private ctx;
+    private transMat;
+    private getFuncs;
+    constructor();
+    parse(object: Object3D, onDone: (res: ColladaExporterResult) => void, options?: ColladaExporterOptions): ColladaExporterResult | null;
+    private format;
+    private base64ToBuffer;
+    private imageToData;
+    private attrBufferToArray;
+    private subArray;
+    private getAttribute;
+    private getTransform;
+    private processGeometry;
+    private processTexture;
+    private processMaterial;
+    private processObject;
+}
+export { ColladaExporter };