three-stdlib 2.15.2 → 2.16.1

package/objects/Reflector.mjs

@@ -1,166 +0,0 @@
-import { Mesh, Color, Plane, Vector3, Matrix4, Vector4, PerspectiveCamera, WebGLRenderTarget, ShaderMaterial, UniformsUtils } from "three";
-class Reflector extends Mesh {
-  constructor(geometry, options = {}) {
-    super(geometry);
-    this.type = "Reflector";
-    const scope = this;
-    const color = options.color !== void 0 ? new Color(options.color) : new Color(8355711);
-    const textureWidth = options.textureWidth || 512;
-    const textureHeight = options.textureHeight || 512;
-    const clipBias = options.clipBias || 0;
-    const shader = options.shader || Reflector.ReflectorShader;
-    const reflectorPlane = new Plane();
-    const normal = new Vector3();
-    const reflectorWorldPosition = new Vector3();
-    const cameraWorldPosition = new Vector3();
-    const rotationMatrix = new Matrix4();
-    const lookAtPosition = new Vector3(0, 0, -1);
-    const clipPlane = new Vector4();
-    const view = new Vector3();
-    const target = new Vector3();
-    const q = new Vector4();
-    const textureMatrix = new Matrix4();
-    const virtualCamera = new PerspectiveCamera();
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight);
-    const material = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      fragmentShader: shader.fragmentShader,
-      vertexShader: shader.vertexShader
-    });
-    material.uniforms["tDiffuse"].value = renderTarget.texture;
-    material.uniforms["color"].value = color;
-    material.uniforms["textureMatrix"].value = textureMatrix;
-    this.material = material;
-    this.onBeforeRender = function(renderer, scene, camera) {
-      reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
-      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
-      rotationMatrix.extractRotation(scope.matrixWorld);
-      normal.set(0, 0, 1);
-      normal.applyMatrix4(rotationMatrix);
-      view.subVectors(reflectorWorldPosition, cameraWorldPosition);
-      if (view.dot(normal) > 0)
-        return;
-      view.reflect(normal).negate();
-      view.add(reflectorWorldPosition);
-      rotationMatrix.extractRotation(camera.matrixWorld);
-      lookAtPosition.set(0, 0, -1);
-      lookAtPosition.applyMatrix4(rotationMatrix);
-      lookAtPosition.add(cameraWorldPosition);
-      target.subVectors(reflectorWorldPosition, lookAtPosition);
-      target.reflect(normal).negate();
-      target.add(reflectorWorldPosition);
-      virtualCamera.position.copy(view);
-      virtualCamera.up.set(0, 1, 0);
-      virtualCamera.up.applyMatrix4(rotationMatrix);
-      virtualCamera.up.reflect(normal);
-      virtualCamera.lookAt(target);
-      virtualCamera.far = camera.far;
-      virtualCamera.updateMatrixWorld();
-      virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
-      textureMatrix.set(0.5, 0, 0, 0.5, 0, 0.5, 0, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0, 1);
-      textureMatrix.multiply(virtualCamera.projectionMatrix);
-      textureMatrix.multiply(virtualCamera.matrixWorldInverse);
-      textureMatrix.multiply(scope.matrixWorld);
-      reflectorPlane.setFromNormalAndCoplanarPoint(normal, reflectorWorldPosition);
-      reflectorPlane.applyMatrix4(virtualCamera.matrixWorldInverse);
-      clipPlane.set(reflectorPlane.normal.x, reflectorPlane.normal.y, reflectorPlane.normal.z, reflectorPlane.constant);
-      const projectionMatrix = virtualCamera.projectionMatrix;
-      q.x = (Math.sign(clipPlane.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
-      q.y = (Math.sign(clipPlane.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
-      q.z = -1;
-      q.w = (1 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
-      clipPlane.multiplyScalar(2 / clipPlane.dot(q));
-      projectionMatrix.elements[2] = clipPlane.x;
-      projectionMatrix.elements[6] = clipPlane.y;
-      projectionMatrix.elements[10] = clipPlane.z + 1 - clipBias;
-      projectionMatrix.elements[14] = clipPlane.w;
-      renderTarget.texture.encoding = renderer.outputEncoding;
-      scope.visible = false;
-      const currentRenderTarget = renderer.getRenderTarget();
-      const currentXrEnabled = renderer.xr.enabled;
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-      renderer.xr.enabled = false;
-      renderer.shadowMap.autoUpdate = false;
-      renderer.setRenderTarget(renderTarget);
-      renderer.state.buffers.depth.setMask(true);
-      if (renderer.autoClear === false)
-        renderer.clear();
-      renderer.render(scene, virtualCamera);
-      renderer.xr.enabled = currentXrEnabled;
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-      renderer.setRenderTarget(currentRenderTarget);
-      const viewport = camera.viewport;
-      if (viewport !== void 0) {
-        renderer.state.viewport(viewport);
-      }
-      scope.visible = true;
-    };
-    this.getRenderTarget = function() {
-      return renderTarget;
-    };
-    this.dispose = function() {
-      renderTarget.dispose();
-      scope.material.dispose();
-    };
-  }
-}
-Reflector.prototype.isReflector = true;
-Reflector.ReflectorShader = {
-  uniforms: {
-    color: {
-      value: null
-    },
-    tDiffuse: {
-      value: null
-    },
-    textureMatrix: {
-      value: null
-    }
-  },
-  vertexShader: `
-		uniform mat4 textureMatrix;
-		varying vec4 vUv;
-
-		#include <common>
-		#include <logdepthbuf_pars_vertex>
-
-		void main() {
-
-			vUv = textureMatrix * vec4( position, 1.0 );
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-			#include <logdepthbuf_vertex>
-
-		}`,
-  fragmentShader: `
-		uniform vec3 color;
-		uniform sampler2D tDiffuse;
-		varying vec4 vUv;
-
-		#include <logdepthbuf_pars_fragment>
-
-		float blendOverlay( float base, float blend ) {
-
-			return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
-
-		}
-
-		vec3 blendOverlay( vec3 base, vec3 blend ) {
-
-			return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );
-
-		}
-
-		void main() {
-
-			#include <logdepthbuf_fragment>
-
-			vec4 base = texture2DProj( tDiffuse, vUv );
-			gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
-
-		}`
-};
-export {
-  Reflector
-};

package/objects/ReflectorForSSRPass.mjs

@@ -1,247 +0,0 @@
-import { Mesh, Color, Vector3, Vector2, Matrix4, PerspectiveCamera, DepthTexture, UnsignedShortType, NearestFilter, WebGLRenderTarget, ShaderMaterial, UniformsUtils, Plane } from "three";
-class ReflectorForSSRPass extends Mesh {
-  constructor(geometry, options = {}) {
-    super(geometry);
-    this.type = "ReflectorForSSRPass";
-    const scope = this;
-    const color = options.color !== void 0 ? new Color(options.color) : new Color(8355711);
-    const textureWidth = options.textureWidth || 512;
-    const textureHeight = options.textureHeight || 512;
-    const clipBias = options.clipBias || 0;
-    const shader = options.shader || ReflectorForSSRPass.ReflectorShader;
-    const useDepthTexture = options.useDepthTexture === true;
-    const yAxis = new Vector3(0, 1, 0);
-    const vecTemp0 = new Vector3();
-    const vecTemp1 = new Vector3();
-    scope.needsUpdate = false;
-    scope.maxDistance = ReflectorForSSRPass.ReflectorShader.uniforms.maxDistance.value;
-    scope.opacity = ReflectorForSSRPass.ReflectorShader.uniforms.opacity.value;
-    scope.color = color;
-    scope.resolution = options.resolution || new Vector2(window.innerWidth, window.innerHeight);
-    scope._distanceAttenuation = ReflectorForSSRPass.ReflectorShader.defines.DISTANCE_ATTENUATION;
-    Object.defineProperty(scope, "distanceAttenuation", {
-      get() {
-        return scope._distanceAttenuation;
-      },
-      set(val) {
-        if (scope._distanceAttenuation === val)
-          return;
-        scope._distanceAttenuation = val;
-        scope.material.defines.DISTANCE_ATTENUATION = val;
-        scope.material.needsUpdate = true;
-      }
-    });
-    scope._fresnel = ReflectorForSSRPass.ReflectorShader.defines.FRESNEL;
-    Object.defineProperty(scope, "fresnel", {
-      get() {
-        return scope._fresnel;
-      },
-      set(val) {
-        if (scope._fresnel === val)
-          return;
-        scope._fresnel = val;
-        scope.material.defines.FRESNEL = val;
-        scope.material.needsUpdate = true;
-      }
-    });
-    const normal = new Vector3();
-    const reflectorWorldPosition = new Vector3();
-    const cameraWorldPosition = new Vector3();
-    const rotationMatrix = new Matrix4();
-    const lookAtPosition = new Vector3(0, 0, -1);
-    const view = new Vector3();
-    const target = new Vector3();
-    const textureMatrix = new Matrix4();
-    const virtualCamera = new PerspectiveCamera();
-    let depthTexture;
-    if (useDepthTexture) {
-      depthTexture = new DepthTexture();
-      depthTexture.type = UnsignedShortType;
-      depthTexture.minFilter = NearestFilter;
-      depthTexture.magFilter = NearestFilter;
-    }
-    const parameters = {
-      depthTexture: useDepthTexture ? depthTexture : null
-    };
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight, parameters);
-    const material = new ShaderMaterial({
-      transparent: useDepthTexture,
-      defines: Object.assign({}, ReflectorForSSRPass.ReflectorShader.defines, {
-        useDepthTexture
-      }),
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      fragmentShader: shader.fragmentShader,
-      vertexShader: shader.vertexShader
-    });
-    material.uniforms["tDiffuse"].value = renderTarget.texture;
-    material.uniforms["color"].value = scope.color;
-    material.uniforms["textureMatrix"].value = textureMatrix;
-    if (useDepthTexture) {
-      material.uniforms["tDepth"].value = renderTarget.depthTexture;
-    }
-    this.material = material;
-    const globalPlane = new Plane(new Vector3(0, 1, 0), clipBias);
-    const globalPlanes = [globalPlane];
-    this.doRender = function(renderer, scene, camera) {
-      material.uniforms["maxDistance"].value = scope.maxDistance;
-      material.uniforms["color"].value = scope.color;
-      material.uniforms["opacity"].value = scope.opacity;
-      vecTemp0.copy(camera.position).normalize();
-      vecTemp1.copy(vecTemp0).reflect(yAxis);
-      material.uniforms["fresnelCoe"].value = (vecTemp0.dot(vecTemp1) + 1) / 2;
-      reflectorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
-      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
-      rotationMatrix.extractRotation(scope.matrixWorld);
-      normal.set(0, 0, 1);
-      normal.applyMatrix4(rotationMatrix);
-      view.subVectors(reflectorWorldPosition, cameraWorldPosition);
-      if (view.dot(normal) > 0)
-        return;
-      view.reflect(normal).negate();
-      view.add(reflectorWorldPosition);
-      rotationMatrix.extractRotation(camera.matrixWorld);
-      lookAtPosition.set(0, 0, -1);
-      lookAtPosition.applyMatrix4(rotationMatrix);
-      lookAtPosition.add(cameraWorldPosition);
-      target.subVectors(reflectorWorldPosition, lookAtPosition);
-      target.reflect(normal).negate();
-      target.add(reflectorWorldPosition);
-      virtualCamera.position.copy(view);
-      virtualCamera.up.set(0, 1, 0);
-      virtualCamera.up.applyMatrix4(rotationMatrix);
-      virtualCamera.up.reflect(normal);
-      virtualCamera.lookAt(target);
-      virtualCamera.far = camera.far;
-      virtualCamera.updateMatrixWorld();
-      virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
-      material.uniforms["virtualCameraNear"].value = camera.near;
-      material.uniforms["virtualCameraFar"].value = camera.far;
-      material.uniforms["virtualCameraMatrixWorld"].value = virtualCamera.matrixWorld;
-      material.uniforms["virtualCameraProjectionMatrix"].value = camera.projectionMatrix;
-      material.uniforms["virtualCameraProjectionMatrixInverse"].value = camera.projectionMatrixInverse;
-      material.uniforms["resolution"].value = scope.resolution;
-      textureMatrix.set(0.5, 0, 0, 0.5, 0, 0.5, 0, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0, 1);
-      textureMatrix.multiply(virtualCamera.projectionMatrix);
-      textureMatrix.multiply(virtualCamera.matrixWorldInverse);
-      textureMatrix.multiply(scope.matrixWorld);
-      renderTarget.texture.encoding = renderer.outputEncoding;
-      const currentRenderTarget = renderer.getRenderTarget();
-      const currentXrEnabled = renderer.xr.enabled;
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-      const currentClippingPlanes = renderer.clippingPlanes;
-      renderer.xr.enabled = false;
-      renderer.shadowMap.autoUpdate = false;
-      renderer.clippingPlanes = globalPlanes;
-      renderer.setRenderTarget(renderTarget);
-      renderer.state.buffers.depth.setMask(true);
-      if (renderer.autoClear === false)
-        renderer.clear();
-      renderer.render(scene, virtualCamera);
-      renderer.xr.enabled = currentXrEnabled;
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-      renderer.clippingPlanes = currentClippingPlanes;
-      renderer.setRenderTarget(currentRenderTarget);
-      const viewport = camera.viewport;
-      if (viewport !== void 0) {
-        renderer.state.viewport(viewport);
-      }
-    };
-    this.getRenderTarget = function() {
-      return renderTarget;
-    };
-  }
-}
-ReflectorForSSRPass.prototype.isReflectorForSSRPass = true;
-ReflectorForSSRPass.ReflectorShader = {
-  defines: {
-    DISTANCE_ATTENUATION: true,
-    FRESNEL: true
-  },
-  uniforms: {
-    color: { value: null },
-    tDiffuse: { value: null },
-    tDepth: { value: null },
-    textureMatrix: { value: new Matrix4() },
-    maxDistance: { value: 180 },
-    opacity: { value: 0.5 },
-    fresnelCoe: { value: null },
-    virtualCameraNear: { value: null },
-    virtualCameraFar: { value: null },
-    virtualCameraProjectionMatrix: { value: new Matrix4() },
-    virtualCameraMatrixWorld: { value: new Matrix4() },
-    virtualCameraProjectionMatrixInverse: { value: new Matrix4() },
-    resolution: { value: new Vector2() }
-  },
-  vertexShader: `
-		uniform mat4 textureMatrix;
-		varying vec4 vUv;
-
-		void main() {
-
-			vUv = textureMatrix * vec4( position, 1.0 );
-
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-  fragmentShader: `
-		uniform vec3 color;
-		uniform sampler2D tDiffuse;
-		uniform sampler2D tDepth;
-		uniform float maxDistance;
-		uniform float opacity;
-		uniform float fresnelCoe;
-		uniform float virtualCameraNear;
-		uniform float virtualCameraFar;
-		uniform mat4 virtualCameraProjectionMatrix;
-		uniform mat4 virtualCameraProjectionMatrixInverse;
-		uniform mat4 virtualCameraMatrixWorld;
-		uniform vec2 resolution;
-		varying vec4 vUv;
-		#include <packing>
-		float blendOverlay( float base, float blend ) {
-			return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
-		}
-		vec3 blendOverlay( vec3 base, vec3 blend ) {
-			return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );
-		}
-		float getDepth( const in vec2 uv ) {
-			return texture2D( tDepth, uv ).x;
-		}
-		float getViewZ( const in float depth ) {
-			return perspectiveDepthToViewZ( depth, virtualCameraNear, virtualCameraFar );
-		}
-		vec3 getViewPosition( const in vec2 uv, const in float depth/*clip space*/, const in float clipW ) {
-			vec4 clipPosition = vec4( ( vec3( uv, depth ) - 0.5 ) * 2.0, 1.0 );//ndc
-			clipPosition *= clipW; //clip
-			return ( virtualCameraProjectionMatrixInverse * clipPosition ).xyz;//view
-		}
-		void main() {
-			vec4 base = texture2DProj( tDiffuse, vUv );
-			#ifdef useDepthTexture
-				vec2 uv=(gl_FragCoord.xy-.5)/resolution.xy;
-				uv.x=1.-uv.x;
-				float depth = texture2DProj( tDepth, vUv ).r;
-				float viewZ = getViewZ( depth );
-				float clipW = virtualCameraProjectionMatrix[2][3] * viewZ+virtualCameraProjectionMatrix[3][3];
-				vec3 viewPosition=getViewPosition( uv, depth, clipW );
-				vec3 worldPosition=(virtualCameraMatrixWorld*vec4(viewPosition,1)).xyz;
-				if(worldPosition.y>maxDistance) discard;
-				float op=opacity;
-				#ifdef DISTANCE_ATTENUATION
-					float ratio=1.-(worldPosition.y/maxDistance);
-					float attenuation=ratio*ratio;
-					op=opacity*attenuation;
-				#endif
-				#ifdef FRESNEL
-					op*=fresnelCoe;
-				#endif
-				gl_FragColor = vec4( blendOverlay( base.rgb, color ), op );
-			#else
-				gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
-			#endif
-		}
-	`
-};
-export {
-  ReflectorForSSRPass
-};

package/objects/ReflectorRTT.mjs

@@ -1,10 +0,0 @@
-import { Reflector } from "./Reflector.mjs";
-class ReflectorRTT extends Reflector {
-  constructor(geometry, options) {
-    super(geometry, options);
-    this.geometry.setDrawRange(0, 0);
-  }
-}
-export {
-  ReflectorRTT
-};

package/objects/Refractor.mjs

@@ -1,178 +0,0 @@
-import { Mesh, Color, PerspectiveCamera, Plane, Matrix4, WebGLRenderTarget, ShaderMaterial, UniformsUtils, Vector3, Quaternion, Vector4 } from "three";
-class Refractor extends Mesh {
-  constructor(geometry, options = {}) {
-    super(geometry);
-    this.type = "Refractor";
-    const scope = this;
-    const color = options.color !== void 0 ? new Color(options.color) : new Color(8355711);
-    const textureWidth = options.textureWidth || 512;
-    const textureHeight = options.textureHeight || 512;
-    const clipBias = options.clipBias || 0;
-    const shader = options.shader || Refractor.RefractorShader;
-    const virtualCamera = new PerspectiveCamera();
-    virtualCamera.matrixAutoUpdate = false;
-    virtualCamera.userData.refractor = true;
-    const refractorPlane = new Plane();
-    const textureMatrix = new Matrix4();
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight);
-    this.material = new ShaderMaterial({
-      uniforms: UniformsUtils.clone(shader.uniforms),
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      transparent: true
-    });
-    this.material.uniforms["color"].value = color;
-    this.material.uniforms["tDiffuse"].value = renderTarget.texture;
-    this.material.uniforms["textureMatrix"].value = textureMatrix;
-    const visible = function() {
-      const refractorWorldPosition = new Vector3();
-      const cameraWorldPosition = new Vector3();
-      const rotationMatrix = new Matrix4();
-      const view = new Vector3();
-      const normal = new Vector3();
-      return function visible2(camera) {
-        refractorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
-        cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
-        view.subVectors(refractorWorldPosition, cameraWorldPosition);
-        rotationMatrix.extractRotation(scope.matrixWorld);
-        normal.set(0, 0, 1);
-        normal.applyMatrix4(rotationMatrix);
-        return view.dot(normal) < 0;
-      };
-    }();
-    const updateRefractorPlane = function() {
-      const normal = new Vector3();
-      const position = new Vector3();
-      const quaternion = new Quaternion();
-      const scale = new Vector3();
-      return function updateRefractorPlane2() {
-        scope.matrixWorld.decompose(position, quaternion, scale);
-        normal.set(0, 0, 1).applyQuaternion(quaternion).normalize();
-        normal.negate();
-        refractorPlane.setFromNormalAndCoplanarPoint(normal, position);
-      };
-    }();
-    const updateVirtualCamera = function() {
-      const clipPlane = new Plane();
-      const clipVector = new Vector4();
-      const q = new Vector4();
-      return function updateVirtualCamera2(camera) {
-        virtualCamera.matrixWorld.copy(camera.matrixWorld);
-        virtualCamera.matrixWorldInverse.copy(virtualCamera.matrixWorld).invert();
-        virtualCamera.projectionMatrix.copy(camera.projectionMatrix);
-        virtualCamera.far = camera.far;
-        clipPlane.copy(refractorPlane);
-        clipPlane.applyMatrix4(virtualCamera.matrixWorldInverse);
-        clipVector.set(clipPlane.normal.x, clipPlane.normal.y, clipPlane.normal.z, clipPlane.constant);
-        const projectionMatrix = virtualCamera.projectionMatrix;
-        q.x = (Math.sign(clipVector.x) + projectionMatrix.elements[8]) / projectionMatrix.elements[0];
-        q.y = (Math.sign(clipVector.y) + projectionMatrix.elements[9]) / projectionMatrix.elements[5];
-        q.z = -1;
-        q.w = (1 + projectionMatrix.elements[10]) / projectionMatrix.elements[14];
-        clipVector.multiplyScalar(2 / clipVector.dot(q));
-        projectionMatrix.elements[2] = clipVector.x;
-        projectionMatrix.elements[6] = clipVector.y;
-        projectionMatrix.elements[10] = clipVector.z + 1 - clipBias;
-        projectionMatrix.elements[14] = clipVector.w;
-      };
-    }();
-    function updateTextureMatrix(camera) {
-      textureMatrix.set(0.5, 0, 0, 0.5, 0, 0.5, 0, 0.5, 0, 0, 0.5, 0.5, 0, 0, 0, 1);
-      textureMatrix.multiply(camera.projectionMatrix);
-      textureMatrix.multiply(camera.matrixWorldInverse);
-      textureMatrix.multiply(scope.matrixWorld);
-    }
-    function render(renderer, scene, camera) {
-      scope.visible = false;
-      const currentRenderTarget = renderer.getRenderTarget();
-      const currentXrEnabled = renderer.xr.enabled;
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-      renderer.xr.enabled = false;
-      renderer.shadowMap.autoUpdate = false;
-      renderer.setRenderTarget(renderTarget);
-      if (renderer.autoClear === false)
-        renderer.clear();
-      renderer.render(scene, virtualCamera);
-      renderer.xr.enabled = currentXrEnabled;
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-      renderer.setRenderTarget(currentRenderTarget);
-      const viewport = camera.viewport;
-      if (viewport !== void 0) {
-        renderer.state.viewport(viewport);
-      }
-      scope.visible = true;
-    }
-    this.onBeforeRender = function(renderer, scene, camera) {
-      renderTarget.texture.encoding = renderer.outputEncoding;
-      if (camera.userData.refractor === true)
-        return;
-      if (!visible(camera) === true)
-        return;
-      updateRefractorPlane();
-      updateTextureMatrix(camera);
-      updateVirtualCamera(camera);
-      render(renderer, scene, camera);
-    };
-    this.getRenderTarget = function() {
-      return renderTarget;
-    };
-    this.dispose = function() {
-      renderTarget.dispose();
-      scope.material.dispose();
-    };
-  }
-}
-Refractor.prototype.isRefractor = true;
-Refractor.RefractorShader = {
-  uniforms: {
-    color: {
-      value: null
-    },
-    tDiffuse: {
-      value: null
-    },
-    textureMatrix: {
-      value: null
-    }
-  },
-  vertexShader: `
-
-		uniform mat4 textureMatrix;
-
-		varying vec4 vUv;
-
-		void main() {
-
-			vUv = textureMatrix * vec4( position, 1.0 );
-			gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );
-
-		}`,
-  fragmentShader: `
-
-		uniform vec3 color;
-		uniform sampler2D tDiffuse;
-
-		varying vec4 vUv;
-
-		float blendOverlay( float base, float blend ) {
-
-			return( base < 0.5 ? ( 2.0 * base * blend ) : ( 1.0 - 2.0 * ( 1.0 - base ) * ( 1.0 - blend ) ) );
-
-		}
-
-		vec3 blendOverlay( vec3 base, vec3 blend ) {
-
-			return vec3( blendOverlay( base.r, blend.r ), blendOverlay( base.g, blend.g ), blendOverlay( base.b, blend.b ) );
-
-		}
-
-		void main() {
-
-			vec4 base = texture2DProj( tDiffuse, vUv );
-			gl_FragColor = vec4( blendOverlay( base.rgb, color ), 1.0 );
-
-		}`
-};
-export {
-  Refractor
-};

package/objects/ShadowMesh.mjs

@@ -1,41 +0,0 @@
-import { Matrix4, Mesh, MeshBasicMaterial } from "three";
-const _shadowMatrix = new Matrix4();
-class ShadowMesh extends Mesh {
-  constructor(mesh) {
-    const shadowMaterial = new MeshBasicMaterial({
-      color: 0,
-      transparent: true,
-      opacity: 0.6,
-      depthWrite: false
-    });
-    super(mesh.geometry, shadowMaterial);
-    this.meshMatrix = mesh.matrixWorld;
-    this.frustumCulled = false;
-    this.matrixAutoUpdate = false;
-  }
-  update(plane, lightPosition4D) {
-    const dot = plane.normal.x * lightPosition4D.x + plane.normal.y * lightPosition4D.y + plane.normal.z * lightPosition4D.z + -plane.constant * lightPosition4D.w;
-    const sme = _shadowMatrix.elements;
-    sme[0] = dot - lightPosition4D.x * plane.normal.x;
-    sme[4] = -lightPosition4D.x * plane.normal.y;
-    sme[8] = -lightPosition4D.x * plane.normal.z;
-    sme[12] = -lightPosition4D.x * -plane.constant;
-    sme[1] = -lightPosition4D.y * plane.normal.x;
-    sme[5] = dot - lightPosition4D.y * plane.normal.y;
-    sme[9] = -lightPosition4D.y * plane.normal.z;
-    sme[13] = -lightPosition4D.y * -plane.constant;
-    sme[2] = -lightPosition4D.z * plane.normal.x;
-    sme[6] = -lightPosition4D.z * plane.normal.y;
-    sme[10] = dot - lightPosition4D.z * plane.normal.z;
-    sme[14] = -lightPosition4D.z * -plane.constant;
-    sme[3] = -lightPosition4D.w * plane.normal.x;
-    sme[7] = -lightPosition4D.w * plane.normal.y;
-    sme[11] = -lightPosition4D.w * plane.normal.z;
-    sme[15] = dot - lightPosition4D.w * -plane.constant;
-    this.matrix.multiplyMatrices(_shadowMatrix, this.meshMatrix);
-  }
-}
-ShadowMesh.prototype.isShadowMesh = true;
-export {
-  ShadowMesh
-};