three-stdlib 2.15.2 → 2.16.1

package/misc/MorphAnimMesh.mjs

@@ -1,40 +0,0 @@
-import { Mesh, AnimationMixer, AnimationClip } from "three";
-var MorphAnimMesh = function(geometry, material) {
-  Mesh.call(this, geometry, material);
-  this.type = "MorphAnimMesh";
-  this.mixer = new AnimationMixer(this);
-  this.activeAction = null;
-};
-MorphAnimMesh.prototype = Object.create(Mesh.prototype);
-MorphAnimMesh.prototype.constructor = MorphAnimMesh;
-MorphAnimMesh.prototype.setDirectionForward = function() {
-  this.mixer.timeScale = 1;
-};
-MorphAnimMesh.prototype.setDirectionBackward = function() {
-  this.mixer.timeScale = -1;
-};
-MorphAnimMesh.prototype.playAnimation = function(label, fps) {
-  if (this.activeAction) {
-    this.activeAction.stop();
-    this.activeAction = null;
-  }
-  var clip = AnimationClip.findByName(this, label);
-  if (clip) {
-    var action = this.mixer.clipAction(clip);
-    action.timeScale = clip.tracks.length * fps / clip.duration;
-    this.activeAction = action.play();
-  } else {
-    throw new Error("THREE.MorphAnimMesh: animations[" + label + "] undefined in .playAnimation()");
-  }
-};
-MorphAnimMesh.prototype.updateAnimation = function(delta) {
-  this.mixer.update(delta);
-};
-MorphAnimMesh.prototype.copy = function(source) {
-  Mesh.prototype.copy.call(this, source);
-  this.mixer = new AnimationMixer(this);
-  return this;
-};
-export {
-  MorphAnimMesh
-};

package/misc/MorphBlendMesh.mjs

@@ -1,179 +0,0 @@
-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/misc/ProgressiveLightmap.mjs

@@ -1,166 +0,0 @@
-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;
-    };
-  }
-  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;
-    });
-  }
-  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);
-  }
-  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;
-  }
-  _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
-};