three-stdlib 2.15.2 → 2.16.1

package/objects/Sky.mjs

@@ -1,124 +0,0 @@
-import { Mesh, BoxGeometry, Vector3, ShaderMaterial, UniformsUtils, BackSide } from "three";
-const _Sky = class extends Mesh {
-  constructor() {
-    super(new BoxGeometry(1, 1, 1), _Sky.material);
-  }
-};
-let Sky = _Sky;
-Sky.SkyShader = {
-  uniforms: {
-    turbidity: { value: 2 },
-    rayleigh: { value: 1 },
-    mieCoefficient: { value: 5e-3 },
-    mieDirectionalG: { value: 0.8 },
-    sunPosition: { value: new Vector3() },
-    up: { value: new Vector3(0, 1, 0) }
-  },
-  vertexShader: [
-    "uniform vec3 sunPosition;",
-    "uniform float rayleigh;",
-    "uniform float turbidity;",
-    "uniform float mieCoefficient;",
-    "uniform vec3 up;",
-    "varying vec3 vWorldPosition;",
-    "varying vec3 vSunDirection;",
-    "varying float vSunfade;",
-    "varying vec3 vBetaR;",
-    "varying vec3 vBetaM;",
-    "varying float vSunE;",
-    "const float e = 2.71828182845904523536028747135266249775724709369995957;",
-    "const float pi = 3.141592653589793238462643383279502884197169;",
-    "const vec3 lambda = vec3( 680E-9, 550E-9, 450E-9 );",
-    "const vec3 totalRayleigh = vec3( 5.804542996261093E-6, 1.3562911419845635E-5, 3.0265902468824876E-5 );",
-    "const float v = 4.0;",
-    "const vec3 K = vec3( 0.686, 0.678, 0.666 );",
-    "const vec3 MieConst = vec3( 1.8399918514433978E14, 2.7798023919660528E14, 4.0790479543861094E14 );",
-    "const float cutoffAngle = 1.6110731556870734;",
-    "const float steepness = 1.5;",
-    "const float EE = 1000.0;",
-    "float sunIntensity( float zenithAngleCos ) {",
-    "	zenithAngleCos = clamp( zenithAngleCos, -1.0, 1.0 );",
-    "	return EE * max( 0.0, 1.0 - pow( e, -( ( cutoffAngle - acos( zenithAngleCos ) ) / steepness ) ) );",
-    "}",
-    "vec3 totalMie( float T ) {",
-    "	float c = ( 0.2 * T ) * 10E-18;",
-    "	return 0.434 * c * MieConst;",
-    "}",
-    "void main() {",
-    "	vec4 worldPosition = modelMatrix * vec4( position, 1.0 );",
-    "	vWorldPosition = worldPosition.xyz;",
-    "	gl_Position = projectionMatrix * modelViewMatrix * vec4( position, 1.0 );",
-    "	gl_Position.z = gl_Position.w;",
-    "	vSunDirection = normalize( sunPosition );",
-    "	vSunE = sunIntensity( dot( vSunDirection, up ) );",
-    "	vSunfade = 1.0 - clamp( 1.0 - exp( ( sunPosition.y / 450000.0 ) ), 0.0, 1.0 );",
-    "	float rayleighCoefficient = rayleigh - ( 1.0 * ( 1.0 - vSunfade ) );",
-    "	vBetaR = totalRayleigh * rayleighCoefficient;",
-    "	vBetaM = totalMie( turbidity ) * mieCoefficient;",
-    "}"
-  ].join("\n"),
-  fragmentShader: [
-    "varying vec3 vWorldPosition;",
-    "varying vec3 vSunDirection;",
-    "varying float vSunfade;",
-    "varying vec3 vBetaR;",
-    "varying vec3 vBetaM;",
-    "varying float vSunE;",
-    "uniform float mieDirectionalG;",
-    "uniform vec3 up;",
-    "const vec3 cameraPos = vec3( 0.0, 0.0, 0.0 );",
-    "const float pi = 3.141592653589793238462643383279502884197169;",
-    "const float n = 1.0003;",
-    "const float N = 2.545E25;",
-    "const float rayleighZenithLength = 8.4E3;",
-    "const float mieZenithLength = 1.25E3;",
-    "const float sunAngularDiameterCos = 0.999956676946448443553574619906976478926848692873900859324;",
-    "const float THREE_OVER_SIXTEENPI = 0.05968310365946075;",
-    "const float ONE_OVER_FOURPI = 0.07957747154594767;",
-    "float rayleighPhase( float cosTheta ) {",
-    "	return THREE_OVER_SIXTEENPI * ( 1.0 + pow( cosTheta, 2.0 ) );",
-    "}",
-    "float hgPhase( float cosTheta, float g ) {",
-    "	float g2 = pow( g, 2.0 );",
-    "	float inverse = 1.0 / pow( 1.0 - 2.0 * g * cosTheta + g2, 1.5 );",
-    "	return ONE_OVER_FOURPI * ( ( 1.0 - g2 ) * inverse );",
-    "}",
-    "void main() {",
-    "	vec3 direction = normalize( vWorldPosition - cameraPos );",
-    "	float zenithAngle = acos( max( 0.0, dot( up, direction ) ) );",
-    "	float inverse = 1.0 / ( cos( zenithAngle ) + 0.15 * pow( 93.885 - ( ( zenithAngle * 180.0 ) / pi ), -1.253 ) );",
-    "	float sR = rayleighZenithLength * inverse;",
-    "	float sM = mieZenithLength * inverse;",
-    "	vec3 Fex = exp( -( vBetaR * sR + vBetaM * sM ) );",
-    "	float cosTheta = dot( direction, vSunDirection );",
-    "	float rPhase = rayleighPhase( cosTheta * 0.5 + 0.5 );",
-    "	vec3 betaRTheta = vBetaR * rPhase;",
-    "	float mPhase = hgPhase( cosTheta, mieDirectionalG );",
-    "	vec3 betaMTheta = vBetaM * mPhase;",
-    "	vec3 Lin = pow( vSunE * ( ( betaRTheta + betaMTheta ) / ( vBetaR + vBetaM ) ) * ( 1.0 - Fex ), vec3( 1.5 ) );",
-    "	Lin *= mix( vec3( 1.0 ), pow( vSunE * ( ( betaRTheta + betaMTheta ) / ( vBetaR + vBetaM ) ) * Fex, vec3( 1.0 / 2.0 ) ), clamp( pow( 1.0 - dot( up, vSunDirection ), 5.0 ), 0.0, 1.0 ) );",
-    "	float theta = acos( direction.y ); // elevation --> y-axis, [-pi/2, pi/2]",
-    "	float phi = atan( direction.z, direction.x ); // azimuth --> x-axis [-pi/2, pi/2]",
-    "	vec2 uv = vec2( phi, theta ) / vec2( 2.0 * pi, pi ) + vec2( 0.5, 0.0 );",
-    "	vec3 L0 = vec3( 0.1 ) * Fex;",
-    "	float sundisk = smoothstep( sunAngularDiameterCos, sunAngularDiameterCos + 0.00002, cosTheta );",
-    "	L0 += ( vSunE * 19000.0 * Fex ) * sundisk;",
-    "	vec3 texColor = ( Lin + L0 ) * 0.04 + vec3( 0.0, 0.0003, 0.00075 );",
-    "	vec3 retColor = pow( texColor, vec3( 1.0 / ( 1.2 + ( 1.2 * vSunfade ) ) ) );",
-    "	gl_FragColor = vec4( retColor, 1.0 );",
-    "#include <tonemapping_fragment>",
-    "#include <encodings_fragment>",
-    "}"
-  ].join("\n")
-};
-Sky.material = new ShaderMaterial({
-  name: "SkyShader",
-  fragmentShader: _Sky.SkyShader.fragmentShader,
-  vertexShader: _Sky.SkyShader.vertexShader,
-  uniforms: UniformsUtils.clone(_Sky.SkyShader.uniforms),
-  side: BackSide,
-  depthWrite: false
-});
-export {
-  Sky
-};

package/objects/Water.mjs

@@ -1,235 +0,0 @@
-import { Mesh, Vector3, Color, FrontSide, Plane, Matrix4, Vector4, PerspectiveCamera, WebGLRenderTarget, UniformsUtils, UniformsLib, ShaderMaterial } from "three";
-class Water extends Mesh {
-  constructor(geometry, options = {}) {
-    super(geometry);
-    const scope = this;
-    const textureWidth = options.textureWidth !== void 0 ? options.textureWidth : 512;
-    const textureHeight = options.textureHeight !== void 0 ? options.textureHeight : 512;
-    const clipBias = options.clipBias !== void 0 ? options.clipBias : 0;
-    const alpha = options.alpha !== void 0 ? options.alpha : 1;
-    const time = options.time !== void 0 ? options.time : 0;
-    const normalSampler = options.waterNormals !== void 0 ? options.waterNormals : null;
-    const sunDirection = options.sunDirection !== void 0 ? options.sunDirection : new Vector3(0.70707, 0.70707, 0);
-    const sunColor = new Color(options.sunColor !== void 0 ? options.sunColor : 16777215);
-    const waterColor = new Color(options.waterColor !== void 0 ? options.waterColor : 8355711);
-    const eye = options.eye !== void 0 ? options.eye : new Vector3(0, 0, 0);
-    const distortionScale = options.distortionScale !== void 0 ? options.distortionScale : 20;
-    const side = options.side !== void 0 ? options.side : FrontSide;
-    const fog = options.fog !== void 0 ? options.fog : false;
-    const mirrorPlane = new Plane();
-    const normal = new Vector3();
-    const mirrorWorldPosition = 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 mirrorCamera = new PerspectiveCamera();
-    const renderTarget = new WebGLRenderTarget(textureWidth, textureHeight);
-    const mirrorShader = {
-      uniforms: UniformsUtils.merge([
-        UniformsLib["fog"],
-        UniformsLib["lights"],
-        {
-          normalSampler: { value: null },
-          mirrorSampler: { value: null },
-          alpha: { value: 1 },
-          time: { value: 0 },
-          size: { value: 1 },
-          distortionScale: { value: 20 },
-          textureMatrix: { value: new Matrix4() },
-          sunColor: { value: new Color(8355711) },
-          sunDirection: { value: new Vector3(0.70707, 0.70707, 0) },
-          eye: { value: new Vector3() },
-          waterColor: { value: new Color(5592405) }
-        }
-      ]),
-      vertexShader: `
-				uniform mat4 textureMatrix;
-				uniform float time;
-
-				varying vec4 mirrorCoord;
-				varying vec4 worldPosition;
-
-				#include <common>
-				#include <fog_pars_vertex>
-				#include <shadowmap_pars_vertex>
-				#include <logdepthbuf_pars_vertex>
-
-				void main() {
-					mirrorCoord = modelMatrix * vec4( position, 1.0 );
-					worldPosition = mirrorCoord.xyzw;
-					mirrorCoord = textureMatrix * mirrorCoord;
-					vec4 mvPosition =  modelViewMatrix * vec4( position, 1.0 );
-					gl_Position = projectionMatrix * mvPosition;
-
-				#include <beginnormal_vertex>
-				#include <defaultnormal_vertex>
-				#include <logdepthbuf_vertex>
-				#include <fog_vertex>
-				#include <shadowmap_vertex>
-			}`,
-      fragmentShader: `
-				uniform sampler2D mirrorSampler;
-				uniform float alpha;
-				uniform float time;
-				uniform float size;
-				uniform float distortionScale;
-				uniform sampler2D normalSampler;
-				uniform vec3 sunColor;
-				uniform vec3 sunDirection;
-				uniform vec3 eye;
-				uniform vec3 waterColor;
-
-				varying vec4 mirrorCoord;
-				varying vec4 worldPosition;
-
-				vec4 getNoise( vec2 uv ) {
-					vec2 uv0 = ( uv / 103.0 ) + vec2(time / 17.0, time / 29.0);
-					vec2 uv1 = uv / 107.0-vec2( time / -19.0, time / 31.0 );
-					vec2 uv2 = uv / vec2( 8907.0, 9803.0 ) + vec2( time / 101.0, time / 97.0 );
-					vec2 uv3 = uv / vec2( 1091.0, 1027.0 ) - vec2( time / 109.0, time / -113.0 );
-					vec4 noise = texture2D( normalSampler, uv0 ) +
-						texture2D( normalSampler, uv1 ) +
-						texture2D( normalSampler, uv2 ) +
-						texture2D( normalSampler, uv3 );
-					return noise * 0.5 - 1.0;
-				}
-
-				void sunLight( const vec3 surfaceNormal, const vec3 eyeDirection, float shiny, float spec, float diffuse, inout vec3 diffuseColor, inout vec3 specularColor ) {
-					vec3 reflection = normalize( reflect( -sunDirection, surfaceNormal ) );
-					float direction = max( 0.0, dot( eyeDirection, reflection ) );
-					specularColor += pow( direction, shiny ) * sunColor * spec;
-					diffuseColor += max( dot( sunDirection, surfaceNormal ), 0.0 ) * sunColor * diffuse;
-				}
-
-				#include <common>
-				#include <packing>
-				#include <bsdfs>
-				#include <fog_pars_fragment>
-				#include <logdepthbuf_pars_fragment>
-				#include <lights_pars_begin>
-				#include <shadowmap_pars_fragment>
-				#include <shadowmask_pars_fragment>
-
-				void main() {
-
-					#include <logdepthbuf_fragment>
-					vec4 noise = getNoise( worldPosition.xz * size );
-					vec3 surfaceNormal = normalize( noise.xzy * vec3( 1.5, 1.0, 1.5 ) );
-
-					vec3 diffuseLight = vec3(0.0);
-					vec3 specularLight = vec3(0.0);
-
-					vec3 worldToEye = eye-worldPosition.xyz;
-					vec3 eyeDirection = normalize( worldToEye );
-					sunLight( surfaceNormal, eyeDirection, 100.0, 2.0, 0.5, diffuseLight, specularLight );
-
-					float distance = length(worldToEye);
-
-					vec2 distortion = surfaceNormal.xz * ( 0.001 + 1.0 / distance ) * distortionScale;
-					vec3 reflectionSample = vec3( texture2D( mirrorSampler, mirrorCoord.xy / mirrorCoord.w + distortion ) );
-
-					float theta = max( dot( eyeDirection, surfaceNormal ), 0.0 );
-					float rf0 = 0.3;
-					float reflectance = rf0 + ( 1.0 - rf0 ) * pow( ( 1.0 - theta ), 5.0 );
-					vec3 scatter = max( 0.0, dot( surfaceNormal, eyeDirection ) ) * waterColor;
-					vec3 albedo = mix( ( sunColor * diffuseLight * 0.3 + scatter ) * getShadowMask(), ( vec3( 0.1 ) + reflectionSample * 0.9 + reflectionSample * specularLight ), reflectance);
-					vec3 outgoingLight = albedo;
-					gl_FragColor = vec4( outgoingLight, alpha );
-
-					#include <tonemapping_fragment>
-					#include <fog_fragment>
-				}`
-    };
-    const material = new ShaderMaterial({
-      fragmentShader: mirrorShader.fragmentShader,
-      vertexShader: mirrorShader.vertexShader,
-      uniforms: UniformsUtils.clone(mirrorShader.uniforms),
-      lights: true,
-      side,
-      fog
-    });
-    material.uniforms["mirrorSampler"].value = renderTarget.texture;
-    material.uniforms["textureMatrix"].value = textureMatrix;
-    material.uniforms["alpha"].value = alpha;
-    material.uniforms["time"].value = time;
-    material.uniforms["normalSampler"].value = normalSampler;
-    material.uniforms["sunColor"].value = sunColor;
-    material.uniforms["waterColor"].value = waterColor;
-    material.uniforms["sunDirection"].value = sunDirection;
-    material.uniforms["distortionScale"].value = distortionScale;
-    material.uniforms["eye"].value = eye;
-    scope.material = material;
-    scope.onBeforeRender = function(renderer, scene, camera) {
-      mirrorWorldPosition.setFromMatrixPosition(scope.matrixWorld);
-      cameraWorldPosition.setFromMatrixPosition(camera.matrixWorld);
-      rotationMatrix.extractRotation(scope.matrixWorld);
-      normal.set(0, 0, 1);
-      normal.applyMatrix4(rotationMatrix);
-      view.subVectors(mirrorWorldPosition, cameraWorldPosition);
-      if (view.dot(normal) > 0)
-        return;
-      view.reflect(normal).negate();
-      view.add(mirrorWorldPosition);
-      rotationMatrix.extractRotation(camera.matrixWorld);
-      lookAtPosition.set(0, 0, -1);
-      lookAtPosition.applyMatrix4(rotationMatrix);
-      lookAtPosition.add(cameraWorldPosition);
-      target.subVectors(mirrorWorldPosition, lookAtPosition);
-      target.reflect(normal).negate();
-      target.add(mirrorWorldPosition);
-      mirrorCamera.position.copy(view);
-      mirrorCamera.up.set(0, 1, 0);
-      mirrorCamera.up.applyMatrix4(rotationMatrix);
-      mirrorCamera.up.reflect(normal);
-      mirrorCamera.lookAt(target);
-      mirrorCamera.far = camera.far;
-      mirrorCamera.updateMatrixWorld();
-      mirrorCamera.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(mirrorCamera.projectionMatrix);
-      textureMatrix.multiply(mirrorCamera.matrixWorldInverse);
-      mirrorPlane.setFromNormalAndCoplanarPoint(normal, mirrorWorldPosition);
-      mirrorPlane.applyMatrix4(mirrorCamera.matrixWorldInverse);
-      clipPlane.set(mirrorPlane.normal.x, mirrorPlane.normal.y, mirrorPlane.normal.z, mirrorPlane.constant);
-      const projectionMatrix = mirrorCamera.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;
-      eye.setFromMatrixPosition(camera.matrixWorld);
-      const currentRenderTarget = renderer.getRenderTarget();
-      const currentXrEnabled = renderer.xr.enabled;
-      const currentShadowAutoUpdate = renderer.shadowMap.autoUpdate;
-      scope.visible = false;
-      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, mirrorCamera);
-      scope.visible = true;
-      renderer.xr.enabled = currentXrEnabled;
-      renderer.shadowMap.autoUpdate = currentShadowAutoUpdate;
-      renderer.setRenderTarget(currentRenderTarget);
-      const viewport = camera.viewport;
-      if (viewport !== void 0) {
-        renderer.state.viewport(viewport);
-      }
-    };
-  }
-}
-Water.prototype.isWater = true;
-export {
-  Water
-};

package/objects/Water2.mjs

@@ -1,252 +0,0 @@
-import { Mesh, Color, Vector2, LinearEncoding, TextureLoader, Matrix4, Clock, ShaderMaterial, UniformsUtils, UniformsLib, RepeatWrapping, Vector4 } from "three";
-import { Reflector } from "./Reflector.mjs";
-import { Refractor } from "./Refractor.mjs";
-class Water2 extends Mesh {
-  constructor(geometry, options = {}) {
-    super(geometry);
-    this.type = "Water";
-    const scope = this;
-    const color = options.color !== void 0 ? new Color(options.color) : new Color(16777215);
-    const textureWidth = options.textureWidth || 512;
-    const textureHeight = options.textureHeight || 512;
-    const clipBias = options.clipBias || 0;
-    const flowDirection = options.flowDirection || new Vector2(1, 0);
-    const flowSpeed = options.flowSpeed || 0.03;
-    const reflectivity = options.reflectivity || 0.02;
-    const scale = options.scale || 1;
-    const shader = options.shader || Water.WaterShader;
-    const encoding = options.encoding !== void 0 ? options.encoding : LinearEncoding;
-    const textureLoader = new TextureLoader();
-    const flowMap = options.flowMap || void 0;
-    const normalMap0 = options.normalMap0 || textureLoader.load("textures/water/Water_1_M_Normal.jpg");
-    const normalMap1 = options.normalMap1 || textureLoader.load("textures/water/Water_2_M_Normal.jpg");
-    const cycle = 0.15;
-    const halfCycle = cycle * 0.5;
-    const textureMatrix = new Matrix4();
-    const clock = new Clock();
-    if (Reflector === void 0) {
-      console.error("THREE.Water: Required component Reflector not found.");
-      return;
-    }
-    if (Refractor === void 0) {
-      console.error("THREE.Water: Required component Refractor not found.");
-      return;
-    }
-    const reflector = new Reflector(geometry, {
-      textureWidth,
-      textureHeight,
-      clipBias,
-      encoding
-    });
-    const refractor = new Refractor(geometry, {
-      textureWidth,
-      textureHeight,
-      clipBias,
-      encoding
-    });
-    reflector.matrixAutoUpdate = false;
-    refractor.matrixAutoUpdate = false;
-    this.material = new ShaderMaterial({
-      uniforms: UniformsUtils.merge([UniformsLib["fog"], shader.uniforms]),
-      vertexShader: shader.vertexShader,
-      fragmentShader: shader.fragmentShader,
-      transparent: true,
-      fog: true
-    });
-    if (flowMap !== void 0) {
-      this.material.defines.USE_FLOWMAP = "";
-      this.material.uniforms["tFlowMap"] = {
-        type: "t",
-        value: flowMap
-      };
-    } else {
-      this.material.uniforms["flowDirection"] = {
-        type: "v2",
-        value: flowDirection
-      };
-    }
-    normalMap0.wrapS = normalMap0.wrapT = RepeatWrapping;
-    normalMap1.wrapS = normalMap1.wrapT = RepeatWrapping;
-    this.material.uniforms["tReflectionMap"].value = reflector.getRenderTarget().texture;
-    this.material.uniforms["tRefractionMap"].value = refractor.getRenderTarget().texture;
-    this.material.uniforms["tNormalMap0"].value = normalMap0;
-    this.material.uniforms["tNormalMap1"].value = normalMap1;
-    this.material.uniforms["color"].value = color;
-    this.material.uniforms["reflectivity"].value = reflectivity;
-    this.material.uniforms["textureMatrix"].value = textureMatrix;
-    this.material.uniforms["config"].value.x = 0;
-    this.material.uniforms["config"].value.y = halfCycle;
-    this.material.uniforms["config"].value.z = halfCycle;
-    this.material.uniforms["config"].value.w = scale;
-    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 updateFlow() {
-      const delta = clock.getDelta();
-      const config = scope.material.uniforms["config"];
-      config.value.x += flowSpeed * delta;
-      config.value.y = config.value.x + halfCycle;
-      if (config.value.x >= cycle) {
-        config.value.x = 0;
-        config.value.y = halfCycle;
-      } else if (config.value.y >= cycle) {
-        config.value.y = config.value.y - cycle;
-      }
-    }
-    this.onBeforeRender = function(renderer, scene, camera) {
-      updateTextureMatrix(camera);
-      updateFlow();
-      scope.visible = false;
-      reflector.matrixWorld.copy(scope.matrixWorld);
-      refractor.matrixWorld.copy(scope.matrixWorld);
-      reflector.onBeforeRender(renderer, scene, camera);
-      refractor.onBeforeRender(renderer, scene, camera);
-      scope.visible = true;
-    };
-  }
-}
-Water2.prototype.isWater = true;
-Water2.WaterShader = {
-  uniforms: {
-    color: {
-      type: "c",
-      value: null
-    },
-    reflectivity: {
-      type: "f",
-      value: 0
-    },
-    tReflectionMap: {
-      type: "t",
-      value: null
-    },
-    tRefractionMap: {
-      type: "t",
-      value: null
-    },
-    tNormalMap0: {
-      type: "t",
-      value: null
-    },
-    tNormalMap1: {
-      type: "t",
-      value: null
-    },
-    textureMatrix: {
-      type: "m4",
-      value: null
-    },
-    config: {
-      type: "v4",
-      value: new Vector4()
-    }
-  },
-  vertexShader: `
-
-		#include <common>
-		#include <fog_pars_vertex>
-		#include <logdepthbuf_pars_vertex>
-
-		uniform mat4 textureMatrix;
-
-		varying vec4 vCoord;
-		varying vec2 vUv;
-		varying vec3 vToEye;
-
-		void main() {
-
-			vUv = uv;
-			vCoord = textureMatrix * vec4( position, 1.0 );
-
-			vec4 worldPosition = modelMatrix * vec4( position, 1.0 );
-			vToEye = cameraPosition - worldPosition.xyz;
-
-			vec4 mvPosition =  viewMatrix * worldPosition; // used in fog_vertex
-			gl_Position = projectionMatrix * mvPosition;
-
-			#include <logdepthbuf_vertex>
-			#include <fog_vertex>
-
-		}`,
-  fragmentShader: `
-
-		#include <common>
-		#include <fog_pars_fragment>
-		#include <logdepthbuf_pars_fragment>
-
-		uniform sampler2D tReflectionMap;
-		uniform sampler2D tRefractionMap;
-		uniform sampler2D tNormalMap0;
-		uniform sampler2D tNormalMap1;
-
-		#ifdef USE_FLOWMAP
-			uniform sampler2D tFlowMap;
-		#else
-			uniform vec2 flowDirection;
-		#endif
-
-		uniform vec3 color;
-		uniform float reflectivity;
-		uniform vec4 config;
-
-		varying vec4 vCoord;
-		varying vec2 vUv;
-		varying vec3 vToEye;
-
-		void main() {
-
-			#include <logdepthbuf_fragment>
-
-			float flowMapOffset0 = config.x;
-			float flowMapOffset1 = config.y;
-			float halfCycle = config.z;
-			float scale = config.w;
-
-			vec3 toEye = normalize( vToEye );
-
-			// determine flow direction
-			vec2 flow;
-			#ifdef USE_FLOWMAP
-				flow = texture2D( tFlowMap, vUv ).rg * 2.0 - 1.0;
-			#else
-				flow = flowDirection;
-			#endif
-			flow.x *= - 1.0;
-
-			// sample normal maps (distort uvs with flowdata)
-			vec4 normalColor0 = texture2D( tNormalMap0, ( vUv * scale ) + flow * flowMapOffset0 );
-			vec4 normalColor1 = texture2D( tNormalMap1, ( vUv * scale ) + flow * flowMapOffset1 );
-
-			// linear interpolate to get the final normal color
-			float flowLerp = abs( halfCycle - flowMapOffset0 ) / halfCycle;
-			vec4 normalColor = mix( normalColor0, normalColor1, flowLerp );
-
-			// calculate normal vector
-			vec3 normal = normalize( vec3( normalColor.r * 2.0 - 1.0, normalColor.b,  normalColor.g * 2.0 - 1.0 ) );
-
-			// calculate the fresnel term to blend reflection and refraction maps
-			float theta = max( dot( toEye, normal ), 0.0 );
-			float reflectance = reflectivity + ( 1.0 - reflectivity ) * pow( ( 1.0 - theta ), 5.0 );
-
-			// calculate final uv coords
-			vec3 coord = vCoord.xyz / vCoord.w;
-			vec2 uv = coord.xy + coord.z * normal.xz * 0.05;
-
-			vec4 reflectColor = texture2D( tReflectionMap, vec2( 1.0 - uv.x, uv.y ) );
-			vec4 refractColor = texture2D( tRefractionMap, uv );
-
-			// multiply water color with the mix of both textures
-			gl_FragColor = vec4( color, 1.0 ) * mix( refractColor, reflectColor, reflectance );
-
-			#include <tonemapping_fragment>
-			#include <encodings_fragment>
-			#include <fog_fragment>
-
-		}`
-};
-export {
-  Water2
-};

package/offscreen/jank.mjs

@@ -1,27 +0,0 @@
-var interval = null;
-var result = null;
-function initJank() {
-  var button = document.getElementById("button");
-  button.addEventListener("click", function() {
-    if (interval === null) {
-      interval = setInterval(jank, 1e3 / 60);
-      button.textContent = "STOP JANK";
-    } else {
-      clearInterval(interval);
-      interval = null;
-      button.textContent = "START JANK";
-      result.textContent = "";
-    }
-  });
-  result = document.getElementById("result");
-}
-function jank() {
-  var number = 0;
-  for (let i = 0; i < 1e7; i++) {
-    number += Math.random();
-  }
-  result.textContent = number;
-}
-export {
-  initJank as default
-};

package/offscreen/offscreen.mjs

@@ -1,5 +0,0 @@
-import init from "./scene.mjs";
-self.onmessage = function(message) {
-  var data = message.data;
-  init(data.drawingSurface, data.width, data.height, data.pixelRatio, data.path);
-};