three-stdlib 2.15.2 → 2.16.1

package/effects/OutlineEffect.js

@@ -1,88 +1,114 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const OutlineEffect = function(renderer, parameters) {
+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 !== void 0 ? parameters.defaultThickness : 3e-3;
-  const defaultColor = new THREE.Color().fromArray(
-    parameters.defaultColor !== void 0 ? parameters.defaultColor : [0, 0, 0]
-  );
-  const defaultAlpha = parameters.defaultAlpha !== void 0 ? parameters.defaultAlpha : 1;
-  const defaultKeepAlive = parameters.defaultKeepAlive !== void 0 ? parameters.defaultKeepAlive : false;
+  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;
-  const originalMaterials = {};
-  const originalOnBeforeRenders = {};
+  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 }
+    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;",
-    "	vec4 pos2 = projectionMatrix * modelViewMatrix * vec4( skinned.xyz + normal, 1.0 );",
-    "	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;",
-    "	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");
+  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 THREE.ShaderMaterial({
-      type: "OutlineEffect",
-      uniforms: THREE.UniformsUtils.merge([THREE.UniformsLib["fog"], THREE.UniformsLib["displacementmap"], uniformsOutline]),
+    return new ShaderMaterial({
+      type: 'OutlineEffect',
+      uniforms: UniformsUtils.merge([UniformsLib['fog'], UniformsLib['displacementmap'], uniformsOutline]),
       vertexShader,
       fragmentShader,
-      side: THREE.BackSide
+      side: BackSide
     });
   }
+
   function getOutlineMaterialFromCache(originalMaterial) {
     let data = cache[originalMaterial.uuid];
-    if (data === void 0) {
+
+    if (data === undefined) {
       data = {
         material: createMaterial(),
         used: true,
@@ -91,30 +117,36 @@ const OutlineEffect = function(renderer, parameters) {
       };
       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 !== void 0) {
+
+    if (object.geometry !== undefined) {
       if (geometry.isBufferGeometry) {
-        hasNormals = geometry.attributes.normal !== void 0;
+        hasNormals = geometry.attributes.normal !== undefined;
       } else {
-        hasNormals = true;
+        hasNormals = true; // the renderer always produces a normal attribute for Geometry
       }
     }
-    return object.isMesh === true && object.material !== void 0 && hasNormals === true;
+
+    return object.isMesh === true && object.material !== undefined && hasNormals === true;
   }
+
   function setOutlineMaterial(object) {
-    if (isCompatible(object) === false)
-      return;
+    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]);
@@ -122,12 +154,14 @@ const OutlineEffect = function(renderer, parameters) {
     } else {
       object.material = getOutlineMaterial(object.material);
     }
+
     originalOnBeforeRenders[object.uuid] = object.onBeforeRender;
     object.onBeforeRender = onBeforeRender;
   }
+
   function restoreOriginalMaterial(object) {
-    if (isCompatible(object) === false)
-      return;
+    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];
@@ -135,35 +169,39 @@ const OutlineEffect = function(renderer, parameters) {
     } else {
       object.material = originalMaterials[object.material.uuid];
     }
+
     object.onBeforeRender = originalOnBeforeRenders[object.uuid];
   }
-  function onBeforeRender(renderer2, scene, camera, geometry, material) {
-    const originalMaterial = originalMaterials[material.uuid];
-    if (originalMaterial === void 0)
-      return;
+
+  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 !== void 0) {
-      if (outlineParameters.thickness !== void 0) {
+
+    if (outlineParameters !== undefined) {
+      if (outlineParameters.thickness !== undefined) {
         material.uniforms.outlineThickness.value = outlineParameters.thickness;
       }
-      if (outlineParameters.color !== void 0)
-        material.uniforms.outlineColor.value.fromArray(outlineParameters.color);
-      if (outlineParameters.alpha !== void 0)
-        material.uniforms.outlineAlpha.value = outlineParameters.alpha;
+
+      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;
+    if (material.name === 'invisible') return;
     const outlineParameters = originalMaterial.userData.outlineParameters;
     material.skinning = originalMaterial.skinning;
     material.morphTargets = originalMaterial.morphTargets;
@@ -172,45 +210,61 @@ const OutlineEffect = function(renderer, parameters) {
     material.toneMapped = originalMaterial.toneMapped;
     material.premultipliedAlpha = originalMaterial.premultipliedAlpha;
     material.displacementMap = originalMaterial.displacementMap;
-    if (outlineParameters !== void 0) {
+
+    if (outlineParameters !== undefined) {
       if (originalMaterial.visible === false) {
         material.visible = false;
       } else {
-        material.visible = outlineParameters.visible !== void 0 ? outlineParameters.visible : true;
+        material.visible = outlineParameters.visible !== undefined ? outlineParameters.visible : true;
       }
-      material.transparent = outlineParameters.alpha !== void 0 && outlineParameters.alpha < 1 ? true : originalMaterial.transparent;
-      if (outlineParameters.keepAlive !== void 0) {
+
+      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.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;
+
+    material.version = originalMaterial.version; // update outline material if necessary
   }
+
   function cleanupCache() {
-    let keys;
+    let keys; // clear originialMaterials
+
     keys = Object.keys(originalMaterials);
+
     for (let i = 0, il = keys.length; i < il; i++) {
-      originalMaterials[keys[i]] = void 0;
-    }
+      originalMaterials[keys[i]] = undefined;
+    } // clear originalOnBeforeRenders
+
+
     keys = Object.keys(originalOnBeforeRenders);
+
     for (let i = 0, il = keys.length; i < il; i++) {
-      originalOnBeforeRenders[keys[i]] = void 0;
-    }
+      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];
         }
@@ -220,33 +274,36 @@ const OutlineEffect = function(renderer, parameters) {
       }
     }
   }
-  this.render = function(scene, camera) {
+
+  this.render = function (scene, camera) {
     let renderTarget;
     let forceClear = false;
-    if (arguments[2] !== void 0) {
-      console.warn(
-        "THREE.OutlineEffect.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead."
-      );
+
+    if (arguments[2] !== undefined) {
+      console.warn('THREE.OutlineEffect.render(): the renderTarget argument has been removed. Use .setRenderTarget() instead.');
       renderTarget = arguments[2];
     }
-    if (arguments[3] !== void 0) {
-      console.warn("THREE.OutlineEffect.render(): the forceClear argument has been removed. Use .clear() instead.");
+
+    if (arguments[3] !== undefined) {
+      console.warn('THREE.OutlineEffect.render(): the forceClear argument has been removed. Use .clear() instead.');
       forceClear = arguments[3];
     }
-    if (renderTarget !== void 0)
-      renderer.setRenderTarget(renderTarget);
-    if (forceClear)
-      renderer.clear();
+
+    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;
@@ -265,31 +322,57 @@ const OutlineEffect = function(renderer, parameters) {
     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) => {
+
+  this.setPixelRatio = value => {
     renderer.setPixelRatio(value);
   };
-  this.getSize = (target) => renderer.getSize(target);
+
+  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) => {
+
+  this.setScissorTest = boolean => {
     renderer.setScissorTest(boolean);
   };
-  this.setRenderTarget = (renderTarget) => {
+
+  this.setRenderTarget = renderTarget => {
     renderer.setRenderTarget(renderTarget);
   };
 };
-exports.OutlineEffect = OutlineEffect;
+
+export { OutlineEffect };

package/effects/ParallaxBarrierEffect.cjs.js

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

@@ -1,56 +1,54 @@
-"use strict";
-Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
-const THREE = require("three");
-const ParallaxBarrierEffect = function(renderer) {
-  const _camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
-  const _scene = new THREE.Scene();
-  const _stereo = new THREE.StereoCamera();
+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: THREE.LinearFilter,
-    magFilter: THREE.NearestFilter,
-    format: THREE.RGBAFormat
+    minFilter: LinearFilter,
+    magFilter: NearestFilter,
+    format: RGBAFormat
   };
-  const _renderTargetL = new THREE.WebGLRenderTarget(512, 512, _params);
-  const _renderTargetR = new THREE.WebGLRenderTarget(512, 512, _params);
-  const _material = new THREE.ShaderMaterial({
+
+  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 }
+      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")
+    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 THREE.Mesh(new THREE.PlaneGeometry(2, 2), _material);
+
+  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();
+    if (camera.parent === null) camera.updateMatrixWorld();
+
     _stereo.update(camera);
+
     renderer.setRenderTarget(_renderTargetL);
     renderer.clear();
     renderer.render(scene, _stereo.cameraL);
@@ -61,4 +59,5 @@ const ParallaxBarrierEffect = function(renderer) {
     renderer.render(_scene, _camera);
   };
 };
-exports.ParallaxBarrierEffect = ParallaxBarrierEffect;
+
+export { ParallaxBarrierEffect };

package/effects/PeppersGhostEffect.cjs.js

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