three-stdlib 2.16.0 → 2.16.1

package/effects/AnaglyphEffect.mjs

@@ -1,120 +0,0 @@
-import { Matrix3, OrthographicCamera, Scene, StereoCamera, LinearFilter, NearestFilter, RGBAFormat, WebGLRenderTarget, ShaderMaterial, Mesh, PlaneGeometry } from "three";
-const AnaglyphEffect = function(renderer, width, height) {
-  this.colorMatrixLeft = new Matrix3().fromArray([
-    0.4561,
-    -0.0400822,
-    -0.0152161,
-    0.500484,
-    -0.0378246,
-    -0.0205971,
-    0.176381,
-    -0.0157589,
-    -546856e-8
-  ]);
-  this.colorMatrixRight = new Matrix3().fromArray([
-    -0.0434706,
-    0.378476,
-    -0.0721527,
-    -0.0879388,
-    0.73364,
-    -0.112961,
-    -155529e-8,
-    -0.0184503,
-    1.2264
-  ]);
-  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
-  };
-  if (width === void 0)
-    width = 512;
-  if (height === void 0)
-    height = 512;
-  const _renderTargetL = new WebGLRenderTarget(width, height, _params);
-  const _renderTargetR = new WebGLRenderTarget(width, height, _params);
-  const _material = new ShaderMaterial({
-    uniforms: {
-      mapLeft: { value: _renderTargetL.texture },
-      mapRight: { value: _renderTargetR.texture },
-      colorMatrixLeft: { value: this.colorMatrixLeft },
-      colorMatrixRight: { value: this.colorMatrixRight }
-    },
-    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;",
-      "uniform mat3 colorMatrixLeft;",
-      "uniform mat3 colorMatrixRight;",
-      "float lin( float c ) {",
-      "	return c <= 0.04045 ? c * 0.0773993808 :",
-      "			pow( c * 0.9478672986 + 0.0521327014, 2.4 );",
-      "}",
-      "vec4 lin( vec4 c ) {",
-      "	return vec4( lin( c.r ), lin( c.g ), lin( c.b ), c.a );",
-      "}",
-      "float dev( float c ) {",
-      "	return c <= 0.0031308 ? c * 12.92",
-      "			: pow( c, 0.41666 ) * 1.055 - 0.055;",
-      "}",
-      "void main() {",
-      "	vec2 uv = vUv;",
-      "	vec4 colorL = lin( texture2D( mapLeft, uv ) );",
-      "	vec4 colorR = lin( texture2D( mapRight, uv ) );",
-      "	vec3 color = clamp(",
-      "			colorMatrixLeft * colorL.rgb +",
-      "			colorMatrixRight * colorR.rgb, 0., 1. );",
-      "	gl_FragColor = vec4(",
-      "			dev( color.r ), dev( color.g ), dev( color.b ),",
-      "			max( colorL.a, colorR.a ) );",
-      "}"
-    ].join("\n")
-  });
-  const _mesh = new Mesh(new PlaneGeometry(2, 2), _material);
-  _scene.add(_mesh);
-  this.setSize = (width2, height2) => {
-    renderer.setSize(width2, height2);
-    const pixelRatio = renderer.getPixelRatio();
-    _renderTargetL.setSize(width2 * pixelRatio, height2 * pixelRatio);
-    _renderTargetR.setSize(width2 * pixelRatio, height2 * pixelRatio);
-  };
-  this.render = (scene, camera) => {
-    const currentRenderTarget = renderer.getRenderTarget();
-    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);
-    renderer.setRenderTarget(currentRenderTarget);
-  };
-  this.dispose = () => {
-    if (_renderTargetL)
-      _renderTargetL.dispose();
-    if (_renderTargetR)
-      _renderTargetR.dispose();
-    if (_mesh)
-      _mesh.geometry.dispose();
-    if (_material)
-      _material.dispose();
-  };
-};
-export {
-  AnaglyphEffect
-};

package/effects/AsciiEffect.mjs

@@ -1,173 +0,0 @@
-const AsciiEffect = function(renderer, charSet, options) {
-  charSet = charSet === void 0 ? " .:-=+*#%@" : charSet;
-  if (!options)
-    options = {};
-  const bResolution = !options["resolution"] ? 0.15 : options["resolution"];
-  const iScale = !options["scale"] ? 1 : options["scale"];
-  const bColor = !options["color"] ? false : options["color"];
-  const bAlpha = !options["alpha"] ? false : options["alpha"];
-  const bBlock = !options["block"] ? false : options["block"];
-  const bInvert = !options["invert"] ? false : options["invert"];
-  const strResolution = "low";
-  let width, height;
-  const domElement = document.createElement("div");
-  domElement.style.cursor = "default";
-  const oAscii = document.createElement("table");
-  domElement.appendChild(oAscii);
-  let iWidth, iHeight;
-  let oImg;
-  this.setSize = (w, h) => {
-    width = w;
-    height = h;
-    renderer.setSize(w, h);
-    initAsciiSize();
-  };
-  this.render = (scene, camera) => {
-    renderer.render(scene, camera);
-    asciifyImage(renderer, oAscii);
-  };
-  this.domElement = domElement;
-  function initAsciiSize() {
-    iWidth = Math.round(width * fResolution);
-    iHeight = Math.round(height * fResolution);
-    oCanvas.width = iWidth;
-    oCanvas.height = iHeight;
-    oImg = renderer.domElement;
-    if (oImg.style.backgroundColor) {
-      oAscii.rows[0].cells[0].style.backgroundColor = oImg.style.backgroundColor;
-      oAscii.rows[0].cells[0].style.color = oImg.style.color;
-    }
-    oAscii.cellSpacing = 0;
-    oAscii.cellPadding = 0;
-    const oStyle = oAscii.style;
-    oStyle.display = "inline";
-    oStyle.width = `${Math.round(iWidth / fResolution * iScale)}px`;
-    oStyle.height = `${Math.round(iHeight / fResolution * iScale)}px`;
-    oStyle.whiteSpace = "pre";
-    oStyle.margin = "0px";
-    oStyle.padding = "0px";
-    oStyle.letterSpacing = `${fLetterSpacing}px`;
-    oStyle.fontFamily = strFont;
-    oStyle.fontSize = `${fFontSize}px`;
-    oStyle.lineHeight = `${fLineHeight}px`;
-    oStyle.textAlign = "left";
-    oStyle.textDecoration = "none";
-  }
-  const aDefaultCharList = " .,:;i1tfLCG08@".split("");
-  const aDefaultColorCharList = " CGO08@".split("");
-  var strFont = "courier new, monospace";
-  const oCanvasImg = renderer.domElement;
-  var oCanvas = document.createElement("canvas");
-  if (!oCanvas.getContext) {
-    return;
-  }
-  const oCtx = oCanvas.getContext("2d");
-  if (!oCtx.getImageData) {
-    return;
-  }
-  let aCharList = bColor ? aDefaultColorCharList : aDefaultCharList;
-  if (charSet)
-    aCharList = charSet;
-  var fResolution = 0.5;
-  switch (strResolution) {
-    case "low":
-      fResolution = 0.25;
-      break;
-    case "medium":
-      fResolution = 0.5;
-      break;
-    case "high":
-      fResolution = 1;
-      break;
-  }
-  if (bResolution)
-    fResolution = bResolution;
-  var fFontSize = 2 / fResolution * iScale;
-  var fLineHeight = 2 / fResolution * iScale;
-  var fLetterSpacing = 0;
-  if (strResolution == "low") {
-    switch (iScale) {
-      case 1:
-        fLetterSpacing = -1;
-        break;
-      case 2:
-      case 3:
-        fLetterSpacing = -2.1;
-        break;
-      case 4:
-        fLetterSpacing = -3.1;
-        break;
-      case 5:
-        fLetterSpacing = -4.15;
-        break;
-    }
-  }
-  if (strResolution == "medium") {
-    switch (iScale) {
-      case 1:
-        fLetterSpacing = 0;
-        break;
-      case 2:
-        fLetterSpacing = -1;
-        break;
-      case 3:
-        fLetterSpacing = -1.04;
-        break;
-      case 4:
-      case 5:
-        fLetterSpacing = -2.1;
-        break;
-    }
-  }
-  if (strResolution == "high") {
-    switch (iScale) {
-      case 1:
-      case 2:
-        fLetterSpacing = 0;
-        break;
-      case 3:
-      case 4:
-      case 5:
-        fLetterSpacing = -1;
-        break;
-    }
-  }
-  function asciifyImage(canvasRenderer, oAscii2) {
-    oCtx.clearRect(0, 0, iWidth, iHeight);
-    oCtx.drawImage(oCanvasImg, 0, 0, iWidth, iHeight);
-    const oImgData = oCtx.getImageData(0, 0, iWidth, iHeight).data;
-    let strChars = "";
-    for (let y = 0; y < iHeight; y += 2) {
-      for (let x = 0; x < iWidth; x++) {
-        const iOffset = (y * iWidth + x) * 4;
-        const iRed = oImgData[iOffset];
-        const iGreen = oImgData[iOffset + 1];
-        const iBlue = oImgData[iOffset + 2];
-        const iAlpha = oImgData[iOffset + 3];
-        let iCharIdx;
-        let fBrightness;
-        fBrightness = (0.3 * iRed + 0.59 * iGreen + 0.11 * iBlue) / 255;
-        if (iAlpha == 0) {
-          fBrightness = 1;
-        }
-        iCharIdx = Math.floor((1 - fBrightness) * (aCharList.length - 1));
-        if (bInvert) {
-          iCharIdx = aCharList.length - iCharIdx - 1;
-        }
-        let strThisChar = aCharList[iCharIdx];
-        if (strThisChar === void 0 || strThisChar == " ")
-          strThisChar = "&nbsp;";
-        if (bColor) {
-          strChars += `<span style='color:rgb(${iRed},${iGreen},${iBlue});${bBlock ? `background-color:rgb(${iRed},${iGreen},${iBlue});` : ""}${bAlpha ? `opacity:${iAlpha / 255};` : ""}'>${strThisChar}</span>`;
-        } else {
-          strChars += strThisChar;
-        }
-      }
-      strChars += "<br/>";
-    }
-    oAscii2.innerHTML = `<tr><td>${strChars}</td></tr>`;
-  }
-};
-export {
-  AsciiEffect
-};

package/effects/OutlineEffect.mjs

@@ -1,295 +0,0 @@
-import { Color, ShaderMaterial, UniformsUtils, UniformsLib, BackSide } from "three";
-const OutlineEffect = function(renderer, parameters) {
-  parameters = parameters || {};
-  this.enabled = true;
-  const defaultThickness = parameters.defaultThickness !== void 0 ? parameters.defaultThickness : 3e-3;
-  const defaultColor = new 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 cache = {};
-  const removeThresholdCount = 60;
-  const originalMaterials = {};
-  const originalOnBeforeRenders = {};
-  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;",
-    "	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");
-  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 === void 0) {
-      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 !== void 0) {
-      if (geometry.isBufferGeometry) {
-        hasNormals = geometry.attributes.normal !== void 0;
-      } else {
-        hasNormals = true;
-      }
-    }
-    return object.isMesh === true && object.material !== void 0 && 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(renderer2, scene, camera, geometry, material) {
-    const originalMaterial = originalMaterials[material.uuid];
-    if (originalMaterial === void 0)
-      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) {
-        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 (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 !== void 0) {
-      if (originalMaterial.visible === false) {
-        material.visible = false;
-      } else {
-        material.visible = outlineParameters.visible !== void 0 ? outlineParameters.visible : true;
-      }
-      material.transparent = outlineParameters.alpha !== void 0 && outlineParameters.alpha < 1 ? true : originalMaterial.transparent;
-      if (outlineParameters.keepAlive !== void 0) {
-        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;
-  }
-  function cleanupCache() {
-    let keys;
-    keys = Object.keys(originalMaterials);
-    for (let i = 0, il = keys.length; i < il; i++) {
-      originalMaterials[keys[i]] = void 0;
-    }
-    keys = Object.keys(originalOnBeforeRenders);
-    for (let i = 0, il = keys.length; i < il; i++) {
-      originalOnBeforeRenders[keys[i]] = void 0;
-    }
-    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] !== void 0) {
-      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.");
-      forceClear = arguments[3];
-    }
-    if (renderTarget !== void 0)
-      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;
-  };
-  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.mjs

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