three-stdlib 2.22.5 → 2.22.6

package/effects/OutlineEffect.js

@@ -1,378 +0,0 @@
-import { Color, ShaderMaterial, UniformsUtils, UniformsLib, BackSide } from 'three';
-
-/**
- * Reference: https://en.wikipedia.org/wiki/Cel_shading
- *
- * API
- *
- * 1. Traditional
- *
- * var effect = new OutlineEffect( renderer );
- *
- * function render() {
- *
- * 	effect.render( scene, camera );
- *
- * }
- *
- * 2. VR compatible
- *
- * var effect = new OutlineEffect( renderer );
- * var renderingOutline = false;
- *
- * scene.onAfterRender = function () {
- *
- * 	if ( renderingOutline ) return;
- *
- * 	renderingOutline = true;
- *
- * 	effect.renderOutline( scene, camera );
- *
- * 	renderingOutline = false;
- *
- * };
- *
- * function render() {
- *
- * 	renderer.render( scene, camera );
- *
- * }
- *
- * // How to set default outline parameters
- * new OutlineEffect( renderer, {
- * 	defaultThickness: 0.01,
- * 	defaultColor: [ 0, 0, 0 ],
- * 	defaultAlpha: 0.8,
- * 	defaultKeepAlive: true // keeps outline material in cache even if material is removed from scene
- * } );
- *
- * // How to set outline parameters for each material
- * material.userData.outlineParameters = {
- * 	thickness: 0.01,
- * 	color: [ 0, 0, 0 ]
- * 	alpha: 0.8,
- * 	visible: true,
- * 	keepAlive: true
- * };
- */
-
-const OutlineEffect = function (renderer, parameters) {
-  parameters = parameters || {};
-  this.enabled = true;
-  const defaultThickness = parameters.defaultThickness !== undefined ? parameters.defaultThickness : 0.003;
-  const defaultColor = new Color().fromArray(parameters.defaultColor !== undefined ? parameters.defaultColor : [0, 0, 0]);
-  const defaultAlpha = parameters.defaultAlpha !== undefined ? parameters.defaultAlpha : 1.0;
-  const defaultKeepAlive = parameters.defaultKeepAlive !== undefined ? parameters.defaultKeepAlive : false; // object.material.uuid -> outlineMaterial or
-  // object.material[ n ].uuid -> outlineMaterial
-  // save at the outline material creation and release
-  // if it's unused removeThresholdCount frames
-  // unless keepAlive is true.
-
-  const cache = {};
-  const removeThresholdCount = 60; // outlineMaterial.uuid -> object.material or
-  // outlineMaterial.uuid -> object.material[ n ]
-  // save before render and release after render.
-
-  const originalMaterials = {}; // object.uuid -> originalOnBeforeRender
-  // save before render and release after render.
-
-  const originalOnBeforeRenders = {}; //this.cache = cache;  // for debug
-
-  const uniformsOutline = {
-    outlineThickness: {
-      value: defaultThickness
-    },
-    outlineColor: {
-      value: defaultColor
-    },
-    outlineAlpha: {
-      value: defaultAlpha
-    }
-  };
-  const vertexShader = ['#include <common>', '#include <uv_pars_vertex>', '#include <displacementmap_pars_vertex>', '#include <fog_pars_vertex>', '#include <morphtarget_pars_vertex>', '#include <skinning_pars_vertex>', '#include <logdepthbuf_pars_vertex>', '#include <clipping_planes_pars_vertex>', 'uniform float outlineThickness;', 'vec4 calculateOutline( vec4 pos, vec3 normal, vec4 skinned ) {', '	float thickness = outlineThickness;', '	const float ratio = 1.0;', // TODO: support outline thickness ratio for each vertex
-  '	vec4 pos2 = projectionMatrix * modelViewMatrix * vec4( skinned.xyz + normal, 1.0 );', // NOTE: subtract pos2 from pos because BackSide objectNormal is negative
-  '	vec4 norm = normalize( pos - pos2 );', '	return pos + norm * thickness * pos.w * ratio;', '}', 'void main() {', '	#include <uv_vertex>', '	#include <beginnormal_vertex>', '	#include <morphnormal_vertex>', '	#include <skinbase_vertex>', '	#include <skinnormal_vertex>', '	#include <begin_vertex>', '	#include <morphtarget_vertex>', '	#include <skinning_vertex>', '	#include <displacementmap_vertex>', '	#include <project_vertex>', '	vec3 outlineNormal = - objectNormal;', // the outline material is always rendered with BackSide
-  '	gl_Position = calculateOutline( gl_Position, outlineNormal, vec4( transformed, 1.0 ) );', '	#include <logdepthbuf_vertex>', '	#include <clipping_planes_vertex>', '	#include <fog_vertex>', '}'].join('\n');
-  const fragmentShader = ['#include <common>', '#include <fog_pars_fragment>', '#include <logdepthbuf_pars_fragment>', '#include <clipping_planes_pars_fragment>', 'uniform vec3 outlineColor;', 'uniform float outlineAlpha;', 'void main() {', '	#include <clipping_planes_fragment>', '	#include <logdepthbuf_fragment>', '	gl_FragColor = vec4( outlineColor, outlineAlpha );', '	#include <tonemapping_fragment>', '	#include <encodings_fragment>', '	#include <fog_fragment>', '	#include <premultiplied_alpha_fragment>', '}'].join('\n');
-
-  function createMaterial() {
-    return new ShaderMaterial({
-      type: 'OutlineEffect',
-      uniforms: UniformsUtils.merge([UniformsLib['fog'], UniformsLib['displacementmap'], uniformsOutline]),
-      vertexShader,
-      fragmentShader,
-      side: BackSide
-    });
-  }
-
-  function getOutlineMaterialFromCache(originalMaterial) {
-    let data = cache[originalMaterial.uuid];
-
-    if (data === undefined) {
-      data = {
-        material: createMaterial(),
-        used: true,
-        keepAlive: defaultKeepAlive,
-        count: 0
-      };
-      cache[originalMaterial.uuid] = data;
-    }
-
-    data.used = true;
-    return data.material;
-  }
-
-  function getOutlineMaterial(originalMaterial) {
-    const outlineMaterial = getOutlineMaterialFromCache(originalMaterial);
-    originalMaterials[outlineMaterial.uuid] = originalMaterial;
-    updateOutlineMaterial(outlineMaterial, originalMaterial);
-    return outlineMaterial;
-  }
-
-  function isCompatible(object) {
-    const geometry = object.geometry;
-    let hasNormals = false;
-
-    if (object.geometry !== undefined) {
-      if (geometry.isBufferGeometry) {
-        hasNormals = geometry.attributes.normal !== undefined;
-      } else {
-        hasNormals = true; // the renderer always produces a normal attribute for Geometry
-      }
-    }
-
-    return object.isMesh === true && object.material !== undefined && hasNormals === true;
-  }
-
-  function setOutlineMaterial(object) {
-    if (isCompatible(object) === false) return;
-
-    if (Array.isArray(object.material)) {
-      for (let i = 0, il = object.material.length; i < il; i++) {
-        object.material[i] = getOutlineMaterial(object.material[i]);
-      }
-    } else {
-      object.material = getOutlineMaterial(object.material);
-    }
-
-    originalOnBeforeRenders[object.uuid] = object.onBeforeRender;
-    object.onBeforeRender = onBeforeRender;
-  }
-
-  function restoreOriginalMaterial(object) {
-    if (isCompatible(object) === false) return;
-
-    if (Array.isArray(object.material)) {
-      for (let i = 0, il = object.material.length; i < il; i++) {
-        object.material[i] = originalMaterials[object.material[i].uuid];
-      }
-    } else {
-      object.material = originalMaterials[object.material.uuid];
-    }
-
-    object.onBeforeRender = originalOnBeforeRenders[object.uuid];
-  }
-
-  function onBeforeRender(renderer, scene, camera, geometry, material) {
-    const originalMaterial = originalMaterials[material.uuid]; // just in case
-
-    if (originalMaterial === undefined) return;
-    updateUniforms(material, originalMaterial);
-  }
-
-  function updateUniforms(material, originalMaterial) {
-    const outlineParameters = originalMaterial.userData.outlineParameters;
-    material.uniforms.outlineAlpha.value = originalMaterial.opacity;
-
-    if (outlineParameters !== undefined) {
-      if (outlineParameters.thickness !== undefined) {
-        material.uniforms.outlineThickness.value = outlineParameters.thickness;
-      }
-
-      if (outlineParameters.color !== undefined) material.uniforms.outlineColor.value.fromArray(outlineParameters.color);
-      if (outlineParameters.alpha !== undefined) material.uniforms.outlineAlpha.value = outlineParameters.alpha;
-    }
-
-    if (originalMaterial.displacementMap) {
-      material.uniforms.displacementMap.value = originalMaterial.displacementMap;
-      material.uniforms.displacementScale.value = originalMaterial.displacementScale;
-      material.uniforms.displacementBias.value = originalMaterial.displacementBias;
-    }
-  }
-
-  function updateOutlineMaterial(material, originalMaterial) {
-    if (material.name === 'invisible') return;
-    const outlineParameters = originalMaterial.userData.outlineParameters;
-    material.skinning = originalMaterial.skinning;
-    material.morphTargets = originalMaterial.morphTargets;
-    material.morphNormals = originalMaterial.morphNormals;
-    material.fog = originalMaterial.fog;
-    material.toneMapped = originalMaterial.toneMapped;
-    material.premultipliedAlpha = originalMaterial.premultipliedAlpha;
-    material.displacementMap = originalMaterial.displacementMap;
-
-    if (outlineParameters !== undefined) {
-      if (originalMaterial.visible === false) {
-        material.visible = false;
-      } else {
-        material.visible = outlineParameters.visible !== undefined ? outlineParameters.visible : true;
-      }
-
-      material.transparent = outlineParameters.alpha !== undefined && outlineParameters.alpha < 1.0 ? true : originalMaterial.transparent;
-
-      if (outlineParameters.keepAlive !== undefined) {
-        cache[originalMaterial.uuid].keepAlive = outlineParameters.keepAlive;
-      }
-    } else {
-      material.transparent = originalMaterial.transparent;
-      material.visible = originalMaterial.visible;
-    }
-
-    if (originalMaterial.wireframe === true || originalMaterial.depthTest === false) material.visible = false;
-
-    if (originalMaterial.clippingPlanes) {
-      material.clipping = true;
-      material.clippingPlanes = originalMaterial.clippingPlanes;
-      material.clipIntersection = originalMaterial.clipIntersection;
-      material.clipShadows = originalMaterial.clipShadows;
-    }
-
-    material.version = originalMaterial.version; // update outline material if necessary
-  }
-
-  function cleanupCache() {
-    let keys; // clear originialMaterials
-
-    keys = Object.keys(originalMaterials);
-
-    for (let i = 0, il = keys.length; i < il; i++) {
-      originalMaterials[keys[i]] = undefined;
-    } // clear originalOnBeforeRenders
-
-
-    keys = Object.keys(originalOnBeforeRenders);
-
-    for (let i = 0, il = keys.length; i < il; i++) {
-      originalOnBeforeRenders[keys[i]] = undefined;
-    } // remove unused outlineMaterial from cache
-
-
-    keys = Object.keys(cache);
-
-    for (let i = 0, il = keys.length; i < il; i++) {
-      const key = keys[i];
-
-      if (cache[key].used === false) {
-        cache[key].count++;
-
-        if (cache[key].keepAlive === false && cache[key].count > removeThresholdCount) {
-          delete cache[key];
-        }
-      } else {
-        cache[key].used = false;
-        cache[key].count = 0;
-      }
-    }
-  }
-
-  this.render = function (scene, camera) {
-    let renderTarget;
-    let forceClear = false;
-
-    if (arguments[2] !== undefined) {
-      console.warn('THREE.OutlineEffect.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead.');
-      renderTarget = arguments[2];
-    }
-
-    if (arguments[3] !== undefined) {
-      console.warn('THREE.OutlineEffect.render(): the forceClear argument has been removed. Use .clear() instead.');
-      forceClear = arguments[3];
-    }
-
-    if (renderTarget !== undefined) renderer.setRenderTarget(renderTarget);
-    if (forceClear) renderer.clear();
-
-    if (this.enabled === false) {
-      renderer.render(scene, camera);
-      return;
-    }
-
-    const currentAutoClear = renderer.autoClear;
-    renderer.autoClear = this.autoClear;
-    renderer.render(scene, camera);
-    renderer.autoClear = currentAutoClear;
-    this.renderOutline(scene, camera);
-  };
-
-  this.renderOutline = (scene, camera) => {
-    const currentAutoClear = renderer.autoClear;
-    const currentSceneAutoUpdate = scene.autoUpdate;
-    const currentSceneBackground = scene.background;
-    const currentShadowMapEnabled = renderer.shadowMap.enabled;
-    scene.autoUpdate = false;
-    scene.background = null;
-    renderer.autoClear = false;
-    renderer.shadowMap.enabled = false;
-    scene.traverse(setOutlineMaterial);
-    renderer.render(scene, camera);
-    scene.traverse(restoreOriginalMaterial);
-    cleanupCache();
-    scene.autoUpdate = currentSceneAutoUpdate;
-    scene.background = currentSceneBackground;
-    renderer.autoClear = currentAutoClear;
-    renderer.shadowMap.enabled = currentShadowMapEnabled;
-  };
-  /*
-   * See #9918
-   *
-   * The following property copies and wrapper methods enable
-   * OutlineEffect to be called from other *Effect, like
-   *
-   * effect = new StereoEffect( new OutlineEffect( renderer ) );
-   *
-   * function render () {
-   *
-   * 	effect.render( scene, camera );
-   *
-   * }
-   */
-
-
-  this.autoClear = renderer.autoClear;
-  this.domElement = renderer.domElement;
-  this.shadowMap = renderer.shadowMap;
-
-  this.clear = (color, depth, stencil) => {
-    renderer.clear(color, depth, stencil);
-  };
-
-  this.getPixelRatio = () => renderer.getPixelRatio();
-
-  this.setPixelRatio = value => {
-    renderer.setPixelRatio(value);
-  };
-
-  this.getSize = target => renderer.getSize(target);
-
-  this.setSize = (width, height, updateStyle) => {
-    renderer.setSize(width, height, updateStyle);
-  };
-
-  this.setViewport = (x, y, width, height) => {
-    renderer.setViewport(x, y, width, height);
-  };
-
-  this.setScissor = (x, y, width, height) => {
-    renderer.setScissor(x, y, width, height);
-  };
-
-  this.setScissorTest = boolean => {
-    renderer.setScissorTest(boolean);
-  };
-
-  this.setRenderTarget = renderTarget => {
-    renderer.setRenderTarget(renderTarget);
-  };
-};
-
-export { OutlineEffect };

package/effects/ParallaxBarrierEffect.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");exports.ParallaxBarrierEffect=function(r){const t=new e.OrthographicCamera(-1,1,1,-1,0,1),a=new e.Scene,i=new e.StereoCamera,n={minFilter:e.LinearFilter,magFilter:e.NearestFilter,format:e.RGBAFormat},o=new e.WebGLRenderTarget(512,512,n),l=new e.WebGLRenderTarget(512,512,n),v=new e.ShaderMaterial({uniforms:{mapLeft:{value:o.texture},mapRight:{value:l.texture}},vertexShader:["varying vec2 vUv;","void main() {","\tvUv = vec2( uv.x, uv.y );","\tgl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );","}"].join("\n"),fragmentShader:["uniform sampler2D mapLeft;","uniform sampler2D mapRight;","varying vec2 vUv;","void main() {","\tvec2 uv = vUv;","\tif ( ( mod( gl_FragCoord.y, 2.0 ) ) > 1.00 ) {","\t\tgl_FragColor = texture2D( mapLeft, uv );","\t} else {","\t\tgl_FragColor = texture2D( mapRight, uv );","\t}","}"].join("\n")}),d=new e.Mesh(new e.PlaneGeometry(2,2),v);a.add(d),this.setSize=(e,t)=>{r.setSize(e,t);const a=r.getPixelRatio();o.setSize(e*a,t*a),l.setSize(e*a,t*a)},this.render=(e,n)=>{e.updateMatrixWorld(),null===n.parent&&n.updateMatrixWorld(),i.update(n),r.setRenderTarget(o),r.clear(),r.render(e,i.cameraL),r.setRenderTarget(l),r.clear(),r.render(e,i.cameraR),r.setRenderTarget(null),r.render(a,t)}};

package/effects/ParallaxBarrierEffect.d.ts

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

package/effects/ParallaxBarrierEffect.js

@@ -1,63 +0,0 @@
-import { OrthographicCamera, Scene, StereoCamera, WebGLRenderTarget, ShaderMaterial, Mesh, PlaneGeometry, LinearFilter, NearestFilter, RGBAFormat } 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/effects/PeppersGhostEffect.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");exports.PeppersGhostEffect=function(t){const r=this;let o,s,i;r.cameraDistance=15,r.reflectFromAbove=!1;const a=new e.PerspectiveCamera,n=new e.PerspectiveCamera,c=new e.PerspectiveCamera,p=new e.PerspectiveCamera,l=new e.Vector3,d=new e.Quaternion,m=new e.Vector3;t.autoClear=!1,this.setSize=(e,r)=>{o=e/2,e<r?(s=e/3,i=e/3):(s=r/3,i=r/3),t.setSize(e,r)},this.render=(e,u)=>{e.updateMatrixWorld(),null===u.parent&&u.updateMatrixWorld(),u.matrixWorld.decompose(l,d,m),a.position.copy(l),a.quaternion.copy(d),a.translateZ(r.cameraDistance),a.lookAt(e.position),n.position.copy(l),n.quaternion.copy(d),n.translateZ(-r.cameraDistance),n.lookAt(e.position),n.rotation.z+=Math.PI/180*180,c.position.copy(l),c.quaternion.copy(d),c.translateX(-r.cameraDistance),c.lookAt(e.position),c.rotation.x+=Math.PI/180*90,p.position.copy(l),p.quaternion.copy(d),p.translateX(r.cameraDistance),p.lookAt(e.position),p.rotation.x+=Math.PI/180*90,t.clear(),t.setScissorTest(!0),t.setScissor(o-s/2,2*i,s,i),t.setViewport(o-s/2,2*i,s,i),r.reflectFromAbove?t.render(e,n):t.render(e,a),t.setScissor(o-s/2,0,s,i),t.setViewport(o-s/2,0,s,i),r.reflectFromAbove?t.render(e,a):t.render(e,n),t.setScissor(o-s/2-s,i,s,i),t.setViewport(o-s/2-s,i,s,i),r.reflectFromAbove?t.render(e,p):t.render(e,c),t.setScissor(o+s/2,i,s,i),t.setViewport(o+s/2,i,s,i),r.reflectFromAbove?t.render(e,c):t.render(e,p),t.setScissorTest(!1)}};

package/effects/PeppersGhostEffect.d.ts

@@ -1,10 +0,0 @@
-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/effects/PeppersGhostEffect.js

@@ -1,134 +0,0 @@
-import { PerspectiveCamera, Vector3, Quaternion } from 'three';
-
-/**
- * peppers ghost effect based on http://www.instructables.com/id/Reflective-Prism/?ALLSTEPS
- */
-
-const PeppersGhostEffect = function (renderer) {
-  const scope = this;
-  scope.cameraDistance = 15;
-  scope.reflectFromAbove = false; // Internals
-
-  let _halfWidth, _width, _height;
-
-  const _cameraF = new PerspectiveCamera(); //front
-
-
-  const _cameraB = new PerspectiveCamera(); //back
-
-
-  const _cameraL = new PerspectiveCamera(); //left
-
-
-  const _cameraR = new PerspectiveCamera(); //right
-
-
-  const _position = new Vector3();
-
-  const _quaternion = new Quaternion();
-
-  const _scale = new Vector3(); // Initialization
-
-
-  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); // front
-
-    _cameraF.position.copy(_position);
-
-    _cameraF.quaternion.copy(_quaternion);
-
-    _cameraF.translateZ(scope.cameraDistance);
-
-    _cameraF.lookAt(scene.position); // back
-
-
-    _cameraB.position.copy(_position);
-
-    _cameraB.quaternion.copy(_quaternion);
-
-    _cameraB.translateZ(-scope.cameraDistance);
-
-    _cameraB.lookAt(scene.position);
-
-    _cameraB.rotation.z += 180 * (Math.PI / 180); // left
-
-    _cameraL.position.copy(_position);
-
-    _cameraL.quaternion.copy(_quaternion);
-
-    _cameraL.translateX(-scope.cameraDistance);
-
-    _cameraL.lookAt(scene.position);
-
-    _cameraL.rotation.x += 90 * (Math.PI / 180); // right
-
-    _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/effects/StereoEffect.cjs.js

@@ -1 +0,0 @@
-"use strict";Object.defineProperty(exports,"__esModule",{value:!0});var e=require("three");exports.StereoEffect=function(t){const r=new e.StereoCamera;r.aspect=.5;const s=new e.Vector2;this.setEyeSeparation=e=>{r.eyeSep=e},this.setSize=(e,r)=>{t.setSize(e,r)},this.render=(e,i)=>{e.updateMatrixWorld(),null===i.parent&&i.updateMatrixWorld(),r.update(i),t.getSize(s),t.autoClear&&t.clear(),t.setScissorTest(!0),t.setScissor(0,0,s.width/2,s.height),t.setViewport(0,0,s.width/2,s.height),t.render(e,r.cameraL),t.setScissor(s.width/2,0,s.width/2,s.height),t.setViewport(s.width/2,0,s.width/2,s.height),t.render(e,r.cameraR),t.setScissorTest(!1)}};

package/effects/StereoEffect.d.ts

@@ -1,9 +0,0 @@
-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/effects/StereoEffect.js

@@ -1,36 +0,0 @@
-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/environments/RoomEnvironment.cjs.js

@@ -1 +0,0 @@
-"use strict";function e(e){if(e&&e.__esModule)return e;var t=Object.create(null);return e&&Object.keys(e).forEach((function(s){if("default"!==s){var n=Object.getOwnPropertyDescriptor(e,s);Object.defineProperty(t,s,n.get?n:{enumerable:!0,get:function(){return e[s]}})}})),t.default=e,Object.freeze(t)}Object.defineProperty(exports,"__esModule",{value:!0});var t=e(require("three"));exports.RoomEnvironment=function(){const e=new t.Scene,s=new t.BoxGeometry;s.deleteAttribute("uv");const n=new t.MeshStandardMaterial({side:t.BackSide}),o=new t.MeshStandardMaterial,a=new t.PointLight(16777215,5,28,2);a.position.set(.418,16.199,.3),e.add(a);const i=new t.Mesh(s,n);i.position.set(-.757,13.219,.717),i.scale.set(31.713,28.305,28.591),e.add(i);const c=new t.Mesh(s,o);c.position.set(-10.906,2.009,1.846),c.rotation.set(0,-.195,0),c.scale.set(2.328,7.905,4.651),e.add(c);const r=new t.Mesh(s,o);r.position.set(-5.607,-.754,-.758),r.rotation.set(0,.994,0),r.scale.set(1.97,1.534,3.955),e.add(r);const d=new t.Mesh(s,o);d.position.set(6.167,.857,7.803),d.rotation.set(0,.561,0),d.scale.set(3.927,6.285,3.687),e.add(d);const l=new t.Mesh(s,o);l.position.set(-2.017,.018,6.124),l.rotation.set(0,.333,0),l.scale.set(2.002,4.566,2.064),e.add(l);const u=new t.Mesh(s,o);u.position.set(2.291,-.756,-2.621),u.rotation.set(0,-.286,0),u.scale.set(1.546,1.552,1.496),e.add(u);const M=new t.Mesh(s,o);M.position.set(-2.193,-.369,-5.547),M.rotation.set(0,.516,0),M.scale.set(3.875,3.487,2.986),e.add(M);const p=new t.Mesh(s,j(50));p.position.set(-16.116,14.37,8.208),p.scale.set(.1,2.428,2.739),e.add(p);const w=new t.Mesh(s,j(50));w.position.set(-16.109,18.021,-8.207),w.scale.set(.1,2.425,2.751),e.add(w);const h=new t.Mesh(s,j(17));h.position.set(14.904,12.198,-1.832),h.scale.set(.15,4.265,6.331),e.add(h);const f=new t.Mesh(s,j(43));f.position.set(-.462,8.89,14.52),f.scale.set(4.38,5.441,.088),e.add(f);const b=new t.Mesh(s,j(20));b.position.set(3.235,11.486,-12.541),b.scale.set(2.5,2,.1),e.add(b);const O=new t.Mesh(s,j(100));function j(e){const s=new t.MeshBasicMaterial;return s.color.setScalar(e),s}return O.position.set(0,20,0),O.scale.set(1,.1,1),e.add(O),e};

package/environments/RoomEnvironment.d.ts

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