three-stdlib 2.22.7 → 2.22.9

package/dist/misc/MorphBlendMesh.mjs

@@ -0,0 +1,179 @@
+import { Mesh, MathUtils } from "three";
+var MorphBlendMesh = function(geometry, material) {
+  Mesh.call(this, geometry, material);
+  this.animationsMap = {};
+  this.animationsList = [];
+  var numFrames = Object.keys(this.morphTargetDictionary).length;
+  var name = "__default";
+  var startFrame = 0;
+  var endFrame = numFrames - 1;
+  var fps = numFrames / 1;
+  this.createAnimation(name, startFrame, endFrame, fps);
+  this.setAnimationWeight(name, 1);
+};
+MorphBlendMesh.prototype = Object.assign(Object.create(Mesh.prototype), {
+  constructor: MorphBlendMesh,
+  createAnimation: function(name, start, end, fps) {
+    var animation = {
+      start,
+      end,
+      length: end - start + 1,
+      fps,
+      duration: (end - start) / fps,
+      lastFrame: 0,
+      currentFrame: 0,
+      active: false,
+      time: 0,
+      direction: 1,
+      weight: 1,
+      directionBackwards: false,
+      mirroredLoop: false
+    };
+    this.animationsMap[name] = animation;
+    this.animationsList.push(animation);
+  },
+  autoCreateAnimations: function(fps) {
+    var pattern = /([a-z]+)_?(\d+)/i;
+    var firstAnimation, frameRanges = {};
+    var i = 0;
+    for (let key in this.morphTargetDictionary) {
+      var chunks = key.match(pattern);
+      if (chunks && chunks.length > 1) {
+        var name = chunks[1];
+        if (!frameRanges[name])
+          frameRanges[name] = { start: Infinity, end: -Infinity };
+        var range = frameRanges[name];
+        if (i < range.start)
+          range.start = i;
+        if (i > range.end)
+          range.end = i;
+        if (!firstAnimation)
+          firstAnimation = name;
+      }
+      i++;
+    }
+    for (let name2 in frameRanges) {
+      var range = frameRanges[name2];
+      this.createAnimation(name2, range.start, range.end, fps);
+    }
+    this.firstAnimation = firstAnimation;
+  },
+  setAnimationDirectionForward: function(name) {
+    var animation = this.animationsMap[name];
+    if (animation) {
+      animation.direction = 1;
+      animation.directionBackwards = false;
+    }
+  },
+  setAnimationDirectionBackward: function(name) {
+    var animation = this.animationsMap[name];
+    if (animation) {
+      animation.direction = -1;
+      animation.directionBackwards = true;
+    }
+  },
+  setAnimationFPS: function(name, fps) {
+    var animation = this.animationsMap[name];
+    if (animation) {
+      animation.fps = fps;
+      animation.duration = (animation.end - animation.start) / animation.fps;
+    }
+  },
+  setAnimationDuration: function(name, duration) {
+    var animation = this.animationsMap[name];
+    if (animation) {
+      animation.duration = duration;
+      animation.fps = (animation.end - animation.start) / animation.duration;
+    }
+  },
+  setAnimationWeight: function(name, weight) {
+    var animation = this.animationsMap[name];
+    if (animation) {
+      animation.weight = weight;
+    }
+  },
+  setAnimationTime: function(name, time) {
+    var animation = this.animationsMap[name];
+    if (animation) {
+      animation.time = time;
+    }
+  },
+  getAnimationTime: function(name) {
+    var time = 0;
+    var animation = this.animationsMap[name];
+    if (animation) {
+      time = animation.time;
+    }
+    return time;
+  },
+  getAnimationDuration: function(name) {
+    var duration = -1;
+    var animation = this.animationsMap[name];
+    if (animation) {
+      duration = animation.duration;
+    }
+    return duration;
+  },
+  playAnimation: function(name) {
+    var animation = this.animationsMap[name];
+    if (animation) {
+      animation.time = 0;
+      animation.active = true;
+    } else {
+      console.warn("THREE.MorphBlendMesh: animation[" + name + "] undefined in .playAnimation()");
+    }
+  },
+  stopAnimation: function(name) {
+    var animation = this.animationsMap[name];
+    if (animation) {
+      animation.active = false;
+    }
+  },
+  update: function(delta) {
+    for (let i = 0, il = this.animationsList.length; i < il; i++) {
+      var animation = this.animationsList[i];
+      if (!animation.active)
+        continue;
+      var frameTime = animation.duration / animation.length;
+      animation.time += animation.direction * delta;
+      if (animation.mirroredLoop) {
+        if (animation.time > animation.duration || animation.time < 0) {
+          animation.direction *= -1;
+          if (animation.time > animation.duration) {
+            animation.time = animation.duration;
+            animation.directionBackwards = true;
+          }
+          if (animation.time < 0) {
+            animation.time = 0;
+            animation.directionBackwards = false;
+          }
+        }
+      } else {
+        animation.time = animation.time % animation.duration;
+        if (animation.time < 0)
+          animation.time += animation.duration;
+      }
+      var keyframe = animation.start + MathUtils.clamp(Math.floor(animation.time / frameTime), 0, animation.length - 1);
+      var weight = animation.weight;
+      if (keyframe !== animation.currentFrame) {
+        this.morphTargetInfluences[animation.lastFrame] = 0;
+        this.morphTargetInfluences[animation.currentFrame] = 1 * weight;
+        this.morphTargetInfluences[keyframe] = 0;
+        animation.lastFrame = animation.currentFrame;
+        animation.currentFrame = keyframe;
+      }
+      var mix = animation.time % frameTime / frameTime;
+      if (animation.directionBackwards)
+        mix = 1 - mix;
+      if (animation.currentFrame !== animation.lastFrame) {
+        this.morphTargetInfluences[animation.currentFrame] = mix * weight;
+        this.morphTargetInfluences[animation.lastFrame] = (1 - mix) * weight;
+      } else {
+        this.morphTargetInfluences[animation.currentFrame] = weight;
+      }
+    }
+  }
+});
+export {
+  MorphBlendMesh
+};

package/dist/misc/ProgressiveLightmap.d.ts

@@ -0,0 +1,61 @@
+import {
+  Camera,
+  Material,
+  Mesh,
+  MeshBasicMaterial,
+  MeshPhongMaterial,
+  Object3D,
+  PlaneBufferGeometry,
+  PlaneGeometry,
+  Texture,
+  Vector3,
+  WebGLRenderer,
+  Scene,
+  WebGLRenderTarget,
+} from 'three'
+
+export interface UVBoxes {
+  w: number
+  h: number
+  index: number
+}
+
+export interface LightMapContainers {
+  basicMat: Material | Material[]
+  object: Object3D
+}
+
+export class ProgressiveLightMap {
+  renderer: WebGLRenderer
+  res: number
+  lightMapContainers: LightMapContainers[]
+  compiled: boolean
+  scene: Scene
+  tinyTarget: WebGLRenderTarget
+  buffer1Active: boolean
+  firstUpdate: boolean
+  warned: boolean
+
+  progressiveLightMap1: WebGLRenderTarget
+  progressiveLightMap2: WebGLRenderTarget
+
+  uvMat: MeshPhongMaterial
+
+  uv_boxes: UVBoxes[]
+
+  blurringPlane: Mesh<PlaneBufferGeometry, MeshBasicMaterial>
+
+  labelMaterial: MeshBasicMaterial
+  labelPlane: PlaneGeometry
+  labelMesh: Mesh<PlaneGeometry, MeshBasicMaterial>
+
+  constructor(renderer: WebGLRenderer, res?: number)
+
+  addObjectsToLightMap(objects: Object3D[]): void
+
+  update(camera: Camera, blendWindow?: number, blurEdges?: boolean): void
+
+  showDebugLightmap(visible: boolean, position?: Vector3): void
+
+  private _initializeBlurPlane(res: number, lightMap?: Texture | null): void
+}

package/dist/misc/ProgressiveLightmap.js

@@ -0,0 +1,186 @@
+"use strict";
+Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
+const THREE = require("three");
+const potpack = require("potpack");
+class ProgressiveLightMap {
+  constructor(renderer, res = 1024) {
+    this.renderer = renderer;
+    this.res = res;
+    this.lightMapContainers = [];
+    this.compiled = false;
+    this.scene = new THREE.Scene();
+    this.scene.background = null;
+    this.tinyTarget = new THREE.WebGLRenderTarget(1, 1);
+    this.buffer1Active = false;
+    this.firstUpdate = true;
+    this.warned = false;
+    const format = /(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent) ? alfFloatType : THREE.FloatType;
+    this.progressiveLightMap1 = new THREE.WebGLRenderTarget(this.res, this.res, { type: format });
+    this.progressiveLightMap2 = new THREE.WebGLRenderTarget(this.res, this.res, { type: format });
+    this.uvMat = new THREE.MeshPhongMaterial();
+    this.uvMat.uniforms = {};
+    this.uvMat.onBeforeCompile = (shader) => {
+      shader.vertexShader = "#define USE_LIGHTMAP\n" + shader.vertexShader.slice(0, -1) + "	gl_Position = vec4((uv2 - 0.5) * 2.0, 1.0, 1.0); }";
+      const bodyStart = shader.fragmentShader.indexOf("void main() {");
+      shader.fragmentShader = "varying vec2 vUv2;\n" + shader.fragmentShader.slice(0, bodyStart) + "	uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n" + shader.fragmentShader.slice(bodyStart - 1, -1) + `
+vec3 texelOld = texture2D(previousShadowMap, vUv2).rgb;
+				gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/averagingWindow);
+			}`;
+      shader.uniforms.previousShadowMap = { value: this.progressiveLightMap1.texture };
+      shader.uniforms.averagingWindow = { value: 100 };
+      this.uvMat.uniforms = shader.uniforms;
+      this.uvMat.userData.shader = shader;
+      this.compiled = true;
+    };
+  }
+  /**
+   * Sets these objects' materials' lightmaps and modifies their uv2's.
+   * @param {Object3D} objects An array of objects and lights to set up your lightmap.
+   */
+  addObjectsToLightMap(objects) {
+    this.uv_boxes = [];
+    const padding = 3 / this.res;
+    for (let ob = 0; ob < objects.length; ob++) {
+      const object = objects[ob];
+      if (object.isLight) {
+        this.scene.attach(object);
+        continue;
+      }
+      if (!object.geometry.hasAttribute("uv")) {
+        console.warn("All lightmap objects need UVs!");
+        continue;
+      }
+      if (this.blurringPlane == null) {
+        this._initializeBlurPlane(this.res, this.progressiveLightMap1);
+      }
+      object.material.lightMap = this.progressiveLightMap2.texture;
+      object.material.dithering = true;
+      object.castShadow = true;
+      object.receiveShadow = true;
+      object.renderOrder = 1e3 + ob;
+      this.uv_boxes.push({ w: 1 + padding * 2, h: 1 + padding * 2, index: ob });
+      this.lightMapContainers.push({ basicMat: object.material, object });
+      this.compiled = false;
+    }
+    const dimensions = potpack(this.uv_boxes);
+    this.uv_boxes.forEach((box) => {
+      const uv2 = objects[box.index].geometry.getAttribute("uv").clone();
+      for (let i = 0; i < uv2.array.length; i += uv2.itemSize) {
+        uv2.array[i] = (uv2.array[i] + box.x + padding) / dimensions.w;
+        uv2.array[i + 1] = (uv2.array[i + 1] + box.y + padding) / dimensions.h;
+      }
+      objects[box.index].geometry.setAttribute("uv2", uv2);
+      objects[box.index].geometry.getAttribute("uv2").needsUpdate = true;
+    });
+  }
+  /**
+   * This function renders each mesh one at a time into their respective surface maps
+   * @param {Camera} camera Standard Rendering Camera
+   * @param {number} blendWindow When >1, samples will accumulate over time.
+   * @param {boolean} blurEdges  Whether to fix UV Edges via blurring
+   */
+  update(camera, blendWindow = 100, blurEdges = true) {
+    if (this.blurringPlane == null) {
+      return;
+    }
+    const oldTarget = this.renderer.getRenderTarget();
+    this.blurringPlane.visible = blurEdges;
+    for (let l = 0; l < this.lightMapContainers.length; l++) {
+      this.lightMapContainers[l].object.oldScene = this.lightMapContainers[l].object.parent;
+      this.scene.attach(this.lightMapContainers[l].object);
+    }
+    if (this.firstUpdate) {
+      this.renderer.setRenderTarget(this.tinyTarget);
+      this.renderer.render(this.scene, camera);
+      this.firstUpdate = false;
+    }
+    for (let l = 0; l < this.lightMapContainers.length; l++) {
+      this.uvMat.uniforms.averagingWindow = { value: blendWindow };
+      this.lightMapContainers[l].object.material = this.uvMat;
+      this.lightMapContainers[l].object.oldFrustumCulled = this.lightMapContainers[l].object.frustumCulled;
+      this.lightMapContainers[l].object.frustumCulled = false;
+    }
+    const activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;
+    const inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1;
+    this.renderer.setRenderTarget(activeMap);
+    this.uvMat.uniforms.previousShadowMap = { value: inactiveMap.texture };
+    this.blurringPlane.material.uniforms.previousShadowMap = { value: inactiveMap.texture };
+    this.buffer1Active = !this.buffer1Active;
+    this.renderer.render(this.scene, camera);
+    for (let l = 0; l < this.lightMapContainers.length; l++) {
+      this.lightMapContainers[l].object.frustumCulled = this.lightMapContainers[l].object.oldFrustumCulled;
+      this.lightMapContainers[l].object.material = this.lightMapContainers[l].basicMat;
+      this.lightMapContainers[l].object.oldScene.attach(this.lightMapContainers[l].object);
+    }
+    this.renderer.setRenderTarget(oldTarget);
+  }
+  /** DEBUG
+   * Draw the lightmap in the main scene.  Call this after adding the objects to it.
+   * @param {boolean} visible Whether the debug plane should be visible
+   * @param {Vector3} position Where the debug plane should be drawn
+   */
+  showDebugLightmap(visible, position = void 0) {
+    if (this.lightMapContainers.length == 0) {
+      if (!this.warned) {
+        console.warn("Call this after adding the objects!");
+        this.warned = true;
+      }
+      return;
+    }
+    if (this.labelMesh == null) {
+      this.labelMaterial = new THREE.MeshBasicMaterial({
+        map: this.progressiveLightMap1.texture,
+        side: THREE.DoubleSide
+      });
+      this.labelPlane = new THREE.PlaneGeometry(100, 100);
+      this.labelMesh = new THREE.Mesh(this.labelPlane, this.labelMaterial);
+      this.labelMesh.position.y = 250;
+      this.lightMapContainers[0].object.parent.add(this.labelMesh);
+    }
+    if (position != void 0) {
+      this.labelMesh.position.copy(position);
+    }
+    this.labelMesh.visible = visible;
+  }
+  /**
+   * INTERNAL Creates the Blurring Plane
+   * @param {number} res The square resolution of this object's lightMap.
+   * @param {WebGLRenderTexture} lightMap The lightmap to initialize the plane with.
+   */
+  _initializeBlurPlane(res, lightMap = null) {
+    const blurMaterial = new THREE.MeshBasicMaterial();
+    blurMaterial.uniforms = {
+      previousShadowMap: { value: null },
+      pixelOffset: { value: 1 / res },
+      polygonOffset: true,
+      polygonOffsetFactor: -1,
+      polygonOffsetUnits: 3
+    };
+    blurMaterial.onBeforeCompile = (shader) => {
+      shader.vertexShader = "#define USE_UV\n" + shader.vertexShader.slice(0, -1) + "	gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }";
+      const bodyStart = shader.fragmentShader.indexOf("void main() {");
+      shader.fragmentShader = "#define USE_UV\n" + shader.fragmentShader.slice(0, bodyStart) + "	uniform sampler2D previousShadowMap;\n	uniform float pixelOffset;\n" + shader.fragmentShader.slice(bodyStart - 1, -1) + `	gl_FragColor.rgb = (
+			  texture2D(previousShadowMap, vUv + vec2( pixelOffset,  0.0        )).rgb +
+			  texture2D(previousShadowMap, vUv + vec2( 0.0        ,  pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2( 0.0        , -pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2(-pixelOffset,  0.0        )).rgb +
+			  texture2D(previousShadowMap, vUv + vec2( pixelOffset,  pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2(-pixelOffset,  pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2( pixelOffset, -pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2(-pixelOffset, -pixelOffset)).rgb)/8.0;
+		}`;
+      shader.uniforms.previousShadowMap = { value: lightMap.texture };
+      shader.uniforms.pixelOffset = { value: 0.5 / res };
+      blurMaterial.uniforms = shader.uniforms;
+      blurMaterial.userData.shader = shader;
+      this.compiled = true;
+    };
+    this.blurringPlane = new THREE.Mesh(new THREE.PlaneGeometry(1, 1), blurMaterial);
+    this.blurringPlane.name = "Blurring Plane";
+    this.blurringPlane.frustumCulled = false;
+    this.blurringPlane.renderOrder = 0;
+    this.blurringPlane.material.depthWrite = false;
+    this.scene.add(this.blurringPlane);
+  }
+}
+exports.ProgressiveLightMap = ProgressiveLightMap;

package/dist/misc/ProgressiveLightmap.mjs

@@ -0,0 +1,186 @@
+import { Scene, WebGLRenderTarget, FloatType, MeshPhongMaterial, MeshBasicMaterial, DoubleSide, PlaneGeometry, Mesh } from "three";
+import potpack from "potpack";
+class ProgressiveLightMap {
+  constructor(renderer, res = 1024) {
+    this.renderer = renderer;
+    this.res = res;
+    this.lightMapContainers = [];
+    this.compiled = false;
+    this.scene = new Scene();
+    this.scene.background = null;
+    this.tinyTarget = new WebGLRenderTarget(1, 1);
+    this.buffer1Active = false;
+    this.firstUpdate = true;
+    this.warned = false;
+    const format = /(Android|iPad|iPhone|iPod)/g.test(navigator.userAgent) ? alfFloatType : FloatType;
+    this.progressiveLightMap1 = new WebGLRenderTarget(this.res, this.res, { type: format });
+    this.progressiveLightMap2 = new WebGLRenderTarget(this.res, this.res, { type: format });
+    this.uvMat = new MeshPhongMaterial();
+    this.uvMat.uniforms = {};
+    this.uvMat.onBeforeCompile = (shader) => {
+      shader.vertexShader = "#define USE_LIGHTMAP\n" + shader.vertexShader.slice(0, -1) + "	gl_Position = vec4((uv2 - 0.5) * 2.0, 1.0, 1.0); }";
+      const bodyStart = shader.fragmentShader.indexOf("void main() {");
+      shader.fragmentShader = "varying vec2 vUv2;\n" + shader.fragmentShader.slice(0, bodyStart) + "	uniform sampler2D previousShadowMap;\n	uniform float averagingWindow;\n" + shader.fragmentShader.slice(bodyStart - 1, -1) + `
+vec3 texelOld = texture2D(previousShadowMap, vUv2).rgb;
+				gl_FragColor.rgb = mix(texelOld, gl_FragColor.rgb, 1.0/averagingWindow);
+			}`;
+      shader.uniforms.previousShadowMap = { value: this.progressiveLightMap1.texture };
+      shader.uniforms.averagingWindow = { value: 100 };
+      this.uvMat.uniforms = shader.uniforms;
+      this.uvMat.userData.shader = shader;
+      this.compiled = true;
+    };
+  }
+  /**
+   * Sets these objects' materials' lightmaps and modifies their uv2's.
+   * @param {Object3D} objects An array of objects and lights to set up your lightmap.
+   */
+  addObjectsToLightMap(objects) {
+    this.uv_boxes = [];
+    const padding = 3 / this.res;
+    for (let ob = 0; ob < objects.length; ob++) {
+      const object = objects[ob];
+      if (object.isLight) {
+        this.scene.attach(object);
+        continue;
+      }
+      if (!object.geometry.hasAttribute("uv")) {
+        console.warn("All lightmap objects need UVs!");
+        continue;
+      }
+      if (this.blurringPlane == null) {
+        this._initializeBlurPlane(this.res, this.progressiveLightMap1);
+      }
+      object.material.lightMap = this.progressiveLightMap2.texture;
+      object.material.dithering = true;
+      object.castShadow = true;
+      object.receiveShadow = true;
+      object.renderOrder = 1e3 + ob;
+      this.uv_boxes.push({ w: 1 + padding * 2, h: 1 + padding * 2, index: ob });
+      this.lightMapContainers.push({ basicMat: object.material, object });
+      this.compiled = false;
+    }
+    const dimensions = potpack(this.uv_boxes);
+    this.uv_boxes.forEach((box) => {
+      const uv2 = objects[box.index].geometry.getAttribute("uv").clone();
+      for (let i = 0; i < uv2.array.length; i += uv2.itemSize) {
+        uv2.array[i] = (uv2.array[i] + box.x + padding) / dimensions.w;
+        uv2.array[i + 1] = (uv2.array[i + 1] + box.y + padding) / dimensions.h;
+      }
+      objects[box.index].geometry.setAttribute("uv2", uv2);
+      objects[box.index].geometry.getAttribute("uv2").needsUpdate = true;
+    });
+  }
+  /**
+   * This function renders each mesh one at a time into their respective surface maps
+   * @param {Camera} camera Standard Rendering Camera
+   * @param {number} blendWindow When >1, samples will accumulate over time.
+   * @param {boolean} blurEdges  Whether to fix UV Edges via blurring
+   */
+  update(camera, blendWindow = 100, blurEdges = true) {
+    if (this.blurringPlane == null) {
+      return;
+    }
+    const oldTarget = this.renderer.getRenderTarget();
+    this.blurringPlane.visible = blurEdges;
+    for (let l = 0; l < this.lightMapContainers.length; l++) {
+      this.lightMapContainers[l].object.oldScene = this.lightMapContainers[l].object.parent;
+      this.scene.attach(this.lightMapContainers[l].object);
+    }
+    if (this.firstUpdate) {
+      this.renderer.setRenderTarget(this.tinyTarget);
+      this.renderer.render(this.scene, camera);
+      this.firstUpdate = false;
+    }
+    for (let l = 0; l < this.lightMapContainers.length; l++) {
+      this.uvMat.uniforms.averagingWindow = { value: blendWindow };
+      this.lightMapContainers[l].object.material = this.uvMat;
+      this.lightMapContainers[l].object.oldFrustumCulled = this.lightMapContainers[l].object.frustumCulled;
+      this.lightMapContainers[l].object.frustumCulled = false;
+    }
+    const activeMap = this.buffer1Active ? this.progressiveLightMap1 : this.progressiveLightMap2;
+    const inactiveMap = this.buffer1Active ? this.progressiveLightMap2 : this.progressiveLightMap1;
+    this.renderer.setRenderTarget(activeMap);
+    this.uvMat.uniforms.previousShadowMap = { value: inactiveMap.texture };
+    this.blurringPlane.material.uniforms.previousShadowMap = { value: inactiveMap.texture };
+    this.buffer1Active = !this.buffer1Active;
+    this.renderer.render(this.scene, camera);
+    for (let l = 0; l < this.lightMapContainers.length; l++) {
+      this.lightMapContainers[l].object.frustumCulled = this.lightMapContainers[l].object.oldFrustumCulled;
+      this.lightMapContainers[l].object.material = this.lightMapContainers[l].basicMat;
+      this.lightMapContainers[l].object.oldScene.attach(this.lightMapContainers[l].object);
+    }
+    this.renderer.setRenderTarget(oldTarget);
+  }
+  /** DEBUG
+   * Draw the lightmap in the main scene.  Call this after adding the objects to it.
+   * @param {boolean} visible Whether the debug plane should be visible
+   * @param {Vector3} position Where the debug plane should be drawn
+   */
+  showDebugLightmap(visible, position = void 0) {
+    if (this.lightMapContainers.length == 0) {
+      if (!this.warned) {
+        console.warn("Call this after adding the objects!");
+        this.warned = true;
+      }
+      return;
+    }
+    if (this.labelMesh == null) {
+      this.labelMaterial = new MeshBasicMaterial({
+        map: this.progressiveLightMap1.texture,
+        side: DoubleSide
+      });
+      this.labelPlane = new PlaneGeometry(100, 100);
+      this.labelMesh = new Mesh(this.labelPlane, this.labelMaterial);
+      this.labelMesh.position.y = 250;
+      this.lightMapContainers[0].object.parent.add(this.labelMesh);
+    }
+    if (position != void 0) {
+      this.labelMesh.position.copy(position);
+    }
+    this.labelMesh.visible = visible;
+  }
+  /**
+   * INTERNAL Creates the Blurring Plane
+   * @param {number} res The square resolution of this object's lightMap.
+   * @param {WebGLRenderTexture} lightMap The lightmap to initialize the plane with.
+   */
+  _initializeBlurPlane(res, lightMap = null) {
+    const blurMaterial = new MeshBasicMaterial();
+    blurMaterial.uniforms = {
+      previousShadowMap: { value: null },
+      pixelOffset: { value: 1 / res },
+      polygonOffset: true,
+      polygonOffsetFactor: -1,
+      polygonOffsetUnits: 3
+    };
+    blurMaterial.onBeforeCompile = (shader) => {
+      shader.vertexShader = "#define USE_UV\n" + shader.vertexShader.slice(0, -1) + "	gl_Position = vec4((uv - 0.5) * 2.0, 1.0, 1.0); }";
+      const bodyStart = shader.fragmentShader.indexOf("void main() {");
+      shader.fragmentShader = "#define USE_UV\n" + shader.fragmentShader.slice(0, bodyStart) + "	uniform sampler2D previousShadowMap;\n	uniform float pixelOffset;\n" + shader.fragmentShader.slice(bodyStart - 1, -1) + `	gl_FragColor.rgb = (
+			  texture2D(previousShadowMap, vUv + vec2( pixelOffset,  0.0        )).rgb +
+			  texture2D(previousShadowMap, vUv + vec2( 0.0        ,  pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2( 0.0        , -pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2(-pixelOffset,  0.0        )).rgb +
+			  texture2D(previousShadowMap, vUv + vec2( pixelOffset,  pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2(-pixelOffset,  pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2( pixelOffset, -pixelOffset)).rgb +
+			  texture2D(previousShadowMap, vUv + vec2(-pixelOffset, -pixelOffset)).rgb)/8.0;
+		}`;
+      shader.uniforms.previousShadowMap = { value: lightMap.texture };
+      shader.uniforms.pixelOffset = { value: 0.5 / res };
+      blurMaterial.uniforms = shader.uniforms;
+      blurMaterial.userData.shader = shader;
+      this.compiled = true;
+    };
+    this.blurringPlane = new Mesh(new PlaneGeometry(1, 1), blurMaterial);
+    this.blurringPlane.name = "Blurring Plane";
+    this.blurringPlane.frustumCulled = false;
+    this.blurringPlane.renderOrder = 0;
+    this.blurringPlane.material.depthWrite = false;
+    this.scene.add(this.blurringPlane);
+  }
+}
+export {
+  ProgressiveLightMap
+};

package/dist/misc/RollerCoaster.d.ts

@@ -0,0 +1,21 @@
+import { BufferGeometry, Curve, Mesh, Vector3 } from 'three'
+
+export class RollerCoasterGeometry extends BufferGeometry {
+  constructor(curve: Curve<Vector3>, divisions: number)
+}
+
+export class RollerCoasterLiftersGeometry extends BufferGeometry {
+  constructor(curve: Curve<Vector3>, divisions: number)
+}
+
+export class RollerCoasterShadowGeometry extends BufferGeometry {
+  constructor(curve: Curve<Vector3>, divisions: number)
+}
+
+export class SkyGeometry extends BufferGeometry {
+  constructor(curve: Curve<Vector3>, divisions: number)
+}
+
+export class TreesGeometry extends BufferGeometry {
+  constructor(landscape: Mesh)
+}