three-stdlib 2.22.9 → 2.23.0

package/dist/effects/ParallaxBarrierEffect.js

@@ -1,64 +1,65 @@
 "use strict";
 Object.defineProperty(exports, 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();
-  const _params = {
-    minFilter: THREE.LinearFilter,
-    magFilter: THREE.NearestFilter,
-    format: THREE.RGBAFormat
-  };
-  const _renderTargetL = new THREE.WebGLRenderTarget(512, 512, _params);
-  const _renderTargetR = new THREE.WebGLRenderTarget(512, 512, _params);
-  const _material = new THREE.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 THREE.Mesh(new THREE.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);
-  };
-};
+class ParallaxBarrierEffect {
+  constructor(renderer) {
+    const _camera = new THREE.OrthographicCamera(-1, 1, 1, -1, 0, 1);
+    const _scene = new THREE.Scene();
+    const _stereo = new THREE.StereoCamera();
+    const _params = { minFilter: THREE.LinearFilter, magFilter: THREE.NearestFilter, format: THREE.RGBAFormat };
+    const _renderTargetL = new THREE.WebGLRenderTarget(512, 512, _params);
+    const _renderTargetR = new THREE.WebGLRenderTarget(512, 512, _params);
+    const _material = new THREE.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 );",
+        "	}",
+        "	#include <tonemapping_fragment>",
+        "	#include <encodings_fragment>",
+        "}"
+      ].join("\n")
+    });
+    const mesh = new THREE.Mesh(new THREE.PlaneGeometry(2, 2), _material);
+    _scene.add(mesh);
+    this.setSize = function(width, height) {
+      renderer.setSize(width, height);
+      const pixelRatio = renderer.getPixelRatio();
+      _renderTargetL.setSize(width * pixelRatio, height * pixelRatio);
+      _renderTargetR.setSize(width * pixelRatio, height * pixelRatio);
+    };
+    this.render = function(scene, camera) {
+      if (scene.matrixWorldAutoUpdate === true)
+        scene.updateMatrixWorld();
+      if (camera.parent === null && camera.matrixWorldAutoUpdate === true)
+        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);
+    };
+  }
+}
 exports.ParallaxBarrierEffect = ParallaxBarrierEffect;

package/dist/effects/ParallaxBarrierEffect.mjs

@@ -1,64 +1,65 @@
 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);
-  };
-};
+class ParallaxBarrierEffect {
+  constructor(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 );",
+        "	}",
+        "	#include <tonemapping_fragment>",
+        "	#include <encodings_fragment>",
+        "}"
+      ].join("\n")
+    });
+    const mesh = new Mesh(new PlaneGeometry(2, 2), _material);
+    _scene.add(mesh);
+    this.setSize = function(width, height) {
+      renderer.setSize(width, height);
+      const pixelRatio = renderer.getPixelRatio();
+      _renderTargetL.setSize(width * pixelRatio, height * pixelRatio);
+      _renderTargetR.setSize(width * pixelRatio, height * pixelRatio);
+    };
+    this.render = function(scene, camera) {
+      if (scene.matrixWorldAutoUpdate === true)
+        scene.updateMatrixWorld();
+      if (camera.parent === null && camera.matrixWorldAutoUpdate === true)
+        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.js

@@ -1,85 +1,88 @@
 "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);
-  };
-};
+class PeppersGhostEffect {
+  constructor(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 = function(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 = function(scene, camera) {
+      if (scene.matrixWorldAutoUpdate === true)
+        scene.updateMatrixWorld();
+      if (camera.parent === null && camera.matrixWorldAutoUpdate === true)
+        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

@@ -1,85 +1,88 @@
 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);
-  };
-};
+class PeppersGhostEffect {
+  constructor(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 = function(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 = function(scene, camera) {
+      if (scene.matrixWorldAutoUpdate === true)
+        scene.updateMatrixWorld();
+      if (camera.parent === null && camera.matrixWorldAutoUpdate === true)
+        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
 };