three-stdlib 2.15.0 → 2.15.2

package/effects/OutlineEffect.mjs

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

@@ -1,54 +1,56 @@
-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();
-
+"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();
   const _params = {
-    minFilter: LinearFilter,
-    magFilter: NearestFilter,
-    format: RGBAFormat
+    minFilter: THREE.LinearFilter,
+    magFilter: THREE.NearestFilter,
+    format: THREE.RGBAFormat
   };
-
-  const _renderTargetL = new WebGLRenderTarget(512, 512, _params);
-
-  const _renderTargetR = new WebGLRenderTarget(512, 512, _params);
-
-  const _material = new ShaderMaterial({
+  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
-      }
+      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 Mesh(new PlaneGeometry(2, 2), _material);
-
+  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();
-
+    if (camera.parent === null)
+      camera.updateMatrixWorld();
     _stereo.update(camera);
-
     renderer.setRenderTarget(_renderTargetL);
     renderer.clear();
     renderer.render(scene, _stereo.cameraL);
@@ -59,5 +61,4 @@ const ParallaxBarrierEffect = function (renderer) {
     renderer.render(_scene, _camera);
   };
 };
-
-export { ParallaxBarrierEffect };
+exports.ParallaxBarrierEffect = ParallaxBarrierEffect;

package/effects/ParallaxBarrierEffect.mjs

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

package/effects/PeppersGhostEffect.js

@@ -1,40 +1,21 @@
-import { PerspectiveCamera, Vector3, Quaternion } from 'three';
-
-/**
- * peppers ghost effect based on http://www.instructables.com/id/Reflective-Prism/?ALLSTEPS
- */
-
-const PeppersGhostEffect = function (renderer) {
+"use strict";
+Object.defineProperties(exports, { __esModule: { value: true }, [Symbol.toStringTag]: { value: "Module" } });
+const THREE = require("three");
+const PeppersGhostEffect = function(renderer) {
   const scope = this;
   scope.cameraDistance = 15;
-  scope.reflectFromAbove = false; // Internals
-
+  scope.reflectFromAbove = false;
   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
-
-
+  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;
@@ -42,93 +23,63 @@ const PeppersGhostEffect = function (renderer) {
       _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
-
+    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); // back
-
-
+    _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); // left
-
+    _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); // right
-
+    _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 };
+exports.PeppersGhostEffect = PeppersGhostEffect;