three-stdlib 2.22.8 → 2.22.10

package/dist/misc/MD2CharacterComplex.mjs

@@ -1,62 +1,63 @@
-import { Object3D, Box3, MathUtils, TextureLoader, UVMapping, MeshLambertMaterial } from "three";
+import { Object3D, TextureLoader, UVMapping, Box3, MathUtils, MeshLambertMaterial } from "three";
 import { MD2Loader } from "../loaders/MD2Loader.mjs";
 import { MorphBlendMesh } from "./MorphBlendMesh.mjs";
-var MD2CharacterComplex = function() {
-  var scope = this;
-  this.scale = 1;
-  this.animationFPS = 6;
-  this.transitionFrames = 15;
-  this.maxSpeed = 275;
-  this.maxReverseSpeed = -275;
-  this.frontAcceleration = 600;
-  this.backAcceleration = 600;
-  this.frontDecceleration = 600;
-  this.angularSpeed = 2.5;
-  this.root = new Object3D();
-  this.meshBody = null;
-  this.meshWeapon = null;
-  this.controls = null;
-  this.skinsBody = [];
-  this.skinsWeapon = [];
-  this.weapons = [];
-  this.currentSkin = void 0;
-  this.onLoadComplete = function() {
-  };
-  this.meshes = [];
-  this.animations = {};
-  this.loadCounter = 0;
-  this.speed = 0;
-  this.bodyOrientation = 0;
-  this.walkSpeed = this.maxSpeed;
-  this.crouchSpeed = this.maxSpeed * 0.5;
-  this.activeAnimation = null;
-  this.oldAnimation = null;
-  this.enableShadows = function(enable) {
+class MD2CharacterComplex {
+  constructor() {
+    this.scale = 1;
+    this.animationFPS = 6;
+    this.transitionFrames = 15;
+    this.maxSpeed = 275;
+    this.maxReverseSpeed = -275;
+    this.frontAcceleration = 600;
+    this.backAcceleration = 600;
+    this.frontDecceleration = 600;
+    this.angularSpeed = 2.5;
+    this.root = new Object3D();
+    this.meshBody = null;
+    this.meshWeapon = null;
+    this.controls = null;
+    this.skinsBody = [];
+    this.skinsWeapon = [];
+    this.weapons = [];
+    this.currentSkin = void 0;
+    this.onLoadComplete = function() {
+    };
+    this.meshes = [];
+    this.animations = {};
+    this.loadCounter = 0;
+    this.speed = 0;
+    this.bodyOrientation = 0;
+    this.walkSpeed = this.maxSpeed;
+    this.crouchSpeed = this.maxSpeed * 0.5;
+    this.activeAnimation = null;
+    this.oldAnimation = null;
+  }
+  enableShadows(enable) {
     for (let i = 0; i < this.meshes.length; i++) {
       this.meshes[i].castShadow = enable;
       this.meshes[i].receiveShadow = enable;
     }
-  };
-  this.setVisible = function(enable) {
+  }
+  setVisible(enable) {
     for (let i = 0; i < this.meshes.length; i++) {
       this.meshes[i].visible = enable;
       this.meshes[i].visible = enable;
     }
-  };
-  this.shareParts = function(original) {
+  }
+  shareParts(original) {
     this.animations = original.animations;
     this.walkSpeed = original.walkSpeed;
     this.crouchSpeed = original.crouchSpeed;
     this.skinsBody = original.skinsBody;
     this.skinsWeapon = original.skinsWeapon;
-    var mesh = createPart(original.meshBody.geometry, this.skinsBody[0]);
+    const mesh = this._createPart(original.meshBody.geometry, this.skinsBody[0]);
     mesh.scale.set(this.scale, this.scale, this.scale);
     this.root.position.y = original.root.position.y;
     this.root.add(mesh);
     this.meshBody = mesh;
     this.meshes.push(mesh);
     for (let i = 0; i < original.weapons.length; i++) {
-      var meshWeapon = createPart(original.weapons[i].geometry, this.skinsWeapon[i]);
+      const meshWeapon = this._createPart(original.weapons[i].geometry, this.skinsWeapon[i]);
       meshWeapon.scale.set(this.scale, this.scale, this.scale);
       meshWeapon.visible = false;
       meshWeapon.name = original.weapons[i].name;
@@ -65,32 +66,52 @@ var MD2CharacterComplex = function() {
       this.meshWeapon = meshWeapon;
       this.meshes.push(meshWeapon);
     }
-  };
-  this.loadParts = function(config) {
+  }
+  loadParts(config) {
+    const scope = this;
+    function loadTextures(baseUrl, textureUrls) {
+      const textureLoader = new TextureLoader();
+      const textures = [];
+      for (let i = 0; i < textureUrls.length; i++) {
+        textures[i] = textureLoader.load(baseUrl + textureUrls[i], checkLoadingComplete);
+        textures[i].mapping = UVMapping;
+        textures[i].name = textureUrls[i];
+        if ("colorSpace" in textures[i])
+          textures[i].colorSpace = "srgb";
+        else
+          textures[i].encoding = 3001;
+      }
+      return textures;
+    }
+    function checkLoadingComplete() {
+      scope.loadCounter -= 1;
+      if (scope.loadCounter === 0)
+        scope.onLoadComplete();
+    }
     this.animations = config.animations;
     this.walkSpeed = config.walkSpeed;
     this.crouchSpeed = config.crouchSpeed;
     this.loadCounter = config.weapons.length * 2 + config.skins.length + 1;
-    var weaponsTextures = [];
+    const weaponsTextures = [];
     for (let i = 0; i < config.weapons.length; i++)
       weaponsTextures[i] = config.weapons[i][1];
     this.skinsBody = loadTextures(config.baseUrl + "skins/", config.skins);
     this.skinsWeapon = loadTextures(config.baseUrl + "skins/", weaponsTextures);
-    var loader = new MD2Loader();
+    const loader = new MD2Loader();
     loader.load(config.baseUrl + config.body, function(geo) {
-      var boundingBox = new Box3();
+      const boundingBox = new Box3();
       boundingBox.setFromBufferAttribute(geo.attributes.position);
       scope.root.position.y = -scope.scale * boundingBox.min.y;
-      var mesh = createPart(geo, scope.skinsBody[0]);
+      const mesh = scope._createPart(geo, scope.skinsBody[0]);
       mesh.scale.set(scope.scale, scope.scale, scope.scale);
       scope.root.add(mesh);
       scope.meshBody = mesh;
       scope.meshes.push(mesh);
       checkLoadingComplete();
     });
-    var generateCallback = function(index, name) {
+    const generateCallback = function(index, name) {
       return function(geo) {
-        var mesh = createPart(geo, scope.skinsWeapon[index]);
+        const mesh = scope._createPart(geo, scope.skinsWeapon[index]);
         mesh.scale.set(scope.scale, scope.scale, scope.scale);
         mesh.visible = false;
         mesh.name = name;
@@ -104,14 +125,14 @@ var MD2CharacterComplex = function() {
     for (let i = 0; i < config.weapons.length; i++) {
       loader.load(config.baseUrl + config.weapons[i][0], generateCallback(i, config.weapons[i][0]));
     }
-  };
-  this.setPlaybackRate = function(rate) {
+  }
+  setPlaybackRate(rate) {
     if (this.meshBody)
       this.meshBody.duration = this.meshBody.baseDuration / rate;
     if (this.meshWeapon)
       this.meshWeapon.duration = this.meshWeapon.baseDuration / rate;
-  };
-  this.setWireframe = function(wireframeEnabled) {
+  }
+  setWireframe(wireframeEnabled) {
     if (wireframeEnabled) {
       if (this.meshBody)
         this.meshBody.material = this.meshBody.materialWireframe;
@@ -123,17 +144,17 @@ var MD2CharacterComplex = function() {
       if (this.meshWeapon)
         this.meshWeapon.material = this.meshWeapon.materialTexture;
     }
-  };
-  this.setSkin = function(index) {
+  }
+  setSkin(index) {
     if (this.meshBody && this.meshBody.material.wireframe === false) {
       this.meshBody.material.map = this.skinsBody[index];
       this.currentSkin = index;
     }
-  };
-  this.setWeapon = function(index) {
+  }
+  setWeapon(index) {
     for (let i = 0; i < this.weapons.length; i++)
       this.weapons[i].visible = false;
-    var activeWeapon = this.weapons[index];
+    const activeWeapon = this.weapons[index];
     if (activeWeapon) {
       activeWeapon.visible = true;
       this.meshWeapon = activeWeapon;
@@ -142,8 +163,8 @@ var MD2CharacterComplex = function() {
         this.meshWeapon.setAnimationTime(this.activeAnimation, this.meshBody.getAnimationTime(this.activeAnimation));
       }
     }
-  };
-  this.setAnimation = function(animationName) {
+  }
+  setAnimation(animationName) {
     if (animationName === this.activeAnimation || !animationName)
       return;
     if (this.meshBody) {
@@ -157,17 +178,17 @@ var MD2CharacterComplex = function() {
       this.meshWeapon.setAnimationWeight(animationName, 0);
       this.meshWeapon.playAnimation(animationName);
     }
-  };
-  this.update = function(delta) {
+  }
+  update(delta) {
     if (this.controls)
       this.updateMovementModel(delta);
     if (this.animations) {
       this.updateBehaviors();
       this.updateAnimations(delta);
     }
-  };
-  this.updateAnimations = function(delta) {
-    var mix = 1;
+  }
+  updateAnimations(delta) {
+    let mix = 1;
     if (this.blendCounter > 0) {
       mix = (this.transitionFrames - this.blendCounter) / this.transitionFrames;
       this.blendCounter -= 1;
@@ -182,11 +203,11 @@ var MD2CharacterComplex = function() {
       this.meshWeapon.setAnimationWeight(this.activeAnimation, mix);
       this.meshWeapon.setAnimationWeight(this.oldAnimation, 1 - mix);
     }
-  };
-  this.updateBehaviors = function() {
-    var controls = this.controls;
-    var animations = this.animations;
-    var moveAnimation, idleAnimation;
+  }
+  updateBehaviors() {
+    const controls = this.controls;
+    const animations = this.animations;
+    let moveAnimation, idleAnimation;
     if (controls.crouch) {
       moveAnimation = animations["crouchMove"];
       idleAnimation = animations["crouchIdle"];
@@ -237,21 +258,22 @@ var MD2CharacterComplex = function() {
         this.meshWeapon.setAnimationDirectionBackward(this.oldAnimation);
       }
     }
-  };
-  this.updateMovementModel = function(delta) {
-    var controls = this.controls;
+  }
+  updateMovementModel(delta) {
+    function exponentialEaseOut(k) {
+      return k === 1 ? 1 : -Math.pow(2, -10 * k) + 1;
+    }
+    const controls = this.controls;
     if (controls.crouch)
       this.maxSpeed = this.crouchSpeed;
     else
       this.maxSpeed = this.walkSpeed;
     this.maxReverseSpeed = -this.maxSpeed;
-    if (controls.moveForward) {
+    if (controls.moveForward)
       this.speed = MathUtils.clamp(this.speed + delta * this.frontAcceleration, this.maxReverseSpeed, this.maxSpeed);
-    }
-    if (controls.moveBackward) {
+    if (controls.moveBackward)
       this.speed = MathUtils.clamp(this.speed - delta * this.backAcceleration, this.maxReverseSpeed, this.maxSpeed);
-    }
-    var dir = 1;
+    const dir = 1;
     if (controls.moveLeft) {
       this.bodyOrientation += delta * this.angularSpeed;
       this.speed = MathUtils.clamp(
@@ -270,62 +292,41 @@ var MD2CharacterComplex = function() {
     }
     if (!(controls.moveForward || controls.moveBackward)) {
       if (this.speed > 0) {
-        var k = exponentialEaseOut(this.speed / this.maxSpeed);
+        const k = exponentialEaseOut(this.speed / this.maxSpeed);
         this.speed = MathUtils.clamp(this.speed - k * delta * this.frontDecceleration, 0, this.maxSpeed);
       } else {
-        var k = exponentialEaseOut(this.speed / this.maxReverseSpeed);
+        const k = exponentialEaseOut(this.speed / this.maxReverseSpeed);
         this.speed = MathUtils.clamp(this.speed + k * delta * this.backAcceleration, this.maxReverseSpeed, 0);
       }
     }
-    var forwardDelta = this.speed * delta;
+    const forwardDelta = this.speed * delta;
     this.root.position.x += Math.sin(this.bodyOrientation) * forwardDelta;
     this.root.position.z += Math.cos(this.bodyOrientation) * forwardDelta;
     this.root.rotation.y = this.bodyOrientation;
-  };
-  function loadTextures(baseUrl, textureUrls) {
-    var textureLoader = new TextureLoader();
-    var textures = [];
-    for (let i = 0; i < textureUrls.length; i++) {
-      textures[i] = textureLoader.load(baseUrl + textureUrls[i], checkLoadingComplete);
-      textures[i].mapping = UVMapping;
-      textures[i].name = textureUrls[i];
-      if ("colorSpace" in textures[i])
-        textures[i].colorSpace = "srgb";
-      else
-        textures[i].encoding = 3001;
-    }
-    return textures;
   }
-  function createPart(geometry, skinMap) {
-    var materialWireframe = new MeshLambertMaterial({
+  // internal
+  _createPart(geometry, skinMap) {
+    const materialWireframe = new MeshLambertMaterial({
       color: 16755200,
       wireframe: true,
       morphTargets: true,
       morphNormals: true
     });
-    var materialTexture = new MeshLambertMaterial({
+    const materialTexture = new MeshLambertMaterial({
       color: 16777215,
       wireframe: false,
       map: skinMap,
       morphTargets: true,
       morphNormals: true
     });
-    var mesh = new MorphBlendMesh(geometry, materialTexture);
+    const mesh = new MorphBlendMesh(geometry, materialTexture);
     mesh.rotation.y = -Math.PI / 2;
     mesh.materialTexture = materialTexture;
     mesh.materialWireframe = materialWireframe;
-    mesh.autoCreateAnimations(scope.animationFPS);
+    mesh.autoCreateAnimations(this.animationFPS);
     return mesh;
   }
-  function checkLoadingComplete() {
-    scope.loadCounter -= 1;
-    if (scope.loadCounter === 0)
-      scope.onLoadComplete();
-  }
-  function exponentialEaseOut(k) {
-    return k === 1 ? 1 : -Math.pow(2, -10 * k) + 1;
-  }
-};
+}
 export {
   MD2CharacterComplex
 };

package/dist/misc/MorphAnimMesh.d.ts

@@ -9,5 +9,5 @@ export class MorphAnimMesh extends Mesh {
   setDirectionBackward(): void
   playAnimation(label: string, fps: number): void
   updateAnimation(delta: number): void
-  copy(source: MorphAnimMesh): this
+  copy(source: MorphAnimMesh, recursive?: boolean): this
 }

package/dist/misc/MorphAnimMesh.js

@@ -1,40 +1,40 @@
 "use strict";
 Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
 const THREE = require("three");
-var MorphAnimMesh = function(geometry, material) {
-  THREE.Mesh.call(this, geometry, material);
-  this.type = "MorphAnimMesh";
-  this.mixer = new THREE.AnimationMixer(this);
-  this.activeAction = null;
-};
-MorphAnimMesh.prototype = Object.create(THREE.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();
+class MorphAnimMesh extends THREE.Mesh {
+  constructor(geometry, material) {
+    super(geometry, material);
+    this.type = "MorphAnimMesh";
+    this.mixer = new THREE.AnimationMixer(this);
     this.activeAction = null;
   }
-  var clip = THREE.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()");
+  setDirectionForward() {
+    this.mixer.timeScale = 1;
   }
-};
-MorphAnimMesh.prototype.updateAnimation = function(delta) {
-  this.mixer.update(delta);
-};
-MorphAnimMesh.prototype.copy = function(source) {
-  THREE.Mesh.prototype.copy.call(this, source);
-  this.mixer = new THREE.AnimationMixer(this);
-  return this;
-};
+  setDirectionBackward() {
+    this.mixer.timeScale = -1;
+  }
+  playAnimation(label, fps) {
+    if (this.activeAction) {
+      this.activeAction.stop();
+      this.activeAction = null;
+    }
+    const clip = THREE.AnimationClip.findByName(this, label);
+    if (clip) {
+      const 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()");
+    }
+  }
+  updateAnimation(delta) {
+    this.mixer.update(delta);
+  }
+  copy(source, recursive) {
+    super.copy(source, recursive);
+    this.mixer = new THREE.AnimationMixer(this);
+    return this;
+  }
+}
 exports.MorphAnimMesh = MorphAnimMesh;

package/dist/misc/MorphAnimMesh.mjs

@@ -1,40 +1,40 @@
 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();
+class MorphAnimMesh extends Mesh {
+  constructor(geometry, material) {
+    super(geometry, material);
+    this.type = "MorphAnimMesh";
+    this.mixer = new AnimationMixer(this);
     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()");
+  setDirectionForward() {
+    this.mixer.timeScale = 1;
   }
-};
-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;
-};
+  setDirectionBackward() {
+    this.mixer.timeScale = -1;
+  }
+  playAnimation(label, fps) {
+    if (this.activeAction) {
+      this.activeAction.stop();
+      this.activeAction = null;
+    }
+    const clip = AnimationClip.findByName(this, label);
+    if (clip) {
+      const 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()");
+    }
+  }
+  updateAnimation(delta) {
+    this.mixer.update(delta);
+  }
+  copy(source, recursive) {
+    super.copy(source, recursive);
+    this.mixer = new AnimationMixer(this);
+    return this;
+  }
+}
 export {
   MorphAnimMesh
 };